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

nodes/backends.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import random
+from collections import defaultdict
+
+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. ``EmailOutbox`` associations to ``node``, ``user`` and ``group`` are
+    also considered and preferred when multiple criteria match. When no
+    outboxes are configured, the system falls back to Django's default SMTP
+    settings.
+    """
+
+    def _resolve_identifier(self, message, attr: str):
+        value = getattr(message, attr, None)
+        if value is None:
+            value = getattr(message, f"{attr}_id", None)
+        if value is None:
+            return None
+        return getattr(value, "pk", value)
+
+    def _select_outbox(
+        self, message
+    ) -> tuple[EmailOutbox | None, list[EmailOutbox]]:
+        from_email = getattr(message, "from_email", None)
+        node_id = self._resolve_identifier(message, "node")
+        user_id = self._resolve_identifier(message, "user")
+        group_id = self._resolve_identifier(message, "group")
+
+        match_sets: list[tuple[str, list[EmailOutbox]]] = []
+
+        if from_email:
+            email_matches = list(
+                EmailOutbox.objects.filter(
+                    Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
+                )
+            )
+            if email_matches:
+                match_sets.append(("from_email", email_matches))
+
+        if node_id:
+            node_matches = list(EmailOutbox.objects.filter(node_id=node_id))
+            if node_matches:
+                match_sets.append(("node", node_matches))
+
+        if user_id:
+            user_matches = list(EmailOutbox.objects.filter(user_id=user_id))
+            if user_matches:
+                match_sets.append(("user", user_matches))
+
+        if group_id:
+            group_matches = list(EmailOutbox.objects.filter(group_id=group_id))
+            if group_matches:
+                match_sets.append(("group", group_matches))
+
+        if not match_sets:
+            return EmailOutbox.objects.first(), []
+
+        candidates: dict[int, EmailOutbox] = {}
+        scores: defaultdict[int, int] = defaultdict(int)
+
+        for _, matches in match_sets:
+            for outbox in matches:
+                candidates[outbox.pk] = outbox
+                scores[outbox.pk] += 1
+
+        if not candidates:
+            return EmailOutbox.objects.first(), []
+
+        selected: EmailOutbox | None = None
+        fallbacks: list[EmailOutbox] = []
+
+        for score in sorted(set(scores.values()), reverse=True):
+            group = [candidates[pk] for pk, value in scores.items() if value == score]
+            if len(group) > 1:
+                random.shuffle(group)
+            if selected is None:
+                selected = group[0]
+                fallbacks.extend(group[1:])
+            else:
+                fallbacks.extend(group)
+
+        return selected, fallbacks
+
+    def send_messages(self, email_messages):
+        sent = 0
+        for message in email_messages:
+            original_from_email = message.from_email
+            outbox, fallbacks = self._select_outbox(message)
+            tried_outboxes = []
+            if outbox:
+                tried_outboxes.append(outbox)
+            tried_outboxes.extend(fallbacks)
+
+            last_error: Exception | None = None
+
+            if tried_outboxes:
+                for candidate in tried_outboxes:
+                    connection = candidate.get_connection()
+                    message.from_email = (
+                        original_from_email
+                        or candidate.from_email
+                        or settings.DEFAULT_FROM_EMAIL
+                    )
+                    try:
+                        sent += connection.send_messages([message]) or 0
+                        last_error = None
+                        break
+                    except Exception as exc:  # pragma: no cover - retry on error
+                        last_error = exc
+                    finally:
+                        try:
+                            connection.close()
+                        except Exception:  # pragma: no cover - close errors shouldn't fail send
+                            pass
+                if last_error is not None:
+                    message.from_email = original_from_email
+                    raise last_error
+            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
+
+            message.from_email = original_from_email
+        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)