arthexis 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

core/form_fields.py

@@ -0,0 +1,75 @@
+"""Custom form fields for the Arthexis admin."""
+
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+from django.core.exceptions import ValidationError
+from django.forms.fields import FileField
+from django.forms.widgets import FILE_INPUT_CONTRADICTION
+from django.utils.translation import gettext_lazy as _
+
+from .widgets import AdminBase64FileWidget
+
+
+class Base64FileField(FileField):
+    """Form field storing uploaded files as base64 encoded strings.
+
+    The field behaves like :class:`~django.forms.FileField` from the user's
+    perspective. Uploaded files are converted to base64 and returned as text so
+    they can be stored in ``TextField`` columns. When no new file is uploaded the
+    initial base64 value is preserved, while clearing the field stores an empty
+    string.
+    """
+
+    widget = AdminBase64FileWidget
+    default_error_messages = {
+        **FileField.default_error_messages,
+        "contradiction": _(
+            "Please either submit a file or check the clear checkbox, not both."
+        ),
+    }
+
+    def __init__(
+        self,
+        *,
+        download_name: str | None = None,
+        content_type: str = "application/octet-stream",
+        **kwargs: Any,
+    ) -> None:
+        widget = kwargs.pop("widget", None) or self.widget()
+        if download_name:
+            widget.download_name = download_name
+        if content_type:
+            widget.content_type = content_type
+        super().__init__(widget=widget, **kwargs)
+
+    def to_python(self, data: Any) -> str | None:
+        """Convert uploaded data to a base64 string."""
+
+        if isinstance(data, str):
+            return data
+        uploaded = super().to_python(data)
+        if uploaded is None:
+            return None
+        content = uploaded.read()
+        if hasattr(uploaded, "seek"):
+            uploaded.seek(0)
+        return base64.b64encode(content).decode("ascii")
+
+    def clean(self, data: Any, initial: str | None = None) -> str:
+        if data is FILE_INPUT_CONTRADICTION:
+            raise ValidationError(
+                self.error_messages["contradiction"], code="contradiction"
+            )
+        cleaned = super().clean(data, initial)
+        if cleaned in {None, False}:
+            return ""
+        return cleaned
+
+    def bound_data(self, data: Any, initial: str | None) -> str | None:
+        return initial
+
+    def has_changed(self, initial: str | None, data: Any) -> bool:
+        return not self.disabled and data is not None

core/models.py

@@ -3,7 +3,7 @@ from django.contrib.auth.models import (
     Group,
     UserManager as DjangoUserManager,
 )
-from django.db import models
+from django.db import DatabaseError, models
 from django.db.models import Q
 from django.db.models.functions import Lower
 from django.conf import settings
@@ -16,6 +16,7 @@ from django.db.models.signals import m2m_changed, post_delete, post_save
 from django.dispatch import receiver
 from django.views.decorators.debug import sensitive_variables
 from datetime import time as datetime_time, timedelta
+import logging
 from django.contrib.contenttypes.models import ContentType
 import hashlib
 import os
@@ -37,8 +38,20 @@ from defusedxml import xmlrpc as defused_xmlrpc
 defused_xmlrpc.monkey_patch()
 xmlrpc_client = defused_xmlrpc.xmlrpc_client
 
+logger = logging.getLogger(__name__)
+
 from .entity import Entity, EntityUserManager, EntityManager
-from .release import Package as ReleasePackage, Credentials, DEFAULT_PACKAGE
+from .release import (
+    Package as ReleasePackage,
+    Credentials,
+    DEFAULT_PACKAGE,
+)
+
+
+def default_package_modules() -> list[str]:
+    """Return the default package module list."""
+
+    return list(DEFAULT_PACKAGE.packages)
 from . import temp_passwords
 from . import user_data  # noqa: F401 - ensure signal registration
 from .fields import (
@@ -593,6 +606,15 @@ class OdooProfile(Profile):
                 kwargs,
             )
         except Exception:
+            logger.exception(
+                "Odoo RPC %s.%s failed for profile %s (host=%s, database=%s, username=%s)",
+                model,
+                method,
+                self.pk,
+                self.host,
+                self.database,
+                self.username,
+            )
             self._clear_verification()
             self.save(update_fields=["verified_on"])
             raise
@@ -753,66 +775,93 @@ class EmailInbox(Profile):
             import imaplib
             import email
 
+            def _decode_imap_bytes(value):
+                if isinstance(value, bytes):
+                    return value.decode("utf-8", errors="ignore")
+                return str(value)
+
             conn = (
                 imaplib.IMAP4_SSL(self.host, self.port)
                 if self.use_ssl
                 else imaplib.IMAP4(self.host, self.port)
             )
-            conn.login(self.username, self.password)
-            conn.select("INBOX")
-            fetch_limit = limit if not use_regular_expressions else max(limit * 5, limit)
-            if use_regular_expressions:
-                typ, data = conn.search(None, "ALL")
-            else:
-                criteria = []
-                charset = None
-
-                def _append(term: str, value: str):
-                    nonlocal charset
-                    if not value:
-                        return
-                    try:
-                        value.encode("ascii")
-                        encoded_value = value
-                    except UnicodeEncodeError:
-                        charset = charset or "UTF-8"
-                        encoded_value = value.encode("utf-8")
-                    criteria.extend([term, encoded_value])
-
-                _append("SUBJECT", subject)
-                _append("FROM", from_address)
-                _append("TEXT", body)
-
-                if not criteria:
+            try:
+                conn.login(self.username, self.password)
+                typ, data = conn.select("INBOX")
+                if typ != "OK":
+                    message = " ".join(_decode_imap_bytes(item) for item in data or [])
+                    if not message:
+                        message = "Unable to select INBOX"
+                    raise ValidationError(message)
+
+                fetch_limit = (
+                    limit if not use_regular_expressions else max(limit * 5, limit)
+                )
+                if use_regular_expressions:
                     typ, data = conn.search(None, "ALL")
                 else:
-                    typ, data = conn.search(charset, *criteria)
-            ids = data[0].split()[-fetch_limit:]
-            messages = []
-            for mid in ids:
-                typ, msg_data = conn.fetch(mid, "(RFC822)")
-                msg = email.message_from_bytes(msg_data[0][1])
-                body_text = _get_body(msg)
-                subj_value = msg.get("Subject", "")
-                from_value = msg.get("From", "")
-                if not (
-                    _matches(subj_value, subject, subject_regex)
-                    and _matches(from_value, from_address, sender_regex)
-                    and _matches(body_text, body, body_regex)
-                ):
-                    continue
-                messages.append(
-                    {
-                        "subject": subj_value,
-                        "from": from_value,
-                        "body": body_text,
-                        "date": msg.get("Date", ""),
-                    }
-                )
-                if len(messages) >= limit:
-                    break
-            conn.logout()
-            return list(reversed(messages))
+                    criteria = []
+                    charset = None
+
+                    def _append(term: str, value: str):
+                        nonlocal charset
+                        if not value:
+                            return
+                        try:
+                            value.encode("ascii")
+                            encoded_value = value
+                        except UnicodeEncodeError:
+                            charset = charset or "UTF-8"
+                            encoded_value = value.encode("utf-8")
+                        criteria.extend([term, encoded_value])
+
+                    _append("SUBJECT", subject)
+                    _append("FROM", from_address)
+                    _append("TEXT", body)
+
+                    if not criteria:
+                        typ, data = conn.search(None, "ALL")
+                    else:
+                        typ, data = conn.search(charset, *criteria)
+
+                if typ != "OK":
+                    message = " ".join(_decode_imap_bytes(item) for item in data or [])
+                    if not message:
+                        message = "Unable to search mailbox"
+                    raise ValidationError(message)
+
+                ids = data[0].split()[-fetch_limit:]
+                messages = []
+                for mid in ids:
+                    typ, msg_data = conn.fetch(mid, "(RFC822)")
+                    if typ != "OK" or not msg_data:
+                        continue
+                    msg = email.message_from_bytes(msg_data[0][1])
+                    body_text = _get_body(msg)
+                    subj_value = msg.get("Subject", "")
+                    from_value = msg.get("From", "")
+                    if not (
+                        _matches(subj_value, subject, subject_regex)
+                        and _matches(from_value, from_address, sender_regex)
+                        and _matches(body_text, body, body_regex)
+                    ):
+                        continue
+                    messages.append(
+                        {
+                            "subject": subj_value,
+                            "from": from_value,
+                            "body": body_text,
+                            "date": msg.get("Date", ""),
+                        }
+                    )
+                    if len(messages) >= limit:
+                        break
+                return list(reversed(messages))
+            finally:
+                try:
+                    conn.logout()
+                except Exception:  # pragma: no cover - best effort cleanup
+                    pass
 
         import poplib
         import email
@@ -1260,11 +1309,34 @@ class RFID(Entity):
         related_name="rfids",
         help_text="Optional reference for this RFID.",
     )
+    origin_node = models.ForeignKey(
+        "nodes.Node",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="created_rfids",
+        help_text="Node where this RFID record was created.",
+    )
     released = models.BooleanField(default=False)
     added_on = models.DateTimeField(auto_now_add=True)
     last_seen_on = models.DateTimeField(null=True, blank=True)
 
     def save(self, *args, **kwargs):
+        update_fields = kwargs.get("update_fields")
+        if not self.origin_node_id:
+            try:
+                from nodes.models import Node  # imported lazily to avoid circular import
+            except Exception:  # pragma: no cover - nodes app may be unavailable
+                node = None
+            else:
+                node = Node.get_local()
+            if node:
+                self.origin_node = node
+                if update_fields:
+                    fields = set(update_fields)
+                    if "origin_node" not in fields:
+                        fields.add("origin_node")
+                        kwargs["update_fields"] = tuple(fields)
         if self.pk:
             old = type(self).objects.filter(pk=self.pk).values("key_a", "key_b").first()
             if old:
@@ -2314,6 +2386,9 @@ class Package(Entity):
     license = models.CharField(max_length=100, default=DEFAULT_PACKAGE.license)
     repository_url = models.URLField(default=DEFAULT_PACKAGE.repository_url)
     homepage_url = models.URLField(default=DEFAULT_PACKAGE.homepage_url)
+    version_path = models.CharField(max_length=255, blank=True, default="")
+    dependencies_path = models.CharField(max_length=255, blank=True, default="")
+    test_command = models.TextField(blank=True, default="")
     release_manager = models.ForeignKey(
         ReleaseManager, on_delete=models.SET_NULL, null=True, blank=True
     )
@@ -2352,12 +2427,22 @@ class Package(Entity):
             license=self.license,
             repository_url=self.repository_url,
             homepage_url=self.homepage_url,
+            version_path=self.version_path or None,
+            dependencies_path=self.dependencies_path or None,
+            test_command=self.test_command or None,
         )
 
 
 class PackageRelease(Entity):
     """Store metadata for a specific package version."""
 
+    _PATCH_BITS = 12
+    _MINOR_BITS = 12
+    _PATCH_MASK = (1 << _PATCH_BITS) - 1
+    _MINOR_MASK = (1 << _MINOR_BITS) - 1
+    _MINOR_SHIFT = _PATCH_BITS
+    _MAJOR_SHIFT = _PATCH_BITS + _MINOR_BITS
+
     objects = PackageReleaseManager()
 
     def natural_key(self):
@@ -2425,14 +2510,18 @@ class PackageRelease(Entity):
         from packaging.version import Version
 
         v = Version(self.version)
-        return (v.major << 2) | (v.minor << 1) | v.micro
+        return (
+            (v.major << self._MAJOR_SHIFT)
+            | (v.minor << self._MINOR_SHIFT)
+            | v.micro
+        )
 
     @staticmethod
     def version_from_migration(number: int) -> str:
         """Return version string encoded by ``number``."""
-        major = (number >> 2) & 0x3FFFFF
-        minor = (number >> 1) & 0x1
-        patch = number & 0x1
+        major = number >> PackageRelease._MAJOR_SHIFT
+        minor = (number >> PackageRelease._MINOR_SHIFT) & PackageRelease._MINOR_MASK
+        patch = number & PackageRelease._PATCH_MASK
         return f"{major}.{minor}.{patch}"
 
     @property
@@ -2460,6 +2549,40 @@ class PackageRelease(Entity):
             return None
         return max(releases, key=lambda r: Version(r.version))
 
+    @classmethod
+    def matches_revision(cls, version: str, revision: str) -> bool:
+        """Return ``True`` when *revision* matches the stored release revision.
+
+        When the release metadata cannot be retrieved (for example during
+        database initialization), the method optimistically returns ``True`` so
+        callers continue operating without raising secondary errors.
+        """
+
+        version = (version or "").strip()
+        revision = (revision or "").strip()
+        if not version or not revision:
+            return True
+
+        try:
+            queryset = cls.objects.filter(version=version)
+            release_revision = (
+                queryset.filter(package__is_active=True)
+                .values_list("revision", flat=True)
+                .first()
+            )
+            if release_revision is None:
+                release_revision = queryset.values_list("revision", flat=True).first()
+        except DatabaseError:  # pragma: no cover - depends on DB availability
+            logger.debug(
+                "PackageRelease.matches_revision skipped: database unavailable",
+                exc_info=True,
+            )
+            return True
+
+        if not release_revision:
+            return True
+        return release_revision.strip() == revision
+
     def build(self, **kwargs) -> None:
         """Wrapper around :func:`core.release.build` for convenience."""
         from . import release as release_utils

core/release.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import os
+import shlex
+import shutil
 import subprocess
 import sys
-import shutil
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Sequence
 
 try:  # pragma: no cover - optional dependency
     import toml  # type: ignore
@@ -16,6 +17,15 @@ except Exception:  # pragma: no cover - fallback when missing
 from config.offline import requires_network, network_available
 
 
+DEFAULT_PACKAGE_MODULES = [
+    "core",
+    "config",
+    "nodes",
+    "ocpp",
+    "pages",
+]
+
+
 @dataclass
 class Package:
     """Metadata for building a distributable package."""
@@ -28,6 +38,10 @@ class Package:
     license: str
     repository_url: str = "https://github.com/arthexis/arthexis"
     homepage_url: str = "https://arthexis.com"
+    packages: Sequence[str] = tuple(DEFAULT_PACKAGE_MODULES)
+    version_path: Optional[Path | str] = None
+    dependencies_path: Optional[Path | str] = None
+    test_command: Optional[str] = None
 
 
 @dataclass
@@ -104,7 +118,10 @@ def _manager_credentials() -> Optional[Credentials]:
     return None
 
 
-def run_tests(log_path: Optional[Path] = None) -> subprocess.CompletedProcess:
+def run_tests(
+    log_path: Optional[Path] = None,
+    command: Optional[Sequence[str]] = None,
+) -> subprocess.CompletedProcess:
     """Run the project's test suite and write output to ``log_path``.
 
     The log file is stored separately from regular application logs to avoid
@@ -112,11 +129,8 @@ def run_tests(log_path: Optional[Path] = None) -> subprocess.CompletedProcess:
     """
 
     log_path = log_path or Path("logs/test.log")
-    proc = subprocess.run(
-        [sys.executable, "manage.py", "test"],
-        capture_output=True,
-        text=True,
-    )
+    cmd = list(command) if command is not None else [sys.executable, "manage.py", "test"]
+    proc = subprocess.run(cmd, capture_output=True, text=True)
     log_path.parent.mkdir(parents=True, exist_ok=True)
     log_path.write_text(proc.stdout + proc.stderr, encoding="utf-8")
     return proc
@@ -147,15 +161,7 @@ def _write_pyproject(package: Package, version: str, requirements: list[str]) ->
             },
         },
         "tool": {
-            "setuptools": {
-                "packages": [
-                    "core",
-                    "config",
-                    "nodes",
-                    "ocpp",
-                    "pages",
-                ]
-            }
+            "setuptools": {"packages": list(package.packages)}
         },
     }
 
@@ -198,7 +204,7 @@ def build(
                 "Git repository is not clean. Commit, stash, or enable auto stash before building."
             )
 
-    version_path = Path("VERSION")
+    version_path = Path(package.version_path) if package.version_path else Path("VERSION")
     if version is None:
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
@@ -210,17 +216,29 @@ def build(
             version_path.write_text(version + "\n")
     else:
         # Ensure the VERSION file reflects the provided release version
+        if version_path.parent != Path("."):
+            version_path.parent.mkdir(parents=True, exist_ok=True)
         version_path.write_text(version + "\n")
 
+    requirements_path = (
+        Path(package.dependencies_path)
+        if package.dependencies_path
+        else Path("requirements.txt")
+    )
     requirements = [
         line.strip()
-        for line in Path("requirements.txt").read_text().splitlines()
+        for line in requirements_path.read_text().splitlines()
         if line.strip() and not line.startswith("#")
     ]
 
     if tests:
         log_path = Path("logs/test.log")
-        proc = run_tests(log_path=log_path)
+        test_command = (
+            shlex.split(package.test_command)
+            if package.test_command
+            else None
+        )
+        proc = run_tests(log_path=log_path, command=test_command)
         if proc.returncode != 0:
             raise TestsFailed(log_path, proc.stdout + proc.stderr)
 

core/tests.py

@@ -1046,7 +1046,9 @@ class ReleaseProgressFixtureVisibilityTests(TestCase):
                 package=package, version=current_version
             )
         self.session_key = f"release_publish_{self.release.pk}"
-        self.log_name = f"{self.release.package.name}-{self.release.version}.log"
+        self.log_name = core_views._release_log_name(
+            self.release.package.name, self.release.version
+        )
         self.lock_path = Path("locks") / f"{self.session_key}.json"
         self.restart_path = Path("locks") / f"{self.session_key}.restarts"
         self.log_path = Path("logs") / self.log_name
@@ -1328,6 +1330,14 @@ class TodoDoneTests(TestCase):
         self.assertIsNotNone(todo.done_on)
         self.assertFalse(todo.is_deleted)
 
+    def test_mark_done_missing_task_refreshes(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        todo.delete()
+        resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        messages = [m.message for m in get_messages(resp.wsgi_request)]
+        self.assertFalse(messages)
+
     def test_mark_done_condition_failure_shows_message(self):
         todo = Todo.objects.create(
             request="Task",