sensor-modeling 0.2.0__py3-none-any.whl

sensor_modeling/visualization/research.py

@@ -0,0 +1,60 @@
+"""Research oriented plotting utilities."""
+
+from __future__ import annotations
+
+from collections.abc import Collection, Sequence
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import seaborn as sns
+
+
+def _require_columns(
+    data: pd.DataFrame, required: Collection[str], context: str
+) -> None:
+    """Raise a clear error when required plotting columns are missing."""
+    missing = sorted(set(required) - set(data.columns))
+    if missing:
+        names = ", ".join(missing)
+        raise ValueError(f"{context} requires columns: {names}")
+
+
+def _finite_residuals(residuals: Sequence[float]) -> list[float]:
+    """Return residuals as finite floats for diagnostic plotting."""
+    values = np.asarray(list(residuals), dtype=float)
+    if values.size == 0:
+        raise ValueError("residuals must contain at least one value")
+    if not np.isfinite(values).all():
+        raise ValueError("residuals must contain only finite values")
+    return values.tolist()
+
+
+def publication_figure(data: pd.DataFrame, x: str, y: str, hue: str | None = None):
+    """Generate a publication quality figure using seaborn."""
+    required = {x, y}
+    if hue is not None:
+        required.add(hue)
+    _require_columns(data, required, "publication_figure")
+    ax = sns.lineplot(data=data, x=x, y=y, hue=hue)
+    ax.set_title("Publication Quality Figure")
+    return ax.get_figure()
+
+
+def model_diagnostics(residuals: Sequence[float]):
+    """Return a Plotly histogram of model residuals."""
+    return px.histogram(
+        x=_finite_residuals(residuals), nbins=30, title="Model Residuals"
+    )
+
+
+def performance_comparison(scores: pd.DataFrame) -> px.bar:
+    """Bar chart comparing performance metrics across models."""
+    _require_columns(scores, {"metric", "model", "score"}, "performance_comparison")
+    return px.bar(scores, x="model", y="score", color="metric")
+
+
+def statistical_tests(results: pd.DataFrame) -> px.scatter:
+    """Scatter plot visualizing statistical test outcomes."""
+    _require_columns(results, {"model", "pvalue", "test"}, "statistical_tests")
+    return px.scatter(results, x="test", y="pvalue", color="model")

sensor_modeling/visualization/web_app.py

@@ -0,0 +1,137 @@
+"""Lightweight Flask web interface for running analyses."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import tempfile
+from functools import wraps
+from pathlib import Path
+from typing import Callable
+
+from flask import (
+    Flask,
+    Response,
+    abort,
+    current_app,
+    render_template_string,
+    request,
+    send_file,
+)
+from werkzeug.datastructures import FileStorage
+from werkzeug.utils import secure_filename
+
+UPLOAD_DIR = Path(tempfile.gettempdir()) / "sensor-modeling-uploads"
+
+
+def _configured_upload_dir() -> Path:
+    """Return the active upload directory, creating it if needed."""
+    upload_dir = Path(current_app.config["UPLOAD_DIR"]).expanduser().resolve()
+    upload_dir.mkdir(parents=True, exist_ok=True)
+    return upload_dir
+
+
+def _check_auth(username: str, password: str) -> bool:
+    """Validate provided credentials against environment variables."""
+    expected_user = os.environ.get("SM_USER")
+    expected_pass = os.environ.get("SM_PASS")
+    if expected_user is None or expected_pass is None:
+        return False
+    return username == expected_user and password == expected_pass
+
+
+def _auth_failed() -> Response:  # pragma: no cover - simple response
+    """Return a 401 response requesting basic authentication."""
+    return Response(
+        "Authentication required",
+        401,
+        {"WWW-Authenticate": 'Basic realm="Login"'},
+    )
+
+
+def _uploaded_data_file() -> FileStorage:
+    """Return the uploaded data file or abort with a clear client error."""
+    if "data" not in request.files:
+        abort(400, "missing data file")
+    file = request.files["data"]
+    if not file.filename:
+        abort(400, "invalid filename")
+    return file
+
+
+def requires_auth(f: Callable) -> Callable:
+    """Enforce basic authentication on endpoints."""
+
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        auth = request.authorization
+        if not auth or not _check_auth(auth.username, auth.password):
+            return _auth_failed()
+        return f(*args, **kwargs)
+
+    return decorated
+
+
+app = Flask(__name__)
+app.config["MAX_CONTENT_LENGTH"] = 2 * 1024 * 1024  # 2MB uploads
+
+
+@app.route("/", methods=["GET"])
+@requires_auth
+def index():  # pragma: no cover - simple template
+    """Render a minimal upload form."""
+    return render_template_string(
+        "<h1>Sensor Modeling</h1>"
+        "<form action='{{ url_for(\"run\") }}' method='post' "
+        "enctype='multipart/form-data'>"
+        "<input type='file' name='data'>"
+        "<input type='text' name='param'>"
+        "<input type='submit'>"
+        "</form>"
+    )
+
+
+@app.route("/run", methods=["POST"])
+@requires_auth
+def run():
+    """Persist uploaded data and return a placeholder result."""
+    file = _uploaded_data_file()
+    param = request.form.get("param", "")
+    filename = secure_filename(file.filename)
+    if not filename:
+        abort(400, "invalid filename")
+    upload_dir = _configured_upload_dir()
+    path = (upload_dir / filename).resolve()
+    if path.parent != upload_dir:  # path traversal guard
+        abort(400, "invalid path")
+    file.save(path)
+    # Placeholder analysis step
+    result_path = path.with_suffix(".txt")
+    with open(result_path, "w", encoding="utf-8") as fh:
+        fh.write(f"processed with param={param}\n")
+    return send_file(result_path, as_attachment=True)
+
+
+def create_app(upload_dir: str | os.PathLike[str] | None = None) -> Flask:
+    """Create the Flask application."""
+    configured_dir = upload_dir or os.environ.get("SM_UPLOAD_DIR") or UPLOAD_DIR
+    app.config["UPLOAD_DIR"] = str(configured_dir)
+    return app
+
+
+def main() -> None:
+    """Run the Flask development server for the web app."""
+    parser = argparse.ArgumentParser(description="Run the sensor visualization app")
+    parser.add_argument("--host", default="127.0.0.1", help="Host interface to bind")
+    parser.add_argument("--port", type=int, default=5000, help="Port to bind")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Run the Flask development server in debug mode",
+    )
+    args = parser.parse_args()
+    create_app().run(host=args.host, port=args.port, debug=args.debug)
+
+
+if __name__ == "__main__":
+    main()