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

core/lcd_screen.py

@@ -1,78 +1,78 @@
-"""Standalone LCD screen updater.
-
-The script polls ``locks/lcd_screen.lck`` for up to two lines of text and
-writes them to the attached LCD1602 display. If either line exceeds 16
-characters the text scrolls horizontally. A third line in the lock file
-can define the scroll speed in milliseconds per character (default 1000
-ms).
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-from pathlib import Path
-
-from nodes.lcd import CharLCD1602, LCDUnavailableError
-
-logger = logging.getLogger(__name__)
-
-LOCK_FILE = Path(__file__).resolve().parents[1] / "locks" / "lcd_screen.lck"
-DEFAULT_SCROLL_MS = 1000
-
-
-def _read_lock_file() -> tuple[str, str, int]:
-    try:
-        lines = LOCK_FILE.read_text(encoding="utf-8").splitlines()
-    except FileNotFoundError:
-        return "", "", DEFAULT_SCROLL_MS
-    line1 = lines[0][:64] if len(lines) > 0 else ""
-    line2 = lines[1][:64] if len(lines) > 1 else ""
-    try:
-        speed = int(lines[2]) if len(lines) > 2 else DEFAULT_SCROLL_MS
-    except ValueError:
-        speed = DEFAULT_SCROLL_MS
-    return line1, line2, speed
-
-
-def _display(lcd: CharLCD1602, line1: str, line2: str, scroll_ms: int) -> None:
-    scroll_sec = max(scroll_ms, 0) / 1000.0
-    text1 = line1[:64]
-    text2 = line2[:64]
-    pad1 = text1 + " " * 16 if len(text1) > 16 else text1.ljust(16)
-    pad2 = text2 + " " * 16 if len(text2) > 16 else text2.ljust(16)
-    steps = max(len(pad1) - 15, len(pad2) - 15)
-    for i in range(steps):
-        segment1 = pad1[i : i + 16]
-        segment2 = pad2[i : i + 16]
-        lcd.write(0, 0, segment1.ljust(16))
-        lcd.write(0, 1, segment2.ljust(16))
-        time.sleep(scroll_sec)
-
-
-def main() -> None:  # pragma: no cover - hardware dependent
-    lcd = None
-    last_mtime = 0.0
-    while True:
-        try:
-            if LOCK_FILE.exists():
-                mtime = LOCK_FILE.stat().st_mtime
-                if mtime != last_mtime or lcd is None:
-                    line1, line2, speed = _read_lock_file()
-                    if lcd is None:
-                        lcd = CharLCD1602()
-                        lcd.init_lcd()
-                    lcd.clear()
-                    _display(lcd, line1, line2, speed)
-                    last_mtime = mtime
-        except LCDUnavailableError as exc:
-            logger.warning("LCD unavailable: %s", exc)
-            lcd = None
-        except Exception as exc:
-            logger.warning("LCD update failed: %s", exc)
-            lcd = None
-        time.sleep(0.5)
-
-
-if __name__ == "__main__":  # pragma: no cover - script entry point
-    main()
+"""Standalone LCD screen updater.
+
+The script polls ``locks/lcd_screen.lck`` for up to two lines of text and
+writes them to the attached LCD1602 display. If either line exceeds 16
+characters the text scrolls horizontally. A third line in the lock file
+can define the scroll speed in milliseconds per character (default 1000
+ms).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+
+from nodes.lcd import CharLCD1602, LCDUnavailableError
+
+logger = logging.getLogger(__name__)
+
+LOCK_FILE = Path(__file__).resolve().parents[1] / "locks" / "lcd_screen.lck"
+DEFAULT_SCROLL_MS = 1000
+
+
+def _read_lock_file() -> tuple[str, str, int]:
+    try:
+        lines = LOCK_FILE.read_text(encoding="utf-8").splitlines()
+    except FileNotFoundError:
+        return "", "", DEFAULT_SCROLL_MS
+    line1 = lines[0][:64] if len(lines) > 0 else ""
+    line2 = lines[1][:64] if len(lines) > 1 else ""
+    try:
+        speed = int(lines[2]) if len(lines) > 2 else DEFAULT_SCROLL_MS
+    except ValueError:
+        speed = DEFAULT_SCROLL_MS
+    return line1, line2, speed
+
+
+def _display(lcd: CharLCD1602, line1: str, line2: str, scroll_ms: int) -> None:
+    scroll_sec = max(scroll_ms, 0) / 1000.0
+    text1 = line1[:64]
+    text2 = line2[:64]
+    pad1 = text1 + " " * 16 if len(text1) > 16 else text1.ljust(16)
+    pad2 = text2 + " " * 16 if len(text2) > 16 else text2.ljust(16)
+    steps = max(len(pad1) - 15, len(pad2) - 15)
+    for i in range(steps):
+        segment1 = pad1[i : i + 16]
+        segment2 = pad2[i : i + 16]
+        lcd.write(0, 0, segment1.ljust(16))
+        lcd.write(0, 1, segment2.ljust(16))
+        time.sleep(scroll_sec)
+
+
+def main() -> None:  # pragma: no cover - hardware dependent
+    lcd = None
+    last_mtime = 0.0
+    while True:
+        try:
+            if LOCK_FILE.exists():
+                mtime = LOCK_FILE.stat().st_mtime
+                if mtime != last_mtime or lcd is None:
+                    line1, line2, speed = _read_lock_file()
+                    if lcd is None:
+                        lcd = CharLCD1602()
+                        lcd.init_lcd()
+                    lcd.clear()
+                    _display(lcd, line1, line2, speed)
+                    last_mtime = mtime
+        except LCDUnavailableError as exc:
+            logger.warning("LCD unavailable: %s", exc)
+            lcd = None
+        except Exception as exc:
+            logger.warning("LCD update failed: %s", exc)
+            lcd = None
+        time.sleep(0.5)
+
+
+if __name__ == "__main__":  # pragma: no cover - script entry point
+    main()

core/liveupdate.py

@@ -1,25 +1,25 @@
-from functools import wraps
-
-
-def live_update(interval=5):
-    """Decorator to mark function-based views for automatic refresh."""
-
-    def decorator(view):
-        @wraps(view)
-        def wrapped(request, *args, **kwargs):
-            setattr(request, "live_update_interval", interval)
-            return view(request, *args, **kwargs)
-
-        return wrapped
-
-    return decorator
-
-
-class LiveUpdateMixin:
-    """Mixin to enable automatic refresh for class-based views."""
-
-    live_update_interval = 5
-
-    def dispatch(self, request, *args, **kwargs):
-        setattr(request, "live_update_interval", self.live_update_interval)
-        return super().dispatch(request, *args, **kwargs)
+from functools import wraps
+
+
+def live_update(interval=5):
+    """Decorator to mark function-based views for automatic refresh."""
+
+    def decorator(view):
+        @wraps(view)
+        def wrapped(request, *args, **kwargs):
+            setattr(request, "live_update_interval", interval)
+            return view(request, *args, **kwargs)
+
+        return wrapped
+
+    return decorator
+
+
+class LiveUpdateMixin:
+    """Mixin to enable automatic refresh for class-based views."""
+
+    live_update_interval = 5
+
+    def dispatch(self, request, *args, **kwargs):
+        setattr(request, "live_update_interval", self.live_update_interval)
+        return super().dispatch(request, *args, **kwargs)

core/log_paths.py

@@ -1,100 +1,114 @@
-"""Helpers for selecting writable log directories."""
-
-from __future__ import annotations
-
-from pathlib import Path
-import os
-import sys
-
-
-def _is_root() -> bool:
-    if hasattr(os, "geteuid"):
-        try:
-            return os.geteuid() == 0
-        except OSError:  # pragma: no cover - defensive for unusual platforms
-            return False
-    return False
-
-
-def _state_home(base_home: Path) -> Path:
-    state_home = os.environ.get("XDG_STATE_HOME")
-    if state_home:
-        return Path(state_home).expanduser()
-    return base_home / ".local" / "state"
-
-
-def select_log_dir(base_dir: Path) -> Path:
-    """Choose a writable log directory for the current process."""
-
-    default = base_dir / "logs"
-    env_override = os.environ.get("ARTHEXIS_LOG_DIR")
-    is_root = _is_root()
-    sudo_user = os.environ.get("SUDO_USER")
-
-    candidates: list[Path] = []
-    if env_override:
-        candidates.append(Path(env_override).expanduser())
-
-    if is_root:
-        if not sudo_user or sudo_user == "root":
-            candidates.append(default)
-        candidates.append(Path("/var/log/arthexis"))
-        candidates.append(Path("/tmp/arthexis/logs"))
-    else:
-        home = Path.home()
-        state_home = _state_home(home)
-        candidates.extend(
-            [
-                default,
-                state_home / "arthexis" / "logs",
-                home / ".arthexis" / "logs",
-                Path("/tmp/arthexis/logs"),
-            ]
-        )
-
-    seen: set[Path] = set()
-    ordered_candidates: list[Path] = []
-    for candidate in candidates:
-        candidate = candidate.expanduser()
-        if candidate not in seen:
-            seen.add(candidate)
-            ordered_candidates.append(candidate)
-
-    attempted: list[Path] = []
-    chosen: Path | None = None
-    for candidate in ordered_candidates:
-        attempted.append(candidate)
-        try:
-            candidate.mkdir(parents=True, exist_ok=True)
-        except OSError:
-            continue
-        if os.access(candidate, os.W_OK | os.X_OK):
-            chosen = candidate
-            break
-
-    if chosen is None:
-        attempted_str = (
-            ", ".join(str(path) for path in attempted) if attempted else "none"
-        )
-        raise RuntimeError(
-            f"Unable to create a writable log directory. Tried: {attempted_str}"
-        )
-
-    if chosen != default:
-        if (
-            attempted
-            and attempted[0] == default
-            and not os.access(default, os.W_OK | os.X_OK)
-        ):
-            print(
-                f"Log directory {default} is not writable; using {chosen}",
-                file=sys.stderr,
-            )
-        elif is_root and sudo_user and sudo_user != "root" and not env_override:
-            print(
-                f"Running with elevated privileges; writing logs to {chosen}",
-                file=sys.stderr,
-            )
-
-    os.environ["ARTHEXIS_LOG_DIR"] = str(chosen)
-    return chosen
+"""Helpers for selecting writable log directories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import os
+import sys
+import tempfile
+
+
+def _is_root() -> bool:
+    if hasattr(os, "geteuid"):
+        try:
+            return os.geteuid() == 0
+        except OSError:  # pragma: no cover - defensive for unusual platforms
+            return False
+    return False
+
+
+def _state_home(base_home: Path) -> Path:
+    state_home = os.environ.get("XDG_STATE_HOME")
+    if state_home:
+        return Path(state_home).expanduser()
+    return base_home / ".local" / "state"
+
+
+def select_log_dir(base_dir: Path) -> Path:
+    """Choose a writable log directory for the current process."""
+
+    default = base_dir / "logs"
+    env_override = os.environ.get("ARTHEXIS_LOG_DIR")
+    is_root = _is_root()
+    sudo_user = os.environ.get("SUDO_USER")
+
+    candidates: list[Path] = []
+    if env_override:
+        candidates.append(Path(env_override).expanduser())
+
+    if is_root:
+        if not sudo_user or sudo_user == "root":
+            candidates.append(default)
+        candidates.append(Path("/var/log/arthexis"))
+        candidates.append(Path("/tmp/arthexis/logs"))
+    else:
+        home: Path | None
+        try:
+            home = Path.home()
+        except (RuntimeError, OSError, KeyError):
+            home = None
+
+        candidates.append(default)
+
+        tmp_logs = Path(tempfile.gettempdir()) / "arthexis" / "logs"
+
+        if home is not None:
+            state_home = _state_home(home)
+            candidates.extend(
+                [
+                    state_home / "arthexis" / "logs",
+                    home / ".arthexis" / "logs",
+                ]
+            )
+        else:
+            candidates.append(tmp_logs)
+
+        candidates.append(Path("/tmp/arthexis/logs"))
+        candidates.append(tmp_logs)
+
+    seen: set[Path] = set()
+    ordered_candidates: list[Path] = []
+    for candidate in candidates:
+        candidate = candidate.expanduser()
+        if candidate not in seen:
+            seen.add(candidate)
+            ordered_candidates.append(candidate)
+
+    attempted: list[Path] = []
+    chosen: Path | None = None
+    for candidate in ordered_candidates:
+        attempted.append(candidate)
+        try:
+            candidate.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            continue
+        if os.access(candidate, os.W_OK | os.X_OK):
+            chosen = candidate
+            break
+
+    if chosen is None:
+        attempted_str = (
+            ", ".join(str(path) for path in attempted) if attempted else "none"
+        )
+        raise RuntimeError(
+            f"Unable to create a writable log directory. Tried: {attempted_str}"
+        )
+
+    if chosen != default:
+        if (
+            attempted
+            and attempted[0] == default
+            and not os.access(default, os.W_OK | os.X_OK)
+        ):
+            print(
+                f"Log directory {default} is not writable; using {chosen}",
+                file=sys.stderr,
+            )
+        elif is_root and sudo_user and sudo_user != "root" and not env_override:
+            print(
+                f"Running with elevated privileges; writing logs to {chosen}",
+                file=sys.stderr,
+            )
+
+    os.environ["ARTHEXIS_LOG_DIR"] = str(chosen)
+    return chosen

core/mailer.py

@@ -1,85 +1,85 @@
-import logging
-from typing import Sequence
-
-from django.conf import settings
-from django.core.mail import EmailMessage
-from django.utils.module_loading import import_string
-
-try:  # pragma: no cover - import should always succeed but guard defensively
-    from django.core.mail.backends.dummy import (
-        EmailBackend as DummyEmailBackend,
-    )
-except Exception:  # pragma: no cover - fallback when dummy backend unavailable
-    DummyEmailBackend = None  # type: ignore[assignment]
-
-logger = logging.getLogger(__name__)
-
-
-def send(
-    subject: str,
-    message: str,
-    recipient_list: Sequence[str],
-    from_email: str | None = None,
-    *,
-    outbox=None,
-    attachments: Sequence[tuple[str, str, str]] | None = None,
-    content_subtype: str | None = None,
-    **kwargs,
-):
-    """Send an email using Django's email utilities.
-
-    If ``outbox`` is provided, its connection will be used when sending.
-    """
-    sender = (
-        from_email or getattr(outbox, "from_email", None) or settings.DEFAULT_FROM_EMAIL
-    )
-    connection = outbox.get_connection() if outbox is not None else None
-    fail_silently = kwargs.pop("fail_silently", False)
-    email = EmailMessage(
-        subject=subject,
-        body=message,
-        from_email=sender,
-        to=list(recipient_list),
-        connection=connection,
-        **kwargs,
-    )
-    if attachments:
-        for attachment in attachments:
-            if not isinstance(attachment, (list, tuple)) or len(attachment) != 3:
-                raise ValueError(
-                    "attachments must contain (name, content, mimetype) tuples"
-                )
-            email.attach(*attachment)
-    if content_subtype:
-        email.content_subtype = content_subtype
-    email.send(fail_silently=fail_silently)
-    return email
-
-
-def can_send_email() -> bool:
-    """Return ``True`` when at least one outbound email path is configured."""
-
-    from nodes.models import EmailOutbox  # imported lazily to avoid circular deps
-
-    has_outbox = (
-        EmailOutbox.objects.filter(is_enabled=True).exclude(host="").exists()
-    )
-    if has_outbox:
-        return True
-
-    backend_path = getattr(settings, "EMAIL_BACKEND", "")
-    if not backend_path:
-        return False
-    try:
-        backend_cls = import_string(backend_path)
-    except Exception:  # pragma: no cover - misconfigured backend
-        logger.warning("Email backend %s could not be imported", backend_path)
-        return False
-
-    if DummyEmailBackend is None:
-        return True
-    try:
-        return not issubclass(backend_cls, DummyEmailBackend)
-    except TypeError:  # pragma: no cover - backend not a class
-        logger.warning("Email backend %s is not a class", backend_path)
-        return False
+import logging
+from typing import Sequence
+
+from django.conf import settings
+from django.core.mail import EmailMessage
+from django.utils.module_loading import import_string
+
+try:  # pragma: no cover - import should always succeed but guard defensively
+    from django.core.mail.backends.dummy import (
+        EmailBackend as DummyEmailBackend,
+    )
+except Exception:  # pragma: no cover - fallback when dummy backend unavailable
+    DummyEmailBackend = None  # type: ignore[assignment]
+
+logger = logging.getLogger(__name__)
+
+
+def send(
+    subject: str,
+    message: str,
+    recipient_list: Sequence[str],
+    from_email: str | None = None,
+    *,
+    outbox=None,
+    attachments: Sequence[tuple[str, str, str]] | None = None,
+    content_subtype: str | None = None,
+    **kwargs,
+):
+    """Send an email using Django's email utilities.
+
+    If ``outbox`` is provided, its connection will be used when sending.
+    """
+    sender = (
+        from_email or getattr(outbox, "from_email", None) or settings.DEFAULT_FROM_EMAIL
+    )
+    connection = outbox.get_connection() if outbox is not None else None
+    fail_silently = kwargs.pop("fail_silently", False)
+    email = EmailMessage(
+        subject=subject,
+        body=message,
+        from_email=sender,
+        to=list(recipient_list),
+        connection=connection,
+        **kwargs,
+    )
+    if attachments:
+        for attachment in attachments:
+            if not isinstance(attachment, (list, tuple)) or len(attachment) != 3:
+                raise ValueError(
+                    "attachments must contain (name, content, mimetype) tuples"
+                )
+            email.attach(*attachment)
+    if content_subtype:
+        email.content_subtype = content_subtype
+    email.send(fail_silently=fail_silently)
+    return email
+
+
+def can_send_email() -> bool:
+    """Return ``True`` when at least one outbound email path is configured."""
+
+    from nodes.models import EmailOutbox  # imported lazily to avoid circular deps
+
+    has_outbox = (
+        EmailOutbox.objects.filter(is_enabled=True).exclude(host="").exists()
+    )
+    if has_outbox:
+        return True
+
+    backend_path = getattr(settings, "EMAIL_BACKEND", "")
+    if not backend_path:
+        return False
+    try:
+        backend_cls = import_string(backend_path)
+    except Exception:  # pragma: no cover - misconfigured backend
+        logger.warning("Email backend %s could not be imported", backend_path)
+        return False
+
+    if DummyEmailBackend is None:
+        return True
+    try:
+        return not issubclass(backend_cls, DummyEmailBackend)
+    except TypeError:  # pragma: no cover - backend not a class
+        logger.warning("Email backend %s is not a class", backend_path)
+        return False