nucleuskit-toolkit 2.2.0__py3-none-any.whl

nucleuskit_toolkit/logging_utils.py

@@ -0,0 +1,68 @@
+"""Console logging helpers used across the pipeline (GUI-safe, no ANSI when not a TTY)."""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+_LOGGER = logging.getLogger("nucleuskit_toolkit")
+_CORE_LOGGER = logging.getLogger("reak_core")  # processing messages of re-ak-core
+
+
+class _AnsiAwareHandler(logging.StreamHandler):
+    """Write to the current ``sys.stdout``.
+
+    The stream is resolved on every record so a GUI worker can redirect
+    stdout into the on-screen log after this handler was created.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            stream = sys.stdout
+            if stream is None:
+                return
+            self.stream = stream
+            if hasattr(stream, "isatty") and stream.isatty():
+                if record.levelno >= logging.ERROR:
+                    msg = f"\033[91m{msg}\033[0m"
+                elif record.levelno >= logging.WARNING:
+                    msg = f"\033[93m{msg}\033[0m"
+            stream.write(msg + self.terminator)
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
+def configure_logging(level: int = logging.INFO) -> None:
+    """Attach a single stream handler to the toolkit and re-ak-core loggers if none exist (idempotent)."""
+    for logger in (_LOGGER, _CORE_LOGGER):
+        if logger.handlers:
+            logger.setLevel(level)
+            continue
+        handler = _AnsiAwareHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logger.addHandler(handler)
+        logger.setLevel(level)
+        logger.propagate = False
+
+
+def printInfo(message: object) -> None:
+    configure_logging()
+    _LOGGER.info("%s", message)
+
+
+def printWarning(message: object) -> None:
+    configure_logging()
+    _LOGGER.warning("%s", message)
+
+
+def printError(message: object) -> None:
+    configure_logging()
+    _LOGGER.error("%s", message)
+
+
+class bcolors:
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"

nucleuskit_toolkit/mqtt/__init__.py

@@ -0,0 +1,5 @@
+"""MQTT controller for Vizia Mobile devices."""
+
+from nucleuskit_toolkit.mqtt.mqtt_controller import MqttController
+
+__all__ = ["MqttController"]

nucleuskit_toolkit/mqtt/mqtt_controller.py

@@ -0,0 +1,256 @@
+"""
+MQTT controller for Vizia Mobile Android devices.
+
+Connects to a user-configured MQTT broker and drives recording sessions via
+the Vizia Mobile MQTT interface (see doc/mqtt_interface.md for the full contract).
+
+Thread-safety: paho-mqtt runs its own network loop in a background thread.
+All public methods are safe to call from any thread. GUI consumers should
+connect to the Qt signals defined in MqttBridge instead of calling these
+methods directly from UI callbacks.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Callable
+
+DEFAULT_BROKER_PORT = 1883
+DEFAULT_STATUS_TOPIC = "vizia/status"
+DEFAULT_COMMAND_TOPIC_SUFFIX = "control/"
+
+TARGET_ALL = "__ALL__"
+
+
+@dataclass
+class DeviceStatus:
+    device_id: str
+    recording: bool = False
+    battery: int = -1
+    last_seen: float = field(default_factory=time.time)
+
+
+class MqttController:
+    """
+    Manages a single MQTT connection to a Vizia Mobile broker.
+
+    Parameters
+    ----------
+    broker_host : str
+        IP address or hostname of the MQTT broker.
+    broker_port : int
+        TCP port of the broker (default 1883).
+    status_topic : str
+        Topic on which devices publish status packets (default "vizia/status").
+    command_topic_suffix : str
+        Suffix appended after ``{recorderId}/`` when publishing commands
+        (default "control/").
+    on_log : Callable[[str], None] | None
+        Called from the paho network thread with human-readable log lines.
+    on_device_update : Callable[[DeviceStatus], None] | None
+        Called whenever a device status packet is received or updated.
+    on_connected : Callable[[], None] | None
+        Called once the broker connection is established.
+    on_disconnected : Callable[[], None] | None
+        Called when the connection drops.
+    """
+
+    def __init__(
+        self,
+        broker_host: str,
+        broker_port: int = DEFAULT_BROKER_PORT,
+        status_topic: str = DEFAULT_STATUS_TOPIC,
+        command_topic_suffix: str = DEFAULT_COMMAND_TOPIC_SUFFIX,
+        on_log: Callable[[str], None] | None = None,
+        on_device_update: Callable[[DeviceStatus], None] | None = None,
+        on_connected: Callable[[], None] | None = None,
+        on_disconnected: Callable[[], None] | None = None,
+    ) -> None:
+        self._broker_host = broker_host.strip()
+        self._broker_port = broker_port
+        self._status_topic = status_topic
+        self._command_topic_suffix = command_topic_suffix
+        self._on_log = on_log
+        self._on_device_update = on_device_update
+        self._on_connected = on_connected
+        self._on_disconnected = on_disconnected
+
+        self._devices: dict[str, DeviceStatus] = {}
+        self._devices_lock = threading.Lock()
+        self._connected = False
+        self._client = None
+
+    # ── Public properties ────────────────────────────────────────────────
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected
+
+    @property
+    def discovered_devices(self) -> list[DeviceStatus]:
+        with self._devices_lock:
+            return list(self._devices.values())
+
+    # ── Connection management ────────────────────────────────────────────
+
+    def connect(self) -> None:
+        """Connect to the broker and start the background network loop."""
+        try:
+            import paho.mqtt.client as mqtt
+        except ImportError as exc:
+            raise RuntimeError(
+                "paho-mqtt is required for the MQTT controller. "
+                "Install with: pip install 'nucleuskit-toolkit[gui]'"
+            ) from exc
+
+        self._log(f"Connecting to broker {self._broker_host}:{self._broker_port} …")
+
+        client = mqtt.Client(
+            client_id=f"nucleuskit-{int(time.time())}",
+            protocol=mqtt.MQTTv311,
+            clean_session=True,
+        )
+        client.on_connect = self._on_mqtt_connect
+        client.on_disconnect = self._on_mqtt_disconnect
+        client.on_message = self._on_mqtt_message
+        client.on_log = self._on_mqtt_log
+
+        client.connect_async(self._broker_host, self._broker_port, keepalive=60)
+        client.loop_start()
+        self._client = client
+
+    def disconnect(self) -> None:
+        """Gracefully disconnect from the broker."""
+        if self._client is None:
+            return
+        self._log("Disconnecting from broker …")
+        try:
+            self._client.loop_stop()
+            self._client.disconnect()
+        except Exception as exc:
+            self._log(f"[WARN] Error during disconnect: {exc}")
+        self._client = None
+        self._connected = False
+
+    # ── Command publishing ───────────────────────────────────────────────
+
+    def send_start_recording(self, device_id: str = TARGET_ALL) -> None:
+        """Send START_RECORDING to one device or all discovered devices."""
+        payload = json.dumps({"Type": "COMMAND", "Content": {"Code": "START_RECORDING"}})
+        self._publish_to(device_id, payload, label="START_RECORDING")
+
+    def send_stop_recording(self, device_id: str = TARGET_ALL) -> None:
+        """Send STOP_RECORDING to one device or all discovered devices."""
+        payload = json.dumps({"Type": "COMMAND", "Content": {"Code": "STOP_RECORDING"}})
+        self._publish_to(device_id, payload, label="STOP_RECORDING")
+
+    def send_tag(self, code: str, values: str = "", device_id: str = TARGET_ALL) -> None:
+        """Inject an event marker into the active recording session."""
+        payload = json.dumps({"Type": "TAG", "Content": {"Code": code, "Values": values}})
+        self._publish_to(device_id, payload, label=f"TAG:{code}")
+
+    # ── Internal helpers ─────────────────────────────────────────────────
+
+    def _publish_to(self, device_id: str, payload: str, label: str) -> None:
+        if not self._connected or self._client is None:
+            self._log("[WARN] Not connected — command not sent.")
+            return
+
+        if device_id == TARGET_ALL:
+            with self._devices_lock:
+                targets = list(self._devices.keys())
+            if not targets:
+                self._log("[WARN] No devices discovered yet — command not sent.")
+                return
+            for did in targets:
+                topic = f"{did}/{self._command_topic_suffix}"
+                self._client.publish(topic, payload, qos=0)
+                self._log(f"→ [{label}] → {topic}")
+        else:
+            topic = f"{device_id}/{self._command_topic_suffix}"
+            self._client.publish(topic, payload, qos=0)
+            self._log(f"→ [{label}] → {topic}")
+
+    def _log(self, msg: str) -> None:
+        if self._on_log is not None:
+            self._on_log(msg)
+
+    # ── paho callbacks (run on the paho network thread) ──────────────────
+
+    def _on_mqtt_connect(self, client, userdata, flags, rc) -> None:  # type: ignore[no-untyped-def]
+        import paho.mqtt.client as mqtt
+
+        if rc == mqtt.CONNACK_ACCEPTED:
+            self._connected = True
+            self._log(f"✓ Connected to {self._broker_host}:{self._broker_port}")
+            self._log(f"  Subscribing to status topic: {self._status_topic}")
+            client.subscribe(self._status_topic, qos=0)
+            self._log("  Ready — waiting for device status packets …")
+            if self._on_connected:
+                self._on_connected()
+        else:
+            reason = {
+                1: "unacceptable protocol version",
+                2: "identifier rejected",
+                3: "server unavailable",
+                4: "bad username or password",
+                5: "not authorised",
+            }.get(rc, f"unknown reason code {rc}")
+            self._log(f"✗ Connection refused: {reason}")
+
+    def _on_mqtt_disconnect(self, client, userdata, rc) -> None:  # type: ignore[no-untyped-def]
+        was_connected = self._connected
+        self._connected = False
+        if rc == 0:
+            self._log("Disconnected cleanly.")
+        else:
+            self._log(f"[WARN] Unexpected disconnect (rc={rc}) — paho will attempt reconnect …")
+        if was_connected and self._on_disconnected:
+            self._on_disconnected()
+
+    def _on_mqtt_message(self, client, userdata, msg) -> None:  # type: ignore[no-untyped-def]
+        try:
+            payload = msg.payload.decode("utf-8")
+            data = json.loads(payload)
+            device_id = str(data.get("id", "device"))
+            recording = bool(data.get("recording", False))
+            battery = int(data.get("battery", -1))
+
+            with self._devices_lock:
+                existing = self._devices.get(device_id)
+                is_new = existing is None
+                status = DeviceStatus(
+                    device_id=device_id,
+                    recording=recording,
+                    battery=battery,
+                    last_seen=time.time(),
+                )
+                self._devices[device_id] = status
+
+            if is_new:
+                self._log(
+                    f"  ● New device discovered: '{device_id}'  "
+                    f"(recording={recording}, battery={battery}%)"
+                )
+
+            if self._on_device_update:
+                self._on_device_update(status)
+
+        except (json.JSONDecodeError, KeyError, ValueError) as exc:
+            self._log(f"[WARN] Malformed status packet on {msg.topic}: {exc}")
+
+    def _on_mqtt_log(self, client, userdata, level, buf) -> None:  # type: ignore[no-untyped-def]
+        import paho.mqtt.client as mqtt
+
+        if level in (mqtt.MQTT_LOG_DEBUG,):
+            return
+        prefix = {
+            mqtt.MQTT_LOG_INFO: "[paho:INFO]",
+            mqtt.MQTT_LOG_NOTICE: "[paho:NOTICE]",
+            mqtt.MQTT_LOG_WARNING: "[paho:WARN]",
+            mqtt.MQTT_LOG_ERR: "[paho:ERR]",
+        }.get(level, "[paho]")
+        self._log(f"{prefix} {buf}")

nucleuskit_toolkit/pipeline.py

@@ -0,0 +1,194 @@
+"""
+Nucleus-Kit analytics toolkit (offline session processing).
+
+The processing itself is re-ak-core's default pipeline (``reak_core.pipeline``): heart dynamics,
+arousal, cognition, emotions, events and the emotions report. Nucleus-Kit adds its local steps
+around it: POV movie conversion, session video rotation and GPS.
+"""
+
+from __future__ import annotations
+
+import threading
+from abc import ABC, abstractmethod
+
+from reak_core.io.session import Session
+from reak_core.pipeline import FunctionStep, Pipeline, RunContext, StepResult
+
+from nucleuskit_toolkit.camera import convertPOVMovieClip, ensure_session_video_rotated_180
+from nucleuskit_toolkit.config import resolve_pov_settings
+from nucleuskit_toolkit.logging_utils import printError, printInfo, printWarning
+from nucleuskit_toolkit.position import processGPS
+
+
+class BasePipeline(ABC):
+    """Minimal base from analyticsEngine.pipelines.BasePipeline."""
+
+    def __init__(self, configuration=None):
+        self.configured = False
+        self.pipeName = "Unknown"
+
+    @abstractmethod
+    def processSession(self, jobDetails):
+        pass
+
+    def updateSession(self, jobDetails):
+        return False
+
+    def configure(self, config_name=None):
+        pass
+
+    def get_pipeline_name(self):
+        return self.pipeName
+
+
+_STEP_LOG = {
+    "prepare": "[pipeline] Preparing session folders",
+    "video_rotation": "[pipeline] Checking session video orientation",
+    "metainfo": "[pipeline] Reading recording length",
+    "heart_dynamics": "[pipeline] Computing heart dynamics",
+    "arousal": "[pipeline] Computing arousal",
+    "cognition": "[pipeline] Computing cognitive indexes",
+    "emotions": "[pipeline] Computing emotions",
+    "feature_events": "[pipeline] Processing events",
+    "playback_annotations": "[pipeline] Seeding playback annotations",
+    "gps": "[pipeline] Processing GPS",
+}
+
+
+def _local_step(name: str, fn) -> FunctionStep:
+    """A Nucleus-Kit step backed by ``fn(session_path)``."""
+
+    def run(session: Session, context: RunContext) -> dict:
+        fn(session.root)
+        return {}
+
+    return FunctionStep(name, run)
+
+
+class _LoggedStep:
+    """Prints the Nucleus-Kit progress line before running the wrapped step.
+
+    When ``cancel`` is set, the step is skipped instead: a cancelled run finishes the step in progress, then
+    skips the remaining ones (recorded as ``skipped`` / ``cancelled`` in ``results/processing.json``).
+    """
+
+    def __init__(self, step, cancel: threading.Event | None = None):
+        self._step = step
+        self._cancel = cancel
+        self.name = step.name
+
+    def run(self, session: Session, context: RunContext):
+        if self._cancel is not None and self._cancel.is_set():
+            return StepResult(self.name, "skipped", detail={"reason": "cancelled"})
+        printInfo(_STEP_LOG.get(self.name, f"[pipeline] {self.name}"))
+        return self._step.run(session, context)
+
+
+class _CancellableExporter:
+    """Runs the wrapped exporter unless the run was cancelled (a cancelled run exports nothing)."""
+
+    def __init__(self, exporter, cancel: threading.Event):
+        self._exporter = exporter
+        self._cancel = cancel
+        self.name = exporter.name
+
+    def export(self, session: Session, context: RunContext, results) -> None:
+        if not self._cancel.is_set():
+            self._exporter.export(session, context, results)
+
+
+def build_pipeline(
+    *,
+    skip_video_rotation: bool = False,
+    apply_nlms: bool = True,
+    emotion_model: str | None = None,
+    cancel: threading.Event | None = None,
+) -> Pipeline:
+    """re-ak-core's default pipeline with the Nucleus-Kit local steps, in Nucleus-Kit's order."""
+    pipeline = Pipeline.default(emotion_model=emotion_model, apply_nlms=apply_nlms)
+    if not skip_video_rotation:
+        pipeline.with_step(_local_step("video_rotation", ensure_session_video_rotated_180), after="prepare")
+    pipeline.with_step(_local_step("gps", processGPS))
+    pipeline.steps = [_LoggedStep(step, cancel) for step in pipeline.steps]
+    if cancel is not None:
+        pipeline.exporters = [_CancellableExporter(exporter, cancel) for exporter in pipeline.exporters]
+    return pipeline
+
+
+class NucleusKitProcessingToolkit(BasePipeline):
+    """
+    Offline analytics pipeline for processing session data from a local folder.
+    """
+
+    def __init__(
+        self,
+        configuration=None,
+        *,
+        skip_video_rotation: bool = False,
+        apply_nlms: bool = True,
+        emotion_model: str | None = None,
+        cancel: threading.Event | None = None,
+    ):
+        super().__init__(configuration)
+        self.plot_data = False
+        self.pipeline: Pipeline | None = None
+        self._skip_video_rotation = skip_video_rotation
+        self._apply_nlms = apply_nlms
+        self._emotion_model = emotion_model
+        self._cancel = cancel
+
+        if configuration is None:
+            self.configureAsDefault()
+            self.configured = True
+        else:
+            printError("[NucleusKitProcessingToolkit] ERROR: Invalid configuration")
+
+    @property
+    def processingSteps(self) -> list[str]:
+        """Names of the steps run, in order."""
+        return [step.name for step in self.pipeline.steps] if self.pipeline else []
+
+    def processSession(self, jobDetails):
+        if not self.configured:
+            printError("[NucleusKitProcessingToolkit] ERROR: Pipeline not configured")
+            return False
+
+        cachepath = jobDetails.path
+        session = Session.open(cachepath)
+
+        pov = resolve_pov_settings(getattr(jobDetails, "pov_config_json", None))
+        screen_id = jobDetails.screenID or (pov.screen_id if pov else None)
+
+        printInfo(f"[pipeline] Starting {self.pipeName}")
+        printInfo("[pipeline] Converting POV movie")
+        try:
+            if screen_id and pov and pov.data_root and pov.ffmpeg_bin_dir:
+                convertPOVMovieClip(screen_id, pov.data_root, pov.ffmpeg_bin_dir)
+            elif screen_id:
+                printWarning(
+                    "[NucleusKitProcessingToolkit] POV screen id set but data_root/ffmpeg not configured; "
+                    "skipping conversion"
+                )
+        except Exception as e:
+            printWarning(f"[NucleusKitProcessingToolkit] WARNING: Converting movie failed: {e}")
+
+        result = self.pipeline.run(session)
+        if self._cancel is not None and self._cancel.is_set():
+            printWarning("[pipeline] Run cancelled: the remaining steps were skipped")
+        for step in result.steps:
+            if step.status == "error":
+                printError(f"[NucleusKitProcessingToolkit] ERROR in {step.name}: {step.error}")
+            else:
+                printInfo(f"[pipeline] {step.name}: {step.status} ({step.seconds:.1f} s)")
+
+        printInfo("[pipeline] Session processing finished")
+        return True
+
+    def configureAsDefault(self):
+        self.pipeName = "HermesDevPipe"
+        self.pipeline = build_pipeline(
+            skip_video_rotation=self._skip_video_rotation,
+            apply_nlms=self._apply_nlms,
+            emotion_model=self._emotion_model,
+            cancel=self._cancel,
+        )

nucleuskit_toolkit/position/__init__.py

@@ -0,0 +1,5 @@
+"""Outdoor position processing (GPS)."""
+
+from nucleuskit_toolkit.position.gps_processor import processGPS
+
+__all__ = ["processGPS"]

nucleuskit_toolkit/position/gps_processor.py

@@ -0,0 +1,91 @@
+"""
+GPS Processor
+
+Processes GPS tracking data from sessions.
+
+Author(s):
+    Fred Simard (fs@re-ak.com), ©RE-AK Technologies Inc.
+    Winter 2026
+"""
+
+import os
+
+import numpy as np
+import pandas as pd
+from reak_core.io.csvfiles import has_text_header
+
+from nucleuskit_toolkit.logging_utils import printInfo, printWarning
+
+GPS_HDR = "[GPSProcessor] "
+
+_GPS_FILENAMES = ["gps.csv", "gps.tmp"]
+_GRID_STEP_S   = 0.5   # shared 2 Hz / 0.5 s pipeline timebase
+
+
+def processGPS(recpath):
+    """
+    Process GPS tracking data.
+
+    Loads the raw GPS CSV (no header: unix_timestamp_s, latitude, longitude),
+    normalises timestamps to session-relative seconds, resamples to the shared
+    2 Hz / 0.5 s grid via linear interpolation, and writes results/gpsDf.csv.
+
+    Args:
+        recpath: Path to the recording directory
+    """
+    printInfo(f"{GPS_HDR}Processing GPS data")
+
+    out_path = os.path.join(recpath, "results", "gpsDf.csv")
+    if os.path.exists(out_path):
+        printInfo(f"{GPS_HDR}GPS already processed, using cached results")
+        return
+
+    gps_file = None
+    for filename in _GPS_FILENAMES:
+        candidate = os.path.join(recpath, "rawData", filename)
+        if os.path.isfile(candidate):
+            gps_file = candidate
+            break
+
+    if gps_file is None:
+        printWarning(f"{GPS_HDR}No GPS file found, tested: {_GPS_FILENAMES}")
+        return
+
+    printInfo(f"{GPS_HDR}Loading {os.path.basename(gps_file)}")
+    try:
+        skiprows = 1 if has_text_header(gps_file) else 0
+        raw = pd.read_csv(
+            gps_file,
+            header=None,
+            names=["unix_ts", "Latitude", "Longitude"],
+            skiprows=skiprows,
+        )
+    except Exception as exc:
+        printWarning(f"{GPS_HDR}Failed to read GPS file: {exc}")
+        return
+
+    if len(raw) < 2:
+        printWarning(f"{GPS_HDR}GPS file contains fewer than 2 rows — skipping")
+        return
+
+    t_raw = raw["unix_ts"].to_numpy(dtype=float)
+    t_rel = t_raw - t_raw[0]
+    lat   = raw["Latitude"].to_numpy(dtype=float)
+    lon   = raw["Longitude"].to_numpy(dtype=float)
+
+    grid = np.arange(0.0, t_rel[-1] + _GRID_STEP_S, _GRID_STEP_S)
+
+    lat_grid = np.interp(grid, t_rel, lat, left=np.nan, right=np.nan)
+    lon_grid = np.interp(grid, t_rel, lon, left=np.nan, right=np.nan)
+
+    result = pd.DataFrame({
+        "Timestamp": grid,
+        "Latitude":  lat_grid,
+        "Longitude": lon_grid,
+    })
+
+    result.to_csv(out_path, index=False, float_format="%.7f", na_rep="NULL")
+    printInfo(
+        f"{GPS_HDR}GPS processing completed — "
+        f"{len(result)} rows @ 2 Hz written to {out_path}"
+    )

nucleuskit_toolkit/session_job.py

@@ -0,0 +1,28 @@
+"""
+Minimal session job DTO for local Nucleus-Kit pipeline processing (no REST).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SessionJob:
+    sessionID: Optional[str] = None
+    path: Optional[str] = None
+    jobType: str = "PROCESS"
+    pipeline: str = "hermes"
+    screenID: Optional[str] = None
+    pov_config_json: Optional[str] = None  # optional path merged after cwd default JSON
+
+
+def session_job_from_folder(folder: str, pov_config_json: Optional[str] = None) -> SessionJob:
+    folder = os.path.abspath(os.path.expanduser(folder))
+    norm = os.path.normpath(folder)
+    session_id = os.path.basename(norm)
+    sep = os.path.sep
+    path = norm if norm.endswith(sep) else norm + sep
+    return SessionJob(sessionID=session_id, path=path, pov_config_json=pov_config_json)

nucleuskit_toolkit/shimmer/__init__.py

@@ -0,0 +1,5 @@
+"""Shimmer wristband physiological processing (PPG, EDA)."""
+
+from nucleuskit_toolkit.shimmer.realtime.proxy import ShimmerSerialProxy
+
+__all__ = ["ShimmerSerialProxy"]

nucleuskit_toolkit/shimmer/constants.py

@@ -0,0 +1,32 @@
+"""Constants for the Shimmer3 wristband hardware."""
+
+
+class ShimmerConstants(object):
+
+    # tmp signal definition
+    SAMPLING_RATE = 51.2
+    GSR_INDEX = 4
+    NYQUIST_FREQ = SAMPLING_RATE / 2
+
+    # ppg conditioning
+    FILTER_ORDER = 4  # applied twice
+    AVG_FILTER_FC = 0.5
+
+    # HRV/BPM
+    THRESHOLD = 20
+    HRV_WINDOW_WIDTH = 11  # used for smoothing
+    BPM_WINDOW_WIDTH = 11  # used for smoothing used to be 101
+    MIN_BPM = 40
+    MAX_BPM = 150
+
+    # gsr conditioning
+    GSR_BANDWIDTH = [0.01, 5]
+    TONIC_FC = 5.0
+    GSR_THRESHOLD_TIGHT = 10
+
+    # arousal conditioning
+    FILTER_ORDER = 4
+    FIRST_STAGE_BANDWIDTH = [0.03, 3]
+    SMOOTHING_CUTOFF = 0.03
+
+    THRESHOLD = 2