pumaguard 20.post172__py3-none-any.whl → 20.post189__py3-none-any.whl

pumaguard/main.py

@@ -18,6 +18,7 @@ from pumaguard.presets import (
     Preset,
     PresetError,
     get_default_settings_file,
+    get_xdg_cache_home,
 )
 from pumaguard.utils import (
     print_bash_completion,
@@ -182,7 +183,12 @@ def main():
     logging.basicConfig(level=logging.INFO)
     logger = logging.getLogger("PumaGuard")
 
-    file_handler = logging.FileHandler("pumaguard.log")
+    # Store logs in XDG cache directory
+    log_dir = get_xdg_cache_home() / "pumaguard"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "pumaguard.log"
+
+    file_handler = logging.FileHandler(str(log_file))
     file_handler.setLevel(logging.DEBUG)
     formatter = logging.Formatter(
         "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

pumaguard/presets.py

@@ -36,7 +36,7 @@ def get_xdg_config_home() -> Path:
 
 def get_xdg_data_home() -> Path:
     """
-    Get the XDG data home directory according to XDG Base Directory spec.
+    Get the XDG data home directory.
 
     Returns:
         Path to XDG_DATA_HOME (defaults to ~/.local/share if not set)
@@ -47,6 +47,19 @@ def get_xdg_data_home() -> Path:
     return Path.home() / ".local" / "share"
 
 
+def get_xdg_cache_home() -> Path:
+    """
+    Get the XDG cache home directory.
+
+    Returns:
+        Path to XDG_CACHE_HOME (defaults to ~/.cache if not set)
+    """
+    xdg_cache = os.environ.get("XDG_CACHE_HOME")
+    if xdg_cache:
+        return Path(xdg_cache)
+    return Path.home() / ".cache"
+
+
 def get_default_settings_file() -> str:
     """
     Get the default settings file path using XDG standards.

pumaguard/pumaguard-ui/flutter_bootstrap.js

@@ -38,6 +38,6 @@ _flutter.buildConfig = {"engineRevision":"13e658725ddaa270601426d1485636157e38c3
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1608487458"
+    serviceWorkerVersion: "181878644"
   }
 });

pumaguard/pumaguard-ui/flutter_service_worker.js

@@ -34,7 +34,7 @@ const RESOURCES = {"flutter.js": "24bc71911b75b5f8135c949e27a2984e",
 "canvaskit/skwasm.js.symbols": "3a4aadf4e8141f284bd524976b1d6bdc",
 "favicon.png": "5dcef449791fa27946b3d35ad8803796",
 "main.dart.wasm": "b7e85784e7cc42b937c6ddffca885d19",
-"flutter_bootstrap.js": "f20c5fcaa9f33f63921a966cdf944569",
+"flutter_bootstrap.js": "4a763a346d06c77e69652e5a31b9a5b8",
 "version.json": "d3ae24eea88b92d3d617cfcd1d6d057d",
 "main.dart.js": "8d76816e4e65d2d9504d5fd4013ba7cf"};
 // The application shell files that are downloaded before a service worker can

pumaguard/server.py

@@ -394,6 +394,24 @@ def main(options: argparse.Namespace, presets: Preset):
         webui.add_image_directory(folder)
         logger.info("Watching folder: %s", folder)
 
+    # Also expose classified result folders in the UI (browse-only)
+    try:
+        Path(presets.classified_puma_dir).mkdir(parents=True, exist_ok=True)
+        Path(presets.classified_other_dir).mkdir(parents=True, exist_ok=True)
+        Path(presets.intermediate_dir).mkdir(parents=True, exist_ok=True)
+    except OSError as exc:  # pragma: no cover
+        logger.error("Could not ensure classified folders exist: %s", exc)
+
+    webui.add_image_directory(presets.classified_puma_dir)
+    webui.add_image_directory(presets.classified_other_dir)
+    webui.add_image_directory(presets.intermediate_dir)
+    logger.info(
+        "Classified browsing enabled for: %s, %s; intermediate: %s",
+        presets.classified_puma_dir,
+        presets.classified_other_dir,
+        presets.intermediate_dir,
+    )
+
     manager.start_all()
 
     lock = acquire_lock()

pumaguard/web_routes/artifacts.py

@@ -0,0 +1,114 @@
+"""Artifacts routes for intermediate visualizations and CSVs."""
+
+from __future__ import (
+    annotations,
+)
+
+import os
+from typing import (
+    TYPE_CHECKING,
+)
+
+from flask import (
+    jsonify,
+    request,
+    send_from_directory,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"}
+
+
+def register_artifacts_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register artifacts endpoints for list and download."""
+
+    @app.route("/api/artifacts", methods=["GET"])
+    def list_artifacts():
+        base_dir = os.path.realpath(
+            os.path.normpath(webui.presets.intermediate_dir)
+        )
+        if not os.path.exists(base_dir):
+            return jsonify(
+                {"artifacts": [], "total": 0, "directory": base_dir}
+            )
+        ext_param = request.args.get("ext", default=None, type=str)
+        ext_filter: set[str] | None = None
+        if ext_param:
+            parts = [
+                p.strip().lower() for p in ext_param.split(",") if p.strip()
+            ]
+            ext_filter = {p if p.startswith(".") else f".{p}" for p in parts}
+        limit = request.args.get("limit", default=None, type=int)
+        entries: list[dict[str, object]] = []
+        try:
+            for filename in os.listdir(base_dir):
+                filepath = os.path.join(base_dir, filename)
+                if not os.path.isfile(filepath):
+                    continue
+                ext = os.path.splitext(filename)[1].lower()
+                if ext_filter is not None and ext not in ext_filter:
+                    continue
+                stat = os.stat(filepath)
+                kind = (
+                    "image"
+                    if ext in IMAGE_EXTS
+                    else ("csv" if ext == ".csv" else "file")
+                )
+                entries.append(
+                    {
+                        "filename": filename,
+                        "path": filepath,
+                        "ext": ext,
+                        "kind": kind,
+                        "size": stat.st_size,
+                        "modified": stat.st_mtime,
+                        "created": stat.st_ctime,
+                    }
+                )
+        except OSError:
+            return jsonify({"error": "Failed to read artifacts"}), 500
+        entries.sort(key=lambda x: x["modified"], reverse=True)  # type: ignore
+        if limit is not None and limit > 0:
+            entries = entries[:limit]
+        return jsonify(
+            {
+                "artifacts": entries,
+                "total": len(entries),
+                "directory": base_dir,
+            }
+        )
+
+    @app.route("/api/artifacts/<path:filepath>", methods=["GET"])
+    def get_artifact(filepath: str):
+        # Resolve to absolute path and validate within intermediate
+        base_dir = os.path.realpath(
+            os.path.normpath(webui.presets.intermediate_dir)
+        )
+        abs_filepath = os.path.realpath(os.path.normpath(filepath))
+        try:
+            common = os.path.commonpath([abs_filepath, base_dir])
+            if common != base_dir:
+                return jsonify({"error": "Access denied"}), 403
+        except ValueError:
+            # Different drives on Windows
+            return jsonify({"error": "Access denied"}), 403
+        if not os.path.exists(abs_filepath) or not os.path.isfile(
+            abs_filepath
+        ):
+            return jsonify({"error": "File not found"}), 404
+        directory = os.path.dirname(abs_filepath)
+        filename = os.path.basename(abs_filepath)
+        as_attachment = (
+            request.args.get("download", default="false").lower() == "true"
+        )
+        return send_from_directory(
+            directory, filename, as_attachment=as_attachment
+        )

pumaguard/web_routes/diagnostics.py

@@ -0,0 +1,89 @@
+"""Diagnostics routes for server status and troubleshooting info."""
+
+from __future__ import (
+    annotations,
+)
+
+from typing import (
+    TYPE_CHECKING,
+)
+
+from flask import (
+    jsonify,
+    request,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+
+def register_diagnostics_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register diagnostics endpoints for status and debug info."""
+
+    @app.route("/api/status", methods=["GET"])
+    def get_status():
+        origin = request.headers.get("Origin", "No Origin header")
+        host = request.headers.get("Host", "No Host header")
+        return jsonify(
+            {
+                "status": "running",
+                "version": "1.0.0",
+                "directories_count": len(webui.image_directories),
+                "host": webui.host,
+                "port": webui.port,
+                "request_origin": origin,
+                "request_host": host,
+            }
+        )
+
+    @app.route("/api/diagnostic", methods=["GET"])
+    def get_diagnostic():
+        diagnostic_info = {
+            "server": {
+                "host": webui.host,
+                "port": webui.port,
+                "flutter_dir": str(webui.flutter_dir),
+                "build_dir": str(webui.build_dir),
+                "build_exists": webui.build_dir.exists(),
+                "mdns_enabled": webui.mdns_enabled,
+                "mdns_name": webui.mdns_name if webui.mdns_enabled else None,
+                "mdns_url": (
+                    f"http://{webui.mdns_name}.local:{webui.port}"
+                    if webui.mdns_enabled
+                    else None
+                ),
+                "local_ip": webui._get_local_ip(),  # pylint: disable=protected-access
+            },
+            "request": {
+                "url": request.url,
+                "base_url": request.base_url,
+                "host": request.headers.get("Host", "N/A"),
+                "origin": request.headers.get("Origin", "N/A"),
+                "referer": request.headers.get("Referer", "N/A"),
+                "user_agent": request.headers.get("User-Agent", "N/A"),
+            },
+            "expected_behavior": {
+                "flutter_app_should_detect": (
+                    f"{request.scheme}://{request.host}"
+                ),
+                "api_calls_should_go_to": (
+                    f"{request.scheme}://{request.host}/api/..."
+                ),
+            },
+            "troubleshooting": {
+                "if_api_calls_go_to_localhost": (
+                    "Browser is using cached old JavaScript - clear cache"
+                ),
+                "if_page_doesnt_load": (
+                    "Check that Flutter app is built: make build-ui"
+                ),
+                "if_cors_errors": "Check browser console for details",
+            },
+        }
+        return jsonify(diagnostic_info)

pumaguard/web_routes/directories.py

@@ -0,0 +1,67 @@
+"""Directory management routes for adding and removing watch folders."""
+
+from __future__ import (
+    annotations,
+)
+
+import logging
+from typing import (
+    TYPE_CHECKING,
+)
+
+from flask import (
+    jsonify,
+    request,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+def register_directories_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register directory endpoints for list, add, remove."""
+
+    @app.route("/api/directories", methods=["GET"])
+    def get_directories():
+        return jsonify({"directories": webui.image_directories})
+
+    @app.route("/api/directories", methods=["POST"])
+    def add_directory():
+        data = request.json
+        directory = data.get("directory") if data else None
+        if not directory:
+            return jsonify({"error": "No directory provided"}), 400
+        # Validate existence happens inside webui.add_image_directory
+        if directory not in webui.image_directories:
+            webui.image_directories.append(directory)
+            logger.info("Added image directory: %s", directory)
+            if webui.folder_manager is not None:
+                webui.folder_manager.register_folder(
+                    directory, webui.watch_method
+                )
+                logger.info(
+                    "Registered folder with manager: %s (method: %s)",
+                    directory,
+                    webui.watch_method,
+                )
+        return jsonify(
+            {"success": True, "directories": webui.image_directories}
+        )
+
+    @app.route("/api/directories/<int:index>", methods=["DELETE"])
+    def remove_directory(index: int):
+        if 0 <= index < len(webui.image_directories):
+            removed = webui.image_directories.pop(index)
+            logger.info("Removed image directory: %s", removed)
+            return jsonify(
+                {"success": True, "directories": webui.image_directories}
+            )
+        return jsonify({"error": "Invalid index"}), 400

pumaguard/web_routes/folders.py

@@ -0,0 +1,121 @@
+"""
+Folders routes for browsing and listing images.
+"""
+
+from __future__ import (
+    annotations,
+)
+
+import os
+from typing import (
+    TYPE_CHECKING,
+    cast,
+)
+
+from flask import (
+    jsonify,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"}
+
+
+def register_folders_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register folder endpoints for list and browse images."""
+
+    @app.route("/api/folders", methods=["GET"])
+    def get_folders():
+        folders = []
+        for directory in webui.image_directories:
+            if not os.path.exists(directory):
+                continue
+            image_count = 0
+            for filename in os.listdir(directory):
+                filepath = os.path.join(directory, filename)
+                if os.path.isfile(filepath):
+                    ext = os.path.splitext(filename)[1].lower()
+                    if ext in IMAGE_EXTS:
+                        image_count += 1
+            folders.append(
+                {
+                    "path": directory,
+                    "name": os.path.basename(directory),
+                    "image_count": image_count,
+                }
+            )
+        return jsonify({"folders": folders})
+
+    @app.route("/api/folders/<path:folder_path>/images", methods=["GET"])
+    def get_folder_images(folder_path: str):
+        # Try to resolve folder_path relative to each allowed image directory
+        abs_folder = None
+        resolved_base = None
+        for directory in webui.image_directories:
+            abs_directory = os.path.realpath(os.path.normpath(directory))
+            # Always join user input to base, then normalize
+            candidate_folder = os.path.realpath(
+                os.path.join(abs_directory, folder_path)
+            )
+            try:
+                common = os.path.commonpath([candidate_folder, abs_directory])
+                if common == abs_directory:
+                    abs_folder = candidate_folder
+                    resolved_base = abs_directory
+                    break
+            except ValueError:
+                # Different drives on Windows
+                continue
+        if abs_folder is None:
+            # Ensure file is within the allowed folder
+            return jsonify({"error": "Access denied"}), 403
+        if not os.path.exists(abs_folder) or not os.path.isdir(abs_folder):
+            return jsonify({"error": "Folder not found"}), 404
+        images = []
+        for filename in os.listdir(abs_folder):
+            filepath = os.path.join(abs_folder, filename)
+            resolved_filepath = os.path.realpath(os.path.normpath(filepath))
+            if (
+                os.path.commonpath([resolved_filepath, abs_folder])
+                != abs_folder
+            ):
+                continue
+            if os.path.isfile(resolved_filepath):
+                ext = os.path.splitext(filename)[1].lower()
+                if ext in IMAGE_EXTS:
+                    stat = os.stat(resolved_filepath)
+                    rel_file_path = os.path.relpath(
+                        resolved_filepath, resolved_base
+                    )
+                    images.append(
+                        {
+                            "filename": filename,
+                            "path": rel_file_path,
+                            "size": stat.st_size,
+                            "modified": stat.st_mtime,
+                            "created": stat.st_ctime,
+                        }
+                    )
+
+        images.sort(key=lambda x: cast(float, x["modified"]), reverse=True)
+        # Return only relative folder path to root and the root directory name
+        if resolved_base is not None:
+            rel_folder_path = os.path.relpath(abs_folder, resolved_base)
+            folder_name = os.path.basename(resolved_base)
+        else:
+            rel_folder_path = ""
+            folder_name = ""
+        return jsonify(
+            {
+                "images": images,
+                "folder": rel_folder_path,
+                "base": folder_name,
+            }
+        )

pumaguard/web_routes/photos.py

@@ -0,0 +1,112 @@
+"""Photos routes for listing, fetching, and deleting images."""
+
+from __future__ import (
+    annotations,
+)
+
+import os
+from typing import (
+    TYPE_CHECKING,
+)
+
+from flask import (
+    jsonify,
+    send_from_directory,
+)
+
+if TYPE_CHECKING:
+    from flask import (
+        Flask,
+    )
+
+    from pumaguard.web_ui import (
+        WebUI,
+    )
+
+IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"}
+
+
+def register_photos_routes(app: "Flask", webui: "WebUI") -> None:
+    """Register photo endpoints for list, get, and delete."""
+
+    @app.route("/api/photos", methods=["GET"])
+    def get_photos():
+        photos: list[dict] = []
+        for directory in webui.image_directories:
+            if not os.path.exists(directory):
+                continue
+            for filename in os.listdir(directory):
+                filepath = os.path.join(directory, filename)
+                if os.path.isfile(filepath):
+                    ext = os.path.splitext(filename)[1].lower()
+                    if ext in IMAGE_EXTS:
+                        stat = os.stat(filepath)
+                        photos.append(
+                            {
+                                "filename": filename,
+                                "path": filepath,
+                                "directory": directory,
+                                "size": stat.st_size,
+                                "modified": stat.st_mtime,
+                                "created": stat.st_ctime,
+                            }
+                        )
+        photos.sort(key=lambda x: x["modified"], reverse=True)
+        return jsonify({"photos": photos, "total": len(photos)})
+
+    @app.route("/api/photos/<path:filepath>", methods=["GET"])
+    def get_photo(filepath: str):
+        # Safely resolve user provided path against allowed directories
+        abs_filepath = None
+        for directory in webui.image_directories:
+            abs_directory = os.path.realpath(directory)
+            joined_path = os.path.join(abs_directory, filepath)
+            candidate = os.path.realpath(joined_path)
+            try:
+                common = os.path.commonpath([candidate, abs_directory])
+                if common == abs_directory:
+                    abs_filepath = candidate
+                    break
+            except ValueError:
+                # Different drives on Windows
+                continue
+        if abs_filepath is None:
+            return jsonify({"error": "Access denied"}), 403
+        if not os.path.exists(abs_filepath) or not os.path.isfile(
+            abs_filepath
+        ):
+            return jsonify({"error": "File not found"}), 404
+        ext = os.path.splitext(abs_filepath)[1].lower()
+        if ext not in IMAGE_EXTS:
+            return jsonify({"error": "Access denied"}), 403
+        directory = os.path.dirname(abs_filepath)
+        filename = os.path.basename(abs_filepath)
+        return send_from_directory(directory, filename)
+
+    @app.route("/api/photos/<path:filepath>", methods=["DELETE"])
+    def delete_photo(filepath: str):
+        # Safely resolve user provided path against allowed directories
+        abs_filepath = None
+        for directory in webui.image_directories:
+            abs_directory = os.path.realpath(directory)
+            joined_path = os.path.join(abs_directory, filepath)
+            candidate = os.path.realpath(joined_path)
+            try:
+                common = os.path.commonpath([candidate, abs_directory])
+                if common == abs_directory:
+                    abs_filepath = candidate
+                    break
+            except ValueError:
+                # Different drives on Windows
+                continue
+        if abs_filepath is None:
+            return jsonify({"error": "Access denied"}), 403
+        if not os.path.exists(abs_filepath) or not os.path.isfile(
+            abs_filepath
+        ):
+            return jsonify({"error": "File not found"}), 404
+        ext = os.path.splitext(abs_filepath)[1].lower()
+        if ext not in IMAGE_EXTS:
+            return jsonify({"error": "Access denied"}), 403
+        os.remove(abs_filepath)
+        return jsonify({"success": True, "message": "Photo deleted"})