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

core/apps.py

@@ -38,6 +38,7 @@ class CoreConfig(AppConfig):
             patch_admin_sigil_builder_view,
             generate_model_sigils,
         )
+        from .celery_utils import normalize_periodic_task_name
         from .admin_history import patch_admin_history
 
         from django_otp.plugins.otp_totp.models import TOTPDevice as OTP_TOTPDevice
@@ -222,8 +223,11 @@ class CoreConfig(AppConfig):
                     schedule, _ = IntervalSchedule.objects.get_or_create(
                         every=1, period=IntervalSchedule.HOURS
                     )
-                    PeriodicTask.objects.get_or_create(
-                        name="poll_email_collectors",
+                    task_name = normalize_periodic_task_name(
+                        PeriodicTask.objects, "poll_email_collectors"
+                    )
+                    PeriodicTask.objects.update_or_create(
+                        name=task_name,
                         defaults={
                             "interval": schedule,
                             "task": "core.tasks.poll_email_collectors",
@@ -348,9 +352,3 @@ class CoreConfig(AppConfig):
             weak=False,
         )
 
-        try:
-            from .mcp.auto_start import schedule_auto_start
-
-            schedule_auto_start(check_profiles_immediately=False)
-        except Exception:  # pragma: no cover - defensive
-            logger.exception("Failed to schedule MCP auto-start")

core/auto_upgrade.py

@@ -10,6 +10,14 @@ from django.conf import settings
 AUTO_UPGRADE_TASK_NAME = "auto-upgrade-check"
 AUTO_UPGRADE_TASK_PATH = "core.tasks.check_github_updates"
 
+DEFAULT_AUTO_UPGRADE_MODE = "version"
+AUTO_UPGRADE_INTERVAL_MINUTES = {
+    "latest": 5,
+    "stable": 60,
+    DEFAULT_AUTO_UPGRADE_MODE: 720,
+}
+AUTO_UPGRADE_FALLBACK_INTERVAL = AUTO_UPGRADE_INTERVAL_MINUTES["stable"]
+
 
 def ensure_auto_upgrade_periodic_task(
     sender=None, *, base_dir: Path | None = None, **kwargs
@@ -30,8 +38,6 @@ def ensure_auto_upgrade_periodic_task(
 
     lock_dir = base_dir / "locks"
     mode_file = lock_dir / "auto_upgrade.lck"
-    if not mode_file.exists():
-        return
 
     try:  # pragma: no cover - optional dependency failures
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
@@ -39,8 +45,17 @@ def ensure_auto_upgrade_periodic_task(
     except Exception:
         return
 
-    _mode = mode_file.read_text().strip() or "version"
-    interval_minutes = 5
+    if not mode_file.exists():
+        try:
+            PeriodicTask.objects.filter(name=AUTO_UPGRADE_TASK_NAME).delete()
+        except (OperationalError, ProgrammingError):  # pragma: no cover - DB not ready
+            return
+        return
+
+    _mode = mode_file.read_text().strip().lower() or DEFAULT_AUTO_UPGRADE_MODE
+    interval_minutes = AUTO_UPGRADE_INTERVAL_MINUTES.get(
+        _mode, AUTO_UPGRADE_FALLBACK_INTERVAL
+    )
 
     try:
         schedule, _ = IntervalSchedule.objects.get_or_create(

core/backends.py

@@ -81,15 +81,22 @@ class RFIDBackend:
         if not rfid_value:
             return None
 
-        tag = RFID.objects.filter(rfid=rfid_value).first()
-        if not tag or not tag.allowed:
+        tag = RFID.matching_queryset(rfid_value).filter(allowed=True).first()
+        if not tag:
             return None
 
+        update_fields: list[str] = []
+        if tag.adopt_rfid(rfid_value):
+            update_fields.append("rfid")
+        if update_fields:
+            tag.save(update_fields=update_fields)
+
         command = (tag.external_command or "").strip()
         if command:
             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 +124,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,
@@ -209,7 +217,9 @@ class LocalhostAdminBackend(ModelBackend):
             try:
                 ipaddress.ip_address(host)
             except ValueError:
-                if not self._is_test_environment(request):
+                if host.lower() == "localhost":
+                    host = "127.0.0.1"
+                elif not self._is_test_environment(request):
                     return None
             forwarded = request.META.get("HTTP_X_FORWARDED_FOR")
             if forwarded:

core/celery_utils.py

@@ -0,0 +1,73 @@
+"""Utilities for working with Celery periodic task names."""
+
+from __future__ import annotations
+
+import re
+from typing import Set
+
+from django.db import transaction
+from django.db.utils import IntegrityError
+
+
+def slugify_task_name(name: str) -> str:
+    """Return a slugified task name using dashes.
+
+    Celery stores periodic task names in the database and historically these
+    values included underscores or dotted module paths. The scheduler UI reads
+    these values directly, so we collapse consecutive underscores or dots into a
+    single dash to keep them human readable while remaining unique.
+    """
+
+    slug = re.sub(r"[._]+", "-", name)
+    # Collapse any accidental duplicate separators that may result from the
+    # replacement so ``foo__bar`` and ``foo..bar`` both become ``foo-bar``.
+    slug = re.sub(r"-{2,}", "-", slug)
+    return slug
+
+
+def periodic_task_name_variants(name: str) -> Set[str]:
+    """Return legacy and slugified variants for a periodic task name."""
+
+    slug = slugify_task_name(name)
+    if slug == name:
+        return {name}
+    return {name, slug}
+
+
+def normalize_periodic_task_name(manager, name: str) -> str:
+    """Ensure the stored periodic task name matches the slugified form.
+
+    The helper renames any rows that still use the legacy value so that follow-up
+    ``update_or_create`` calls keep working without leaving duplicate tasks in
+    the scheduler. When a conflicting slug already exists we keep the slugged
+    version and remove the legacy entry.
+    """
+
+    slug = slugify_task_name(name)
+    if slug == name:
+        return slug
+
+    for task in manager.filter(name=name):
+        conflict = manager.filter(name=slug).exclude(pk=task.pk).first()
+        if conflict:
+            # Preserve foreign key references when possible before removing the
+            # legacy row.
+            related_attr = getattr(task, "client_report_schedule", None)
+            if related_attr and getattr(conflict, "client_report_schedule", None) is None:
+                related_attr.periodic_task = conflict
+                related_attr.save(update_fields=["periodic_task"])
+            task.delete()
+            continue
+
+        task.name = slug
+        try:
+            with transaction.atomic():
+                task.save(update_fields=["name"])
+        except IntegrityError:
+            # Another process may have created the slug in between the select and
+            # the update. Fall back to deleting the legacy row to avoid duplicate
+            # scheduler entries.
+            task.refresh_from_db()
+            if task.name != slug:
+                task.delete()
+    return slug

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
 
 

core/environment.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-
 from django.conf import settings
 from django.contrib import admin
 from django.template.response import TemplateResponse
@@ -20,18 +19,18 @@ def _environment_view(request):
     context = admin.site.each_context(request)
     context.update(
         {
-            "title": _("Environ"),
+            "title": _("Environment"),
             "env_vars": env_vars,
+            "environment_tasks": [],
         }
     )
     return TemplateResponse(request, "admin/environment.html", context)
 
-
 def _config_view(request):
     context = admin.site.each_context(request)
     context.update(
         {
-            "title": _("Config"),
+            "title": _("Django Config"),
             "django_settings": _get_django_settings(),
         }
     )
@@ -39,7 +38,7 @@ def _config_view(request):
 
 
 def patch_admin_environment_view() -> None:
-    """Add custom admin view for environment information."""
+    """Register the Environment and Config admin views on the main admin site."""
     original_get_urls = admin.site.get_urls
 
     def get_urls():