auto-trainer-core 2.0.1.dev353__py3-none-any.whl

autotrainer/core/analysis/auto_tunnel_fan_monitor.py

@@ -0,0 +1,92 @@
+
+import dataclasses
+import math
+from typing import Optional, Tuple, List
+
+from autotrainer.core import get_perf_now, Offset3DTuple
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.multiproc import no_op_timer, make_daemon_timer
+from autotrainer.core.analysis.detector import BaseDetector
+from autotrainer.core.analysis.pellet_position_monitor import PelletMisplacedDetector
+
+
+logger = get_verbose_logger(__name__)
+
+
+_offset_nans = Offset3DTuple(math.nan, math.nan, math.nan)
+
+
+@dataclasses.dataclass
+class AutoTunnelSweepConfiguration:
+    enabled: bool = False
+    misplaced_trigger_delay: float = 5
+    tunnel_fan_on_duration: float = 5
+    rate_limit_delay: float = 60
+
+
+class AutoTunnelSweepMonitor(BaseDetector):
+
+    def __init__(
+        self, config: AutoTunnelSweepConfiguration,
+        *,
+        pellet_misplaced_detector: PelletMisplacedDetector,
+    ):
+        super().__init__()
+        self._config = config
+        self._misplaced_detector = pellet_misplaced_detector
+        self._timer_end_engaged = no_op_timer
+        pellet_misplaced_detector.property_changed += self._on_pellet_misplaced_property_changed
+
+    @property
+    def config(self) -> AutoTunnelSweepConfiguration:
+        return self._config
+
+    @config.setter
+    def config(self, value: AutoTunnelSweepConfiguration):
+        self._config = value
+
+    def _stop(self):
+        self._timer_end_engaged.cancel()
+        self.is_engaged = False  # force disengaged on stop
+
+    def _end_engaged(self):
+        self.is_engaged = False
+        self._misplaced_detector.restart()
+
+    def _check_state(self) -> Optional[float]:
+        cfg = self._config
+        if not self._running or not cfg.enabled:
+            return None
+        if not self._misplaced_detector.is_engaged:
+            logger.debug("misplaced not engaged")
+            self.is_engaged = False
+            return None
+        p_now = get_perf_now()
+        rate_remain = cfg.rate_limit_delay + cfg.misplaced_trigger_delay - (p_now - self._disengaged_perf_c)
+        if rate_remain > 0:
+            logger.verbose("delaying tunnel sweep for %.1fs due to rate limit", rate_remain)
+            return rate_remain
+        self.is_engaged = True
+        prev_timer_disengage = self._timer_end_engaged
+        if prev_timer_disengage is no_op_timer or prev_timer_disengage.finished.is_set():
+            timer = self._timer_end_engaged = make_daemon_timer(cfg.tunnel_fan_on_duration, self._end_engaged)
+            timer.start()
+        return None
+
+    def _on_pellet_misplaced_property_changed(self, name, value, _):
+        if not self._running or not self._config.enabled:
+            logger.verbose("auto tunnel sweep not enabled")
+            return
+        if name == BaseDetector.IS_ENGAGED:
+            if value:
+                delay = self._config.misplaced_trigger_delay
+                if delay > 0:
+                    with self._lock:
+                        timer = self._cur_timer
+                        if not timer.finished.is_set():
+                            self._logger.debug("timer already in progress")
+                        else:
+                            self._make_new_timer(delay)
+                    return
+            # all other cases (pellet misplaced not engaged or trigger delay <= 0):
+            self.check_state()

autotrainer/core/analysis/detector.py

@@ -0,0 +1,179 @@
+import math
+import queue
+import threading
+import time
+from typing import Dict, Tuple, Optional, Union
+
+from autotrainer.api import ApiEventKind
+from autotrainer.core import ObservableObject, get_perf_now
+from autotrainer.core.event import post_api_detector_event_content
+from autotrainer.core.event.event_manager import EventManager
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.multiproc import no_op_timer, make_daemon_timer
+
+
+logger = get_verbose_logger(__name__)
+
+
+class BaseDetector(ObservableObject):
+
+    IS_ENGAGED = "is_engaged"
+
+    use_daemon: bool = False
+    default_timer_delay: Optional[float] = None
+
+    def __init__(self):
+        super().__init__()
+        self._running = False
+        self._p_started = -math.inf
+        self._is_engaged = False
+        self._engaged_perf_c = -math.inf
+        self._disengaged_perf_c = -math.inf
+        self._cur_timer = no_op_timer
+        self._thread_queue: Optional[Tuple[threading.Thread, queue.Queue]] = None
+        self._lock = threading.RLock()
+        self._logger = get_verbose_logger(self.__class__.__module__)
+        self._event_manager = EventManager.default()
+
+    def post_detector_event(self, detector_id: int, active: bool, enabled: Optional[bool] = None):
+        if enabled is None:
+            enabled = self._running
+        post_api_detector_event_content(self._event_manager, detector_id, active, enabled)
+
+    @property
+    def running(self):
+        return self._running
+
+    @property
+    def is_engaged(self):
+        return self._is_engaged
+
+    @is_engaged.setter
+    def is_engaged(self, value):
+        prev, self._is_engaged = self._is_engaged, value
+        if prev == value:
+            return
+        perf_now = get_perf_now()
+        if value:
+            self._engaged_perf_c = perf_now
+        else:
+            self._disengaged_perf_c = perf_now
+        self._logger.notice("is_engaged -> %s (age previous = %.1f)",
+                            value, perf_now - (self._disengaged_perf_c if value else self._engaged_perf_c))
+        self._on_property_changed(self.IS_ENGAGED, value, prev)
+
+    @property
+    def engaged_age(self):
+        return (get_perf_now() if self._is_engaged else self._disengaged_perf_c) - self._engaged_perf_c
+
+    @property
+    def disengaged_age(self):
+        return (get_perf_now() if not self._is_engaged else self._engaged_perf_c) - self._disengaged_perf_c
+
+    def _make_new_timer(self, delay: float):
+        self._cur_timer.cancel()  # safer
+        timer = self._cur_timer = make_daemon_timer(delay, self.check_state)
+        timer.start()
+        self._logger.verbose("created timer to check_state within %.1fs", delay)
+
+    def _check_state(self) -> Optional[float]:
+        raise NotImplementedError
+
+    def check_state_if_not_detector_thread(self):
+        th_q = self._thread_queue
+        if th_q is None or threading.current_thread() != th_q[0]:
+            self.check_state()
+
+    def check_state(self):
+        with self._lock:
+            if not self._running:
+                return None
+            next_delay = self._check_state()
+            if next_delay is None:
+                next_delay = self.default_timer_delay
+            if next_delay is not None and not self.use_daemon:
+                # "recurrent/timed" detector
+                self._make_new_timer(next_delay)
+            else:
+                # daemon detector or detector that will resume by explicit refresh
+                self._cur_timer.cancel()
+                self._cur_timer = no_op_timer
+        return next_delay
+
+    def _start(self):
+        """Allow any subclass to customize its start procedure. super() should be called."""
+
+    def start(self):
+        with self._lock:
+            if self._running:
+                self._logger.debug("requested start but already running")
+                return
+            self._logger.verbose("%s: starting monitor", self.__class__.__name__)
+            self._running = True
+            self.is_engaged = False  # force reset "engaged" to False
+            self._p_started = get_perf_now()
+            self._start()
+            if self.use_daemon:
+                cmd_queue = queue.Queue()
+                thread = threading.Thread(name=self.__class__.__name__, target=self._daemon_run, daemon=True,
+                                          args=(cmd_queue,))
+                thread.start()
+                self._thread_queue = thread, cmd_queue
+            else:
+                self.check_state()
+
+    def _daemon_run(self, cmd_queue):
+        self._logger.info("%s running", self.__class__.__name__)
+        while True:
+            delay = self.check_state()  # always check immediately
+            if delay is None:
+                delay = self.default_timer_delay
+                if delay is None:
+                    delay = 1
+            # Now limit max delay to 60 seconds,
+            # so that any change in config will be handled at most every 60 seconds.
+            # Some detector, like global animal presence, could use very long delay between check,
+            # so this ensures that if its setting relating to the delay is changed, then the new one will be handled,
+            # ~relatively quickly.
+            # Otherwise, we would need to restart any of them that has its config updated.
+            delay = min(60., delay)
+            try:
+                r = cmd_queue.get(timeout=delay)
+            except queue.Empty:
+                pass
+            else:
+                cmd_queue.task_done()
+                # we only support None exit sentinel
+                assert r is None
+                break
+        self._logger.verbose("%s: exiting main loop", self.__class__.__name__)
+
+    def _stop(self):
+        pass
+
+    def stop(self):
+        with self._lock:
+            self._cur_timer.cancel()
+            if not self._running:
+                return
+            self._logger.verbose("%s: stopping monitor", self.__class__.__name__)
+            self._running = False
+            self._stop()
+        # don't try join check thread with the lock acquired, given that can deadlock otherwise.
+        thread_queue = self._thread_queue
+        if thread_queue is not None:
+            thread, q = self._thread_queue
+            # assert isinstance(q, queue.Queue)
+            if thread.is_alive():
+                q.put(None)
+            self._logger.debug("Joining check thread %s", thread)
+            thread.join(3)
+            self._logger.verbose("joined check thread %s", thread)
+            if thread.is_alive():
+                self._logger.warning("check thread still alive, but continuing anyway")
+            self._thread_queue = None
+
+    def restart(self):
+        self._logger.notice("Restarting %s", self.__class__.__name__)
+        self.stop()
+        self.start()

autotrainer/core/analysis/external_doors_monitor.py

@@ -0,0 +1,124 @@
+import dataclasses
+import math
+from typing import Dict, Tuple, Optional, NamedTuple
+
+from autotrainer.api import ApiDetectorKind
+
+from autotrainer.core import get_perf_now
+from autotrainer.core.analysis.detector import BaseDetector
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.configuration.external_doors_monitor_configuration import ExternalDoorsMonitorConfig
+from autotrainer.core.message.system_status_message import SystemStatusMessageKind
+
+logger = get_verbose_logger(__name__)
+
+class DoorState(NamedTuple):
+    open: Optional[bool]
+    perf_c: float
+
+
+FrontDoor = SystemStatusMessageKind.FRONT_DOOR
+SlidingDoor = SystemStatusMessageKind.DRAWER_DOOR
+
+
+ActiveDoors = {
+    FrontDoor,
+    SlidingDoor,
+}
+
+
+_door_2_api_detector_kind = {
+    FrontDoor: ApiDetectorKind.frontDoor,
+    SlidingDoor: ApiDetectorKind.slidingDoor,
+}
+
+
+@dataclasses.dataclass
+class DoorsState:
+    front: DoorState
+    sliding: DoorState
+
+    def get_door(self, kind: SystemStatusMessageKind) -> DoorState:
+        if kind == FrontDoor:
+            return self.front
+        elif kind == SlidingDoor:
+            return self.sliding
+        raise ValueError(f"Invalid door kind: {kind}")
+
+    def set_door(self, kind: SystemStatusMessageKind, state: DoorState):
+        if kind == FrontDoor:
+            self.front = state
+        elif kind == SlidingDoor:
+            self.sliding = state
+        else:
+            raise ValueError(f"Invalid door kind: {kind}")
+
+
+def _make_doors_state():
+    return DoorsState(
+        front=DoorState(None, -math.inf),
+        sliding=DoorState(None, -math.inf),
+    )
+
+
+class ExternalDoorsMonitor(BaseDetector):
+
+    CONFIG = "config"
+
+    def __init__(self, config: ExternalDoorsMonitorConfig):
+        super().__init__()
+        self._config = config
+        self._doors_state = _make_doors_state()
+
+    @property
+    def config(self) -> ExternalDoorsMonitorConfig:
+        return self._config
+
+    @config.setter
+    def config(self, value: ExternalDoorsMonitorConfig):
+        prev, self._config = self._config, value
+        logger.debug("external_doors=%s", value)
+        # self._on_property_changed(self.CONFIG, value, prev)
+        # not needed atm.
+
+    @property
+    def doors_state(self) -> DoorsState:
+        return self._doors_state
+
+    def _start(self):
+        super()._start()
+        self._doors_state = _make_doors_state()
+
+    def _check_state(self):
+        doors_state = self._doors_state
+        perf_now = get_perf_now()
+        cfg = self._config
+        min_delay = math.inf
+        new_engaged = False
+        for door_kind in ActiveDoors:
+            door_open, door_last_perf_c = doors_state.get_door(door_kind)
+            if door_open:
+                r = cfg.trigger_open_delay - (perf_now - door_last_perf_c)
+                if r < 0:
+                    new_engaged = True
+                elif r < min_delay:
+                    min_delay = r
+        self.is_engaged = new_engaged
+        if not new_engaged and not math.isinf(min_delay):
+            logger.debug("timer for next check state delay=%.1f", min_delay)
+            return min_delay
+        return None
+
+    def update_door_state(self, door_kind, is_open):
+        if __debug__:
+            if door_kind not in ActiveDoors:
+                logger.warning("Got unexpected door message: %s", door_kind)
+                return
+        state = self._doors_state.get_door(door_kind)
+        if is_open == state.open:
+            return
+        logger.notice("%s: is_open: %s -> %s", door_kind, state.open, is_open)
+        new_perf_c = get_perf_now() if is_open else state.perf_c
+        self._doors_state.set_door(door_kind, DoorState(is_open, new_perf_c))
+        self.check_state()
+        self.post_detector_event(_door_2_api_detector_kind[door_kind], is_open)

autotrainer/core/analysis/global_animal_presence_monitor.py

@@ -0,0 +1,69 @@
+import os
+import time
+import math
+import threading
+
+from autotrainer.core import ObservableObject, get_perf_now
+from autotrainer.core.analysis.detector import BaseDetector
+from autotrainer.core.configuration.animal_presence_configuration import GlobalAnimalPresenceConfig
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.video_detection import PresenceDetectionAttrs
+from autotrainer.core.analysis.load_cell_monitor import LoadCellMonitor
+
+logger = get_verbose_logger(__name__)
+
+
+class GlobalAnimalPresenceMonitor(BaseDetector):
+
+    use_daemon = True
+    feature_enabled = True
+
+    def __init__(
+        self, *,
+        config: GlobalAnimalPresenceConfig,
+        load_cell_monitor: LoadCellMonitor,
+        topcam_presence: PresenceDetectionAttrs,
+    ):
+        super().__init__()
+        self._config = config
+        self._load_cell_monitor = load_cell_monitor
+        self._topcam_presence = topcam_presence
+
+    @property
+    def config(self):
+        return self._config
+
+    @config.setter
+    def config(self, value):
+        self._config = value
+
+    def _check_state(self):
+        perf_now = get_perf_now()
+        cfg = self._config
+        load_cell_mon = self._load_cell_monitor.context
+        topcam_presence = self._topcam_presence
+        if topcam_presence is None:
+            logger.verbose("topcam presence is not configured")
+            return None
+        top_cam_pres_age = perf_now - topcam_presence.last_presence_start_perf_c
+        delay_seconds = cfg.presence_missing_delay_hours * 3600
+        timer_delay = 1
+        diff_started = perf_now - self._p_started
+        if diff_started < delay_seconds or load_cell_mon.is_engaged:
+            new_engaged = False
+            if diff_started < delay_seconds:
+                timer_delay = delay_seconds - diff_started
+            top_cam_miss = math.nan
+            load_cell_miss = math.nan
+        else:
+            top_cam_miss = delay_seconds - top_cam_pres_age
+            load_cell_miss = delay_seconds - load_cell_mon.disengaged_age
+            if top_cam_miss <= 0 and load_cell_miss <= 0:
+                new_engaged = True
+            else:
+                new_engaged = False
+                timer_delay = max(top_cam_miss, load_cell_miss)
+        logger.debug("engaged=%s top_cam_miss=%.1f load_cell_miss=%.1f ; new_delay=%.1f",
+                     new_engaged, top_cam_miss, load_cell_miss, timer_delay)
+        self.is_engaged = new_engaged
+        return timer_delay

autotrainer/core/analysis/head_fix_measurement.py

@@ -0,0 +1,15 @@
+import dataclasses
+from typing import List
+
+
+@dataclasses.dataclass
+class HeadFixMeasurement:
+    when: float = 0   # realtime timestamp, i.e: "UNIX" timestamp, in float seconds as normally.
+    timestamp: int = 0  # perf counter timestamp, in integer nanoseconds
+    weight: float = 0
+    switch: bool = False
+    pressure: float = 0
+    temperature: float = 0
+    humidity: float = 0
+    spectrum: List[float] = dataclasses.field(default_factory=list)
+    head_contact: bool = False

autotrainer/core/analysis/headbar_pressure_monitor.py

@@ -0,0 +1,158 @@
+from dataclasses import dataclass
+from math import floor
+from datetime import datetime
+from typing import List
+from typing_extensions import Self
+
+import numpy
+
+from ..observable_object import ObservableObject
+from ..event import EventManager, ApiEventKind, post_api_event_content
+
+
+@dataclass
+class HeadbarPressureConfiguration:
+    threshold: float = 20
+    duration: float = 0.5
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        return cls(
+            threshold=content.get("threshold", 30),
+            duration=content.get("duration", 0.25)
+        )
+
+
+class HeadbarPressureMonitor(ObservableObject):
+    """
+    Monitor the headbar pressure data stream and perform any required analysis.  The current implementation is used to
+    determine if the headbar is considered sufficiently "engaged" or not.  At this time, this is specifically used
+    downstream to allow for the tunnel auto-clamp behavior, when enabled.
+    """
+
+    IS_ENGAGED_PROPERTY = "is_engaged"
+
+    def __init__(self):
+        super().__init__()
+
+        self._is_engaged = False
+        self._force_engaged = False
+
+        self._sample_rate = 100
+
+        self._load_cell_engaged_threshold: float = 30
+        self._duration: float = 0.25
+
+        self._values = numpy.empty((1, 0))
+
+        self._buffer_length: float = 1.0
+        self._retain_count: int = 1
+
+        self._window_count: int = 3
+
+        self._first_third = 1
+        self._last_third = 1
+
+        self._rebuild_buffers()
+
+    @property
+    def sample_rate(self) -> int:
+        return self._sample_rate
+
+    @sample_rate.setter
+    def sample_rate(self, value: int) -> None:
+        # Odd number sample rates lead to mismatched indexing.  Can just handle here once by effectively doing the
+        # round.
+        self._sample_rate = value + (value % 2)
+        self._rebuild_buffers()
+
+    @property
+    def load_cell_engaged_threshold(self) -> float:
+        return self._load_cell_engaged_threshold
+
+    @load_cell_engaged_threshold.setter
+    def load_cell_engaged_threshold(self, value: float) -> None:
+        prev, self._load_cell_engaged_threshold = self._load_cell_engaged_threshold, value
+        self._on_property_changed("threshold", value, prev)
+
+    @property
+    def duration(self) -> float:
+        return self._duration
+
+    @duration.setter
+    def duration(self, value: float) -> None:
+        prev, self._duration = self._duration, value
+        self._on_property_changed("duration", value, prev)
+        self._rebuild_buffers()
+
+    @property
+    def is_engaged(self) -> bool:
+        return self._is_engaged or self._force_engaged
+
+    @is_engaged.setter
+    def is_engaged(self, value):
+        value = value or self._force_engaged
+        old_value, self._is_engaged = self._is_engaged, value
+        if value != old_value:
+            self.property_changed(self.IS_ENGAGED_PROPERTY, value, old_value)
+
+    def load_configuration(self, configuration: HeadbarPressureConfiguration):
+        self.load_cell_engaged_threshold = configuration.threshold
+        self.duration = configuration.duration
+
+    def save_configuration(self) -> HeadbarPressureConfiguration:
+        return HeadbarPressureConfiguration(threshold=self._load_cell_engaged_threshold, duration=self._duration)
+
+    def update(self, values: List[float], when: float = 0.0, index: int = 0) -> bool:
+        self._values = numpy.append(self._values, values)
+        self._values = self._values[-self._retain_count:]
+
+        if len(self._values) < self._retain_count:
+            return False
+
+        is_engaged = False
+
+        # Values are appended and dropped in batches.  Need to evaluate over the full window size as more than just one
+        # sample will be gone the next evaluation.  We could just evaluate oldest last window_count samples, but there
+        # would be greater latency in the response.  We are also evaluating the same window of samples multiple times
+        # depending on the measurement batch size, but this is simple calculation and not worth optimizing out at the
+        # moment.
+        for idx in range(self._window_count * 3):
+            new_start = idx + self._last_third
+            new_end = idx + self._window_count
+            old_start = idx
+            old_end = idx + self._first_third
+
+            if numpy.all(self._values[old_start:old_end] <= (
+                    self._values[new_start:new_end] - self._load_cell_engaged_threshold)):
+                is_engaged = True
+                break
+
+        is_engaged |= self._force_engaged
+        prev_engaged = self._is_engaged
+        self.is_engaged = is_engaged
+        if is_engaged != prev_engaged:
+            EventManager.default().post_event_content(
+                ApiEventKind.headbarPressureEngagedChanged,
+                data=dict(is_engaged=is_engaged),
+                when=datetime.fromtimestamp(when), index=index)
+        return is_engaged
+
+    def _rebuild_buffers(self):
+        # Measurements are received in batches.  Depending on that batch size, it may not result in a continuous, moving
+        # evaluation with data processed in batches.  Store a larger buffer than the window so we can apply the window
+        # over each starting and ending element.
+        self._buffer_length = self._duration * 4
+        self._retain_count = round(self._sample_rate * self._buffer_length)
+
+        self._window_count = round(self._sample_rate * self._duration)
+
+        self._first_third = floor(self._window_count / 3)
+        self._last_third = self._window_count - self._first_third
+
+    def force_engaged(self, engaged: bool) -> None:
+        """
+        Primarily used for testing.  This will force the headbar pressure monitor to be engaged or not engaged.
+        """
+        self._force_engaged = engaged
+        self.is_engaged = engaged