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

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,53 +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 = []
-                if subject:
-                    criteria.extend(["SUBJECT", f'"{subject}"'])
-                if from_address:
-                    criteria.extend(["FROM", f'"{from_address}"'])
-                if body:
-                    criteria.extend(["TEXT", f'"{body}"'])
-                if not criteria:
-                    criteria = ["ALL"]
-                typ, data = conn.search(None, *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", ""),
-                    }
+            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 len(messages) >= limit:
-                    break
-            conn.logout()
-            return list(reversed(messages))
+                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:
+                        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
@@ -1247,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:
@@ -2301,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
     )
@@ -2339,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):
@@ -2412,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
@@ -2447,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
@@ -2637,3 +2773,23 @@ class Todo(Entity):
         if isinstance(field, ConditionTextField):
             return field.evaluate(self)
         return ConditionCheckResult(True, "")
+
+
+class TOTPDeviceSettings(models.Model):
+    """Per-device configuration options for authenticator enrollments."""
+
+    device = models.OneToOneField(
+        "otp_totp.TOTPDevice",
+        on_delete=models.CASCADE,
+        related_name="custom_settings",
+    )
+    issuer = models.CharField(
+        max_length=64,
+        blank=True,
+        default="",
+        help_text=_("Label shown in authenticator apps. Leave blank to use Arthexis."),
+    )
+
+    class Meta:
+        verbose_name = _("Authenticator device settings")
+        verbose_name_plural = _("Authenticator device settings")

core/reference_utils.py

@@ -30,7 +30,7 @@ def filter_visible_references(
         if host:
             site = Site.objects.filter(domain__iexact=host).first()
 
-    site_id = site.pk if site else None
+    site_id = getattr(site, "pk", None)
 
     if node is None:
         try:

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)
 
@@ -344,3 +362,7 @@ def publish(
     proc = subprocess.run(cmd, capture_output=True, text=True)
     if proc.returncode != 0:
         raise ReleaseError(proc.stdout + proc.stderr)
+
+    tag_name = f"v{version}"
+    _run(["git", "tag", tag_name])
+    _run(["git", "push", "origin", tag_name])

core/system.py

@@ -119,7 +119,7 @@ def _auto_upgrade_next_check() -> str:
 
 
 def _resolve_auto_upgrade_namespace(key: str) -> str | None:
-    """Resolve sigils within the ``AUTO-UPGRADE`` namespace."""
+    """Resolve sigils within the legacy ``AUTO-UPGRADE`` namespace."""
 
     normalized = key.replace("-", "_").upper()
     if normalized == "NEXT_CHECK":
@@ -137,6 +137,9 @@ def resolve_system_namespace_value(key: str) -> str | None:
 
     if not key:
         return None
+    normalized_key = key.replace("-", "_").upper()
+    if normalized_key == "NEXT_VER_CHECK":
+        return _auto_upgrade_next_check()
     namespace, _, remainder = key.partition(".")
     if not remainder:
         return None
@@ -218,8 +221,8 @@ def _build_system_fields(info: dict[str, object]) -> list[SystemField]:
     )
 
     add_field(
-        _("Next auto-upgrade check"),
-        "AUTO-UPGRADE.NEXT-CHECK",
+        _("Next version check"),
+        "NEXT-VER-CHECK",
         info.get("auto_upgrade_next_check", ""),
     )