arthexis 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

nodes/apps.py

@@ -7,7 +7,6 @@ from pathlib import Path
 
 from django.apps import AppConfig
 from django.conf import settings
-from django.core.signals import request_started
 from django.db import connections
 from django.db.utils import OperationalError
 from utils import revision
@@ -17,13 +16,9 @@ logger = logging.getLogger(__name__)
 
 
 def _startup_notification() -> None:
-    """Queue a notification with host:port and version on a background thread."""
+    """Queue a Net Message with ``hostname:port`` and version info."""
 
     host = socket.gethostname()
-    try:
-        address = socket.gethostbyname(host)
-    except socket.gaierror:
-        address = host
 
     port = os.environ.get("PORT", "8000")
 
@@ -35,9 +30,9 @@ def _startup_notification() -> None:
     revision_value = revision.get_revision()
     rev_short = revision_value[-6:] if revision_value else ""
 
-    body = f"v{version}"
+    body = version
     if rev_short:
-        body += f" r{rev_short}"
+        body = f"{body} r{rev_short}" if body else f"r{rev_short}"
 
     def _worker() -> None:  # pragma: no cover - background thread
         # Allow the LCD a moment to become ready and retry a few times
@@ -45,7 +40,7 @@ def _startup_notification() -> None:
             try:
                 from nodes.models import NetMessage
 
-                NetMessage.broadcast(subject=f"{address}:{port}", body=body)
+                NetMessage.broadcast(subject=f"{host}:{port}", body=body)
                 break
             except Exception:
                 time.sleep(1)
@@ -54,9 +49,8 @@ def _startup_notification() -> None:
 
 
 def _trigger_startup_notification(**_: object) -> None:
-    """Send the startup notification once a request has started."""
+    """Attempt to send the startup notification in the background."""
 
-    request_started.disconnect(_trigger_startup_notification, dispatch_uid="nodes-startup")
     try:
         connections["default"].ensure_connection()
     except OperationalError:
@@ -68,9 +62,9 @@ def _trigger_startup_notification(**_: object) -> None:
 class NodesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "nodes"
-    verbose_name = "2. Infrastructure"
+    verbose_name = "4. Infrastructure"
 
     def ready(self):  # pragma: no cover - exercised on app start
-        request_started.connect(
-            _trigger_startup_notification, dispatch_uid="nodes-startup"
-        )
+        from django.db.models.signals import post_migrate
+
+        post_migrate.connect(_trigger_startup_notification, sender=self)

nodes/backends.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from django.core.mail.backends.base import BaseEmailBackend
+from django.core.mail import get_connection
+from django.conf import settings
+from django.db.models import Q
+
+from .models import EmailOutbox
+
+
+class OutboxEmailBackend(BaseEmailBackend):
+    """Email backend that selects an :class:`EmailOutbox` automatically.
+
+    If a matching outbox exists for the message's ``from_email`` (matching
+    either ``from_email`` or ``username``), that outbox's SMTP credentials are
+    used. Otherwise, the first available outbox is used. When no outboxes are
+    configured, the system falls back to Django's default SMTP settings.
+    """
+
+    def _select_outbox(self, from_email: str | None) -> EmailOutbox | None:
+        if from_email:
+            return (
+                EmailOutbox.objects.filter(
+                    Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
+                ).first()
+                or EmailOutbox.objects.first()
+            )
+        return EmailOutbox.objects.first()
+
+    def send_messages(self, email_messages):
+        sent = 0
+        for message in email_messages:
+            outbox = self._select_outbox(message.from_email)
+            if outbox:
+                connection = outbox.get_connection()
+                if not message.from_email:
+                    message.from_email = (
+                        outbox.from_email or settings.DEFAULT_FROM_EMAIL
+                    )
+            else:
+                connection = get_connection(
+                    "django.core.mail.backends.smtp.EmailBackend"
+                )
+                if not message.from_email:
+                    message.from_email = settings.DEFAULT_FROM_EMAIL
+            try:
+                sent += connection.send_messages([message]) or 0
+            finally:
+                try:
+                    connection.close()
+                except Exception:  # pragma: no cover - close errors shouldn't fail send
+                    pass
+        return sent

nodes/lcd.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 import subprocess
 import time
 from dataclasses import dataclass
-from typing import List
 
 try:  # pragma: no cover - hardware dependent
     import smbus  # type: ignore
@@ -21,6 +20,12 @@ except Exception:  # pragma: no cover - missing dependency
     except Exception:  # pragma: no cover - missing dependency
         smbus = None  # type: ignore
 
+SMBUS_HINT = (
+    "smbus module not found. Enable the I2C interface and install the dependencies.\n"
+    "For Debian/Ubuntu run: sudo apt-get install i2c-tools python3-smbus\n"
+    "Within the virtualenv: pip install smbus2"
+)
+
 
 class LCDUnavailableError(RuntimeError):
     """Raised when the LCD cannot be initialised."""
@@ -32,9 +37,11 @@ class _BusWrapper:
 
     channel: int
 
-    def write_byte(self, addr: int, data: int) -> None:  # pragma: no cover - thin wrapper
+    def write_byte(
+        self, addr: int, data: int
+    ) -> None:  # pragma: no cover - thin wrapper
         if smbus is None:
-            raise LCDUnavailableError("smbus not available")
+            raise LCDUnavailableError(SMBUS_HINT)
         bus = smbus.SMBus(self.channel)
         bus.write_byte(addr, data)
         bus.close()
@@ -45,7 +52,7 @@ class CharLCD1602:
 
     def __init__(self, bus: _BusWrapper | None = None) -> None:
         if smbus is None:  # pragma: no cover - hardware dependent
-            raise LCDUnavailableError("smbus not available")
+            raise LCDUnavailableError(SMBUS_HINT)
         self.bus = bus or _BusWrapper(1)
         self.BLEN = 1
         self.PCF8574_address = 0x27
@@ -85,7 +92,7 @@ class CharLCD1602:
         # Allow the LCD controller to catch up between data writes.
         time.sleep(0.001)
 
-    def i2c_scan(self) -> List[str]:  # pragma: no cover - requires hardware
+    def i2c_scan(self) -> list[str]:  # pragma: no cover - requires hardware
         """Return a list of detected I2C addresses.
 
         The implementation relies on the external ``i2cdetect`` command.  On
@@ -94,13 +101,18 @@ class CharLCD1602:
         list so callers can fall back to a sensible default address.
         """
 
-        cmd = "i2cdetect -y 1 | awk 'NR>1 {$1=\"\"; print}'"
         try:
-            out = subprocess.check_output(cmd, shell=True).decode()
+            output = subprocess.check_output(["i2cdetect", "-y", "1"], text=True)
         except Exception:  # pragma: no cover - depends on environment
             return []
-        out = out.replace("\n", "").replace(" --", "")
-        return [tok for tok in out.split(" ") if tok]
+
+        addresses: list[str] = []
+        for line in output.splitlines()[1:]:
+            parts = line.split()
+            for token in parts[1:]:
+                if token != "--":
+                    addresses.append(token)
+        return addresses
 
     def init_lcd(self, addr: int | None = None, bl: int = 1) -> None:
         self.BLEN = 1 if bl else 0
@@ -138,7 +150,9 @@ class CharLCD1602:
         """Re-run the initialisation sequence to recover the display."""
         self.init_lcd(addr=self.LCD_ADDR, bl=self.BLEN)
 
-    def set_backlight(self, on: bool = True) -> None:  # pragma: no cover - hardware dependent
+    def set_backlight(
+        self, on: bool = True
+    ) -> None:  # pragma: no cover - hardware dependent
         self.BLEN = 1 if on else 0
         self._write_word(self.LCD_ADDR, 0x00)