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

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,83 +1,89 @@
-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.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 isinstance(attachment, (list, tuple)):
+                length = len(attachment)
+                if length not in {2, 3}:
+                    raise ValueError(
+                        "attachments must contain 2- or 3-item (name, content, mimetype) tuples"
+                    )
+                email.attach(*attachment)
+            else:
+                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

core/middleware.py

@@ -1,91 +1,91 @@
-from django.contrib.auth import get_user_model
-from django.contrib.contenttypes.models import ContentType
-from django.contrib.sites.models import Site
-from django.urls import resolve
-
-from nodes.models import Node, NodeRole
-
-from .models import AdminHistory
-from .sigil_context import set_context, clear_context
-
-
-class AdminHistoryMiddleware:
-    """Log recently visited admin changelists for each user."""
-
-    def __init__(self, get_response):
-        self.get_response = get_response
-
-    def __call__(self, request):
-        response = self.get_response(request)
-        match = getattr(request, "resolver_match", None)
-        if (
-            request.user.is_authenticated
-            and request.user.is_staff
-            and request.method == "GET"
-            and match
-            and match.url_name
-            and match.url_name.endswith("_changelist")
-            and response.status_code == 200
-        ):
-            parts = request.path.strip("/").split("/")
-            if len(parts) >= 3:
-                app_label, model_name = parts[1], parts[2]
-                content_type = ContentType.objects.get_by_natural_key(
-                    app_label, model_name
-                )
-                AdminHistory.objects.update_or_create(
-                    user=request.user,
-                    url=request.get_full_path(),
-                    defaults={"content_type": content_type},
-                )
-        return response
-
-
-class SigilContextMiddleware:
-    """Capture model instance identifiers from resolved views."""
-
-    def __init__(self, get_response):
-        self.get_response = get_response
-
-    def __call__(self, request):
-        context = {}
-        if request.user.is_authenticated:
-            context[get_user_model()] = request.user.pk
-        try:
-            site = Site.objects.get_current(request)
-            context[Site] = site.pk
-        except Exception:
-            pass
-        if hasattr(request, "node") and getattr(request, "node", None):
-            context[Node] = request.node.pk
-        if hasattr(request, "role") and getattr(request, "role", None):
-            context[NodeRole] = request.role.pk
-        try:
-            match = resolve(request.path_info)
-        except Exception:  # pragma: no cover - resolution errors
-            match = None
-        if match and hasattr(match, "func"):
-            view = match.func
-            model = None
-            if hasattr(view, "view_class"):
-                view_class = view.view_class
-                model = getattr(view_class, "model", None)
-                if model is None:
-                    queryset = getattr(view_class, "queryset", None)
-                    if queryset is not None:
-                        model = queryset.model
-            if model is not None:
-                pk = match.kwargs.get("pk") or match.kwargs.get("id")
-                if pk is not None:
-                    context[model] = pk
-                for field in model._meta.fields:
-                    if field.is_relation:
-                        for key in (field.name, field.attname):
-                            if key in match.kwargs:
-                                context[field.related_model] = match.kwargs[key]
-                                break
-        set_context(context)
-        try:
-            return self.get_response(request)
-        finally:
-            clear_context()
+from django.contrib.auth import get_user_model
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.sites.models import Site
+from django.urls import resolve
+
+from nodes.models import Node, NodeRole
+
+from .models import AdminHistory
+from .sigil_context import set_context, clear_context
+
+
+class AdminHistoryMiddleware:
+    """Log recently visited admin changelists for each user."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        match = getattr(request, "resolver_match", None)
+        if (
+            request.user.is_authenticated
+            and request.user.is_staff
+            and request.method == "GET"
+            and match
+            and match.url_name
+            and match.url_name.endswith("_changelist")
+            and response.status_code == 200
+        ):
+            parts = request.path.strip("/").split("/")
+            if len(parts) >= 3:
+                app_label, model_name = parts[1], parts[2]
+                content_type = ContentType.objects.get_by_natural_key(
+                    app_label, model_name
+                )
+                AdminHistory.objects.update_or_create(
+                    user=request.user,
+                    url=request.get_full_path(),
+                    defaults={"content_type": content_type},
+                )
+        return response
+
+
+class SigilContextMiddleware:
+    """Capture model instance identifiers from resolved views."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        context = {}
+        if request.user.is_authenticated:
+            context[get_user_model()] = request.user.pk
+        try:
+            site = Site.objects.get_current(request)
+            context[Site] = site.pk
+        except Exception:
+            pass
+        if hasattr(request, "node") and getattr(request, "node", None):
+            context[Node] = request.node.pk
+        if hasattr(request, "role") and getattr(request, "role", None):
+            context[NodeRole] = request.role.pk
+        try:
+            match = resolve(request.path_info)
+        except Exception:  # pragma: no cover - resolution errors
+            match = None
+        if match and hasattr(match, "func"):
+            view = match.func
+            model = None
+            if hasattr(view, "view_class"):
+                view_class = view.view_class
+                model = getattr(view_class, "model", None)
+                if model is None:
+                    queryset = getattr(view_class, "queryset", None)
+                    if queryset is not None:
+                        model = queryset.model
+            if model is not None:
+                pk = match.kwargs.get("pk") or match.kwargs.get("id")
+                if pk is not None:
+                    context[model] = pk
+                for field in model._meta.fields:
+                    if field.is_relation:
+                        for key in (field.name, field.attname):
+                            if key in match.kwargs:
+                                context[field.related_model] = match.kwargs[key]
+                                break
+        set_context(context)
+        try:
+            return self.get_response(request)
+        finally:
+            clear_context()