pumaguard 20.post174__py3-none-any.whl → 20.post190__py3-none-any.whl

pumaguard/web_routes/settings.py

@@ -0,0 +1,116 @@
+"""Settings routes for loading, saving, and updating presets."""
+
+from __future__ import (
+    annotations,
+)
+
+import logging
+from typing import (
+    TYPE_CHECKING,
+)
+
+import yaml
+from flask import (
+    jsonify,
+    request,
+)
+from yaml.representer import (
+    YAMLError,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+def register_settings_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register settings endpoints for GET, PUT, save, and load."""
+
+    @app.route("/api/settings", methods=["GET"])
+    def get_settings():
+        return jsonify(dict(webui.presets))
+
+    @app.route("/api/settings", methods=["PUT"])
+    def update_settings():
+        try:
+            data = request.json
+            if not data:
+                return jsonify({"error": "No data provided"}), 400
+
+            allowed_settings = [
+                "YOLO-min-size",
+                "YOLO-conf-thresh",
+                "YOLO-max-dets",
+                "YOLO-model-filename",
+                "classifier-model-filename",
+                "deterrent-sound-file",
+                "file-stabilization-extra-wait",
+                "play-sound",
+            ]
+
+            if len(data) == 0:
+                raise ValueError("Did not receive any settings")
+
+            for key, value in data.items():
+                if key in allowed_settings:
+                    logger.debug("Updating %s with %s", key, value)
+                    attr_name = key.replace("-", "_").replace("YOLO_", "yolo_")
+                    setattr(webui.presets, attr_name, value)
+                else:
+                    logger.debug("Skipping unknown/read-only setting: %s", key)
+
+            try:
+                filepath = webui.presets.settings_file
+                settings_dict = dict(webui.presets)
+                with open(filepath, "w", encoding="utf-8") as f:
+                    yaml.dump(settings_dict, f, default_flow_style=False)
+                logger.info("Settings updated and saved to %s", filepath)
+            except YAMLError:
+                logger.exception("Error saving settings")
+                return (
+                    jsonify(
+                        {
+                            "error": (
+                                "Settings updated but failed to save due "
+                                "to an internal error"
+                            )
+                        }
+                    ),
+                    500,
+                )
+
+            return jsonify(
+                {"success": True, "message": "Settings updated and saved"}
+            )
+        except ValueError as e:  # pragma: no cover (unexpected)
+            logger.error("Error updating settings: %s", e)
+            return jsonify({"error": str(e)}), 500
+
+    @app.route("/api/settings/save", methods=["POST"])
+    def save_settings():
+        data = request.json
+        filepath = data.get("filepath") if data else None
+        if not filepath:
+            filepath = webui.presets.settings_file
+        settings_dict = dict(webui.presets)
+        with open(filepath, "w", encoding="utf-8") as f:
+            yaml.dump(settings_dict, f, default_flow_style=False)
+        logger.info("Settings saved to %s", filepath)
+        return jsonify({"success": True, "filepath": filepath})
+
+    @app.route("/api/settings/load", methods=["POST"])
+    def load_settings():
+        data = request.json
+        filepath = data.get("filepath") if data else None
+        if not filepath:
+            return jsonify({"error": "No filepath provided"}), 400
+        webui.presets.load(filepath)
+        logger.info("Settings loaded from %s", filepath)
+        return jsonify({"success": True, "message": "Settings loaded"})

pumaguard/web_routes/sync.py

@@ -0,0 +1,130 @@
+"""Sync routes for checksums and batch downloading."""
+
+from __future__ import (
+    annotations,
+)
+
+import hashlib
+import io
+import os
+import zipfile
+from typing import (
+    TYPE_CHECKING,
+)
+
+from flask import (
+    jsonify,
+    request,
+    send_file,
+    send_from_directory,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+
+def _calculate_file_checksum(filepath: str) -> str:
+    """Calculate SHA256 checksum of file."""
+    sha256_hash = hashlib.sha256()
+    with open(filepath, "rb") as f:
+        for byte_block in iter(lambda: f.read(4096), b""):
+            sha256_hash.update(byte_block)
+    return sha256_hash.hexdigest()
+
+
+def register_sync_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register sync endpoints for file checksums and downloads."""
+
+    @app.route("/api/sync/checksums", methods=["POST"])
+    def calculate_checksums():
+        data = request.json
+        if not data or "files" not in data:
+            return jsonify({"error": "No files provided"}), 400
+        client_files = data["files"]
+        files_to_download = []
+        for filepath, client_checksum in client_files.items():
+            # Resolve and validate within allowed directories
+            abs_filepath = os.path.realpath(os.path.normpath(filepath))
+            allowed = False
+            for directory in webui.image_directories:
+                abs_directory = os.path.realpath(os.path.normpath(directory))
+                try:
+                    common = os.path.commonpath([abs_filepath, abs_directory])
+                    if common == abs_directory:
+                        allowed = True
+                        break
+                except ValueError:
+                    # Different drives on Windows
+                    continue
+            if not allowed:
+                continue
+            if not os.path.exists(abs_filepath):
+                continue
+            server_checksum = _calculate_file_checksum(abs_filepath)
+            if server_checksum != client_checksum:
+                stat = os.stat(abs_filepath)
+                files_to_download.append(
+                    {
+                        "path": filepath,
+                        "checksum": server_checksum,
+                        "size": stat.st_size,
+                        "modified": stat.st_mtime,
+                    }
+                )
+        return jsonify(
+            {
+                "files_to_download": files_to_download,
+                "total": len(files_to_download),
+            }
+        )
+
+    @app.route("/api/sync/download", methods=["POST"])
+    def download_files():
+        data = request.json
+        if not data or "files" not in data:
+            return jsonify({"error": "No files provided"}), 400
+        file_paths = data["files"]
+        validated_files = []
+        for filepath in file_paths:
+            # Resolve and validate within allowed directories
+            abs_filepath = os.path.realpath(os.path.normpath(filepath))
+            allowed = False
+            for directory in webui.image_directories:
+                # Ensure allowed directories are normalized and real paths
+                abs_directory = os.path.realpath(os.path.normpath(directory))
+                try:
+                    common = os.path.commonpath([abs_filepath, abs_directory])
+                    if common == abs_directory and os.path.isfile(
+                        abs_filepath
+                    ):
+                        allowed = True
+                        break
+                except ValueError:
+                    # Different drives on Windows
+                    continue
+            if allowed and os.path.exists(abs_filepath):
+                validated_files.append(abs_filepath)
+        if not validated_files:
+            return jsonify({"error": "No valid files to download"}), 400
+        if len(validated_files) == 1:
+            directory = os.path.dirname(validated_files[0])
+            filename = os.path.basename(validated_files[0])
+            return send_from_directory(directory, filename, as_attachment=True)
+        memory_file = io.BytesIO()
+        with zipfile.ZipFile(memory_file, "w", zipfile.ZIP_DEFLATED) as zf:
+            for filepath in validated_files:
+                arcname = os.path.basename(filepath)
+                zf.write(filepath, arcname)
+        memory_file.seek(0)
+        return send_file(
+            memory_file,
+            mimetype="application/zip",
+            as_attachment=True,
+            download_name="pumaguard_images.zip",
+        )