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

nodes/urls.py

@@ -1,13 +1,29 @@
-from django.urls import path
-
-from . import views
-
-urlpatterns = [
-    path("info/", views.node_info, name="node-info"),
-    path("list/", views.node_list, name="node-list"),
-    path("register/", views.register_node, name="register-node"),
-    path("screenshot/", views.capture, name="node-screenshot"),
-    path("net-message/", views.net_message, name="net-message"),
-    path("last-message/", views.last_net_message, name="last-net-message"),
-    path("<slug:endpoint>/", views.public_node_endpoint, name="node-public-endpoint"),
-]
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+    path("info/", views.node_info, name="node-info"),
+    path("list/", views.node_list, name="node-list"),
+    path("register/", views.register_node, name="register-node"),
+    path("screenshot/", views.capture, name="node-screenshot"),
+    path("net-message/", views.net_message, name="net-message"),
+    path("net-message/pull/", views.net_message_pull, name="net-message-pull"),
+    path("rfid/export/", views.export_rfids, name="node-rfid-export"),
+    path("rfid/import/", views.import_rfids, name="node-rfid-import"),
+    path("network/chargers/", views.network_chargers, name="node-network-chargers"),
+    path(
+        "network/chargers/forward/",
+        views.forward_chargers,
+        name="node-network-forward-chargers",
+    ),
+    path(
+        "network/chargers/action/",
+        views.network_charger_action,
+        name="node-network-charger-action",
+    ),
+    path("proxy/session/", views.proxy_session, name="node-proxy-session"),
+    path("proxy/login/<str:token>/", views.proxy_login, name="node-proxy-login"),
+    path("proxy/execute/", views.proxy_execute, name="node-proxy-execute"),
+    path("<slug:endpoint>/", views.public_node_endpoint, name="node-public-endpoint"),
+]

nodes/utils.py

@@ -1,73 +1,172 @@
-from datetime import datetime
-from pathlib import Path
-import hashlib
-import logging
-
-from django.conf import settings
-from selenium import webdriver
-from selenium.webdriver.firefox.options import Options
-from selenium.common.exceptions import WebDriverException
-
-from .models import ContentSample
-
-SCREENSHOT_DIR = settings.LOG_DIR / "screenshots"
-logger = logging.getLogger(__name__)
-
-
-def capture_screenshot(url: str, cookies=None) -> Path:
-    """Capture a screenshot of ``url`` and save it to :data:`SCREENSHOT_DIR`.
-
-    ``cookies`` can be an iterable of Selenium cookie mappings which will be
-    applied after the initial navigation and before the screenshot is taken.
-    """
-    options = Options()
-    options.add_argument("-headless")
-    try:
-        with webdriver.Firefox(options=options) as browser:
-            browser.set_window_size(1280, 720)
-            SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
-            filename = SCREENSHOT_DIR / f"{datetime.utcnow():%Y%m%d%H%M%S}.png"
-            try:
-                browser.get(url)
-            except WebDriverException as exc:
-                logger.error("Failed to load %s: %s", url, exc)
-            if cookies:
-                for cookie in cookies:
-                    try:
-                        browser.add_cookie(cookie)
-                    except WebDriverException as exc:
-                        logger.error("Failed to apply cookie for %s: %s", url, exc)
-                browser.get(url)
-            if not browser.save_screenshot(str(filename)):
-                raise RuntimeError("Screenshot capture failed")
-            return filename
-    except WebDriverException as exc:
-        logger.error("Failed to capture screenshot from %s: %s", url, exc)
-        raise RuntimeError(f"Screenshot capture failed: {exc}") from exc
-
-
-def save_screenshot(path: Path, node=None, method: str = "", transaction_uuid=None):
-    """Save screenshot file info if not already recorded.
-
-    Returns the created :class:`ContentSample` or ``None`` if duplicate.
-    """
-
-    original = path
-    if not path.is_absolute():
-        path = settings.LOG_DIR / path
-    with path.open("rb") as fh:
-        digest = hashlib.sha256(fh.read()).hexdigest()
-    if ContentSample.objects.filter(hash=digest).exists():
-        logger.info("Duplicate screenshot content; record not created")
-        return None
-    stored_path = (original if not original.is_absolute() else path).as_posix()
-    data = {
-        "node": node,
-        "path": stored_path,
-        "method": method,
-        "hash": digest,
-        "kind": ContentSample.IMAGE,
-    }
-    if transaction_uuid is not None:
-        data["transaction_uuid"] = transaction_uuid
-    return ContentSample.objects.create(**data)
+from datetime import datetime
+from pathlib import Path
+import hashlib
+import logging
+import shutil
+import subprocess
+import uuid
+
+from django.conf import settings
+from selenium import webdriver
+from selenium.webdriver.firefox.options import Options
+from selenium.common.exceptions import WebDriverException
+
+try:  # pragma: no cover - optional dependency may be missing
+    from geckodriver_autoinstaller import install as install_geckodriver
+except Exception:  # pragma: no cover - fallback when installer is unavailable
+    install_geckodriver = None
+
+from .classifiers import run_default_classifiers, suppress_default_classifiers
+from .models import ContentSample
+
+SCREENSHOT_DIR = settings.LOG_DIR / "screenshots"
+CAMERA_DIR = settings.LOG_DIR / "camera"
+logger = logging.getLogger(__name__)
+
+_FIREFOX_BINARY_CANDIDATES = ("firefox", "firefox-esr", "firefox-bin")
+
+
+def _find_firefox_binary() -> str | None:
+    """Return the first available Firefox binary path or ``None``."""
+
+    for candidate in _FIREFOX_BINARY_CANDIDATES:
+        path = shutil.which(candidate)
+        if path:
+            return path
+    return None
+
+
+def _ensure_geckodriver() -> None:
+    """Install geckodriver on demand when possible."""
+
+    if install_geckodriver is None:  # pragma: no cover - dependency not installed
+        return
+    try:
+        install_geckodriver()
+    except Exception as exc:  # pragma: no cover - external failures are rare in tests
+        logger.warning("Unable to ensure geckodriver availability: %s", exc)
+
+
+def capture_screenshot(url: str, cookies=None) -> Path:
+    """Capture a screenshot of ``url`` and save it to :data:`SCREENSHOT_DIR`.
+
+    ``cookies`` can be an iterable of Selenium cookie mappings which will be
+    applied after the initial navigation and before the screenshot is taken.
+    """
+    firefox_binary = _find_firefox_binary()
+    if not firefox_binary:
+        raise RuntimeError(
+            "Screenshot capture failed: Firefox is not installed. Install Firefox to enable screenshot capture."
+        )
+
+    options = Options()
+    options.binary_location = firefox_binary
+    options.add_argument("-headless")
+    _ensure_geckodriver()
+    try:
+        with webdriver.Firefox(options=options) as browser:
+            browser.set_window_size(1280, 720)
+            SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
+            filename = SCREENSHOT_DIR / f"{datetime.utcnow():%Y%m%d%H%M%S}.png"
+            try:
+                browser.get(url)
+            except WebDriverException as exc:
+                logger.error("Failed to load %s: %s", url, exc)
+            if cookies:
+                for cookie in cookies:
+                    try:
+                        browser.add_cookie(cookie)
+                    except WebDriverException as exc:
+                        logger.error("Failed to apply cookie for %s: %s", url, exc)
+                browser.get(url)
+            if not browser.save_screenshot(str(filename)):
+                raise RuntimeError("Screenshot capture failed")
+            return filename
+    except WebDriverException as exc:
+        logger.error("Failed to capture screenshot from %s: %s", url, exc)
+        message = str(exc)
+        if "Unable to obtain driver for firefox" in message:
+            message = (
+                "Firefox WebDriver is unavailable. Install geckodriver or configure the GECKODRIVER environment variable so Selenium can locate it."
+            )
+        raise RuntimeError(f"Screenshot capture failed: {message}") from exc
+
+
+def capture_rpi_snapshot(timeout: int = 10) -> Path:
+    """Capture a snapshot using the Raspberry Pi camera stack."""
+
+    tool_path = shutil.which("rpicam-still")
+    if not tool_path:
+        raise RuntimeError("rpicam-still is not available")
+    CAMERA_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.utcnow()
+    unique_suffix = uuid.uuid4().hex
+    filename = CAMERA_DIR / f"{timestamp:%Y%m%d%H%M%S}-{unique_suffix}.jpg"
+    try:
+        result = subprocess.run(
+            [tool_path, "-o", str(filename), "-t", "1"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout,
+        )
+    except Exception as exc:  # pragma: no cover - depends on camera stack
+        logger.error("Failed to invoke %s: %s", tool_path, exc)
+        raise RuntimeError(f"Snapshot capture failed: {exc}") from exc
+    if result.returncode != 0:
+        error = (result.stderr or result.stdout or "Snapshot capture failed").strip()
+        logger.error("rpicam-still exited with %s: %s", result.returncode, error)
+        raise RuntimeError(error)
+    if not filename.exists():
+        logger.error("Snapshot file %s was not created", filename)
+        raise RuntimeError("Snapshot capture failed")
+    return filename
+
+
+def save_screenshot(
+    path: Path,
+    node=None,
+    method: str = "",
+    transaction_uuid=None,
+    *,
+    content: str | None = None,
+    user=None,
+    link_duplicates: bool = False,
+):
+    """Save screenshot file info if not already recorded.
+
+    Returns the created :class:`ContentSample`. If ``link_duplicates`` is ``True``
+    and a sample with identical content already exists, the existing record is
+    returned instead of ``None``.
+    """
+
+    original = path
+    if not path.is_absolute():
+        path = settings.LOG_DIR / path
+    with path.open("rb") as fh:
+        digest = hashlib.sha256(fh.read()).hexdigest()
+    existing = ContentSample.objects.filter(hash=digest).first()
+    if existing:
+        if link_duplicates:
+            logger.info("Duplicate screenshot content; reusing existing sample")
+            return existing
+        logger.info("Duplicate screenshot content; record not created")
+        return None
+    stored_path = (original if not original.is_absolute() else path).as_posix()
+    data = {
+        "node": node,
+        "path": stored_path,
+        "method": method,
+        "hash": digest,
+        "kind": ContentSample.IMAGE,
+    }
+    if transaction_uuid is not None:
+        data["transaction_uuid"] = transaction_uuid
+    if content is not None:
+        data["content"] = content
+    if user is not None:
+        data["user"] = user
+    with suppress_default_classifiers():
+        sample = ContentSample.objects.create(**data)
+    run_default_classifiers(sample)
+    return sample