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

autotrainer/core/analysis/pellet_position_monitor.py

@@ -0,0 +1,108 @@
+import dataclasses
+import math
+from typing import Optional, Tuple, List
+
+from autotrainer.api import ApiDetectorKind
+
+from autotrainer.core.diamond_triangle_config import DiamondTriangleOffsetConfig
+from autotrainer.core import get_perf_now, Offset3DTuple, calculate_std_dev_manual
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.analysis.detector import BaseDetector
+
+
+logger = get_verbose_logger(__name__)
+
+
+_offset_nans = Offset3DTuple(math.nan, math.nan, math.nan)
+
+
+@dataclasses.dataclass
+class PelletMisplacedDetectorConfiguration:
+    enabled: bool = True
+    aggregate_duration: float = 1  # how long ago to check/look at results
+    # previous results older than that are discarded before each check/update.
+
+    use_dcs_y_low_limit: bool = True
+    dcs_y_low_limit: float = 0  # lower than this -> error condition
+
+
+class PelletMisplacedDetector(BaseDetector):
+
+    use_daemon = True
+    default_timer_delay = 0.25  # default delay between each check of the possible condition(s)
+    # NB: should be at least 2 times smaller than aggregate_duration, otherwise given we expire too old data
+    # before checking the condition, we could always have the data set empty.
+
+    def __init__(self, config: PelletMisplacedDetectorConfiguration):
+        super().__init__()
+        self._config = config
+        self._prev_data: List[Tuple[float, Offset3DTuple]] = []
+        self._dcs_config: Optional[DiamondTriangleOffsetConfig] = None
+
+    @BaseDetector.is_engaged.setter
+    def is_engaged(self, value):
+        prev = self._is_engaged
+        BaseDetector.is_engaged.fset(self, value)
+        if prev != value:
+            self.post_detector_event(ApiDetectorKind.pelletMisplaced, value)
+
+    @property
+    def dcs_config(self) -> Optional[DiamondTriangleOffsetConfig]:
+        return self._dcs_config
+
+    @dcs_config.setter
+    def dcs_config(self, value: Optional[DiamondTriangleOffsetConfig]):
+        logger.verbose("got new DCS config: %s", value)
+        self._dcs_config = value
+
+    def _check_state(self) -> Optional[float]:
+        cfg = self._config
+        prev_data = self._prev_data
+        engaged = False
+        p_now = get_perf_now()
+        if p_now - self._p_started < cfg.aggregate_duration:
+            # wait at least 1 window before consider
+            return None
+        idx = 0
+        while idx < len(prev_data):
+            perf_c = prev_data[idx][0]
+            if p_now - perf_c <= cfg.aggregate_duration:
+                break
+            idx += 1
+        del prev_data[:idx]
+        if cfg.use_dcs_y_low_limit:
+            # logger.debug("Checking %s", prev_positions)
+            if len(prev_data) > 0 and all(pos.y < cfg.dcs_y_low_limit for _, pos in prev_data):
+                engaged = True
+        if not self._is_engaged and engaged:
+            if len(prev_data) < 2:
+                if len(prev_data) == 0:
+                    avg_pos, stdev_pos = _offset_nans, _offset_nans
+                else:
+                    avg_pos, stdev_pos = prev_data[-1][1], Offset3DTuple(0, 0, 0)
+            else:
+                avg_pos, stdev_pos = calculate_std_dev_manual([d[1] for d in prev_data])
+            logger.notice("New engaged, dcs_pos=%s stdev=%s ; all=%s",
+                          avg_pos.humanize(), stdev_pos.humanize(), prev_data)
+        self.is_engaged = engaged
+        return None
+
+    def update(self, pellet_inference_3d: Optional[Offset3DTuple]):
+        dcs_cfg = self._dcs_config
+        if dcs_cfg is None or not dcs_cfg.fully_valid:  # refuse to guess with not fully valid
+            return
+        if pellet_inference_3d is None:
+            # no need put None 3d loc, the check is done by timer
+            return
+        rel_to_diamond = dcs_cfg.diamond_coord - pellet_inference_3d
+        dcs_pellet_3d = dcs_cfg.inference_to_diamond(rel_to_diamond)
+        if __debug__:
+            # should not be needed with fully_valid check above.
+            if any(map(math.isnan, dcs_pellet_3d)):
+                logger.debug("filtering bad pellet3d : %s", pellet_inference_3d)
+                return
+        p_now = get_perf_now()
+        with self._lock:
+            self._prev_data.append((p_now, dcs_pellet_3d))
+        # self.check_state()
+        # no: we don't need resolution/check frequency as high as the input source

autotrainer/core/analysis/sensor_analysis.py

@@ -0,0 +1,390 @@
+from __future__ import annotations
+
+import csv
+import os
+import math
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Tuple, IO
+
+import numpy
+
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core.project import ProjectInfo, ProjectInterval
+from autotrainer.core.perf_monitor import PerfMonitor
+from autotrainer.core.observable_object import ObservableObject
+from autotrainer.core.video_detection import PresenceDetectionAttrs
+
+from ..configuration.alarm_configuration import EmergencyAlarmConfiguration
+from ..configuration.animal_presence_configuration import GlobalAnimalPresenceConfig
+from ..configuration.external_doors_monitor_configuration import ExternalDoorsMonitorConfig
+from ..configuration.system_fault_config import SystemFaultConfig
+from ..configuration.system_maintenance_config import SystemMaintenanceConfig
+from ..message.audio_spectrum_message import AudioSpectrumMessage
+
+from .head_fix_measurement import HeadFixMeasurement
+from .audio_spectrum_monitor import AudioSpectrumThrashMonitor
+from .headbar_pressure_monitor import HeadbarPressureMonitor
+from .load_cell_monitor import LoadCellMonitor
+from .load_cell_tare_monitor import LoadCellTareMonitor
+from .alarm_monitor import EmergencyAlarmMonitor
+from .global_animal_presence_monitor import GlobalAnimalPresenceMonitor
+from .external_doors_monitor import ExternalDoorsMonitor
+from .pellet_position_monitor import PelletMisplacedDetector, PelletMisplacedDetectorConfiguration
+from .auto_tunnel_fan_monitor import AutoTunnelSweepMonitor, AutoTunnelSweepConfiguration
+from .system_maintenance_monitor import SystemMaintenanceMonitor
+from .system_fault_monitor import SystemFaultMonitor
+
+logger = get_verbose_logger(__name__)
+
+
+# TODO: Separate true analysis from data recording to file(s) for post-analysis.
+class SensorAnalysis(ObservableObject):
+
+    def __init__(self, *, topcam_presence: Optional[PresenceDetectionAttrs] = None):
+        super().__init__()
+
+        self._project_info: Optional[ProjectInfo] = None
+        self._interval = ProjectInterval.HOUR
+
+        self._filter_invalid_weight_started = False
+
+        # The "monitor" CSV file with the bulk of the sensor data.
+        self._record_file = None
+        self._current_record_interval = -1
+        self._had_write_error = False
+
+        # The audio spectrum file.
+        self._audio_record_file_writer: Optional[Tuple[IO[str], csv.DictWriter]] = None
+        self._current_audio_record_interval = -1
+        self._audio_had_write_error = False
+
+        self._is_load_cell_engaged = False
+        self._load_cell_monitor = LoadCellMonitor()
+
+        # The analog pressure sensor on the headbar.
+        self._is_headbar_pressure_engaged = False
+        self._headbar_pressure_monitor = HeadbarPressureMonitor()
+
+        # The digital i/o switch on the headbar.
+        self._is_headbar_switch_engaged = False
+
+        self._tare_detector = LoadCellTareMonitor()
+        self._tare_callback = None
+
+        self._audio_thrashing_monitor = AudioSpectrumThrashMonitor()
+
+        self._global_animal_presence_monitor = GlobalAnimalPresenceMonitor(
+            config=GlobalAnimalPresenceConfig(),
+            load_cell_monitor=self._load_cell_monitor,
+            topcam_presence=topcam_presence,
+        )
+
+        self._external_doors_monitor = ExternalDoorsMonitor(ExternalDoorsMonitorConfig())
+
+        self._pellet_misplaced_monitor = PelletMisplacedDetector(PelletMisplacedDetectorConfiguration())
+        self._auto_tunnel_sweep_monitor = AutoTunnelSweepMonitor(
+            AutoTunnelSweepConfiguration(),
+            pellet_misplaced_detector=self._pellet_misplaced_monitor,
+        )
+
+        self._system_maintenance_monitor = SystemMaintenanceMonitor(config=SystemMaintenanceConfig())
+        self._system_fault_monitor = SystemFaultMonitor(config=SystemFaultConfig())
+
+        self._alarm_monitor = EmergencyAlarmMonitor(
+            config=EmergencyAlarmConfiguration(),
+            load_cell_monitor=self._load_cell_monitor,
+            load_cell_tare_monitor=self._tare_detector,
+            audio_monitor=self._audio_thrashing_monitor,
+            external_doors_monitor=self._external_doors_monitor,
+            global_animal_presence_monitor=self._global_animal_presence_monitor,
+            system_maintenance_monitor=self._system_maintenance_monitor,
+            system_fault_monitor=self._system_fault_monitor,
+            topcam_presence_attrs=topcam_presence,
+        )
+
+        self._perf_monitor = PerfMonitor(name="<sensor-analysis>", units="mps", report_window=30)
+
+        self._detectors = [
+            self._alarm_monitor,  # put first
+            self._load_cell_monitor,
+            self._tare_detector,
+            self._audio_thrashing_monitor,
+            self._external_doors_monitor,
+            self._global_animal_presence_monitor,
+            self._pellet_misplaced_monitor,
+            self._auto_tunnel_sweep_monitor,
+            self._system_maintenance_monitor,
+            self._system_fault_monitor,
+        ]
+
+    @property
+    def detectors(self):
+        return self._detectors
+
+    def start(self):
+        for detector in self._detectors:
+            detector.start()
+
+    def stop(self):
+        for detector in self._detectors:
+            detector.stop()
+
+    def restart(self):
+        for detector in self._detectors:
+            detector.restart()
+
+    @property
+    def project_info(self) -> Optional[ProjectInfo]:
+        return self._project_info
+
+    @project_info.setter
+    def project_info(self, value: ProjectInfo) -> None:
+        self._project_info = value
+        self._update_record_file()
+        self._update_audio_file()
+        self._perf_monitor.reset()
+
+    @property
+    def interval(self) -> ProjectInterval:
+        return self._interval
+
+    @interval.setter
+    def interval(self, value: ProjectInterval) -> None:
+        self._interval = value
+
+    @property
+    def load_cell_monitor(self) -> LoadCellMonitor:
+        return self._load_cell_monitor
+
+    @property
+    def headbar_pressure_monitor(self) -> HeadbarPressureMonitor:
+        return self._headbar_pressure_monitor
+
+    @property
+    def load_cell_tare_monitor(self) -> LoadCellTareMonitor:
+        return self._tare_detector
+
+    @property
+    def audio_thrashing_monitor(self) -> AudioSpectrumThrashMonitor:
+        return self._audio_thrashing_monitor
+
+    @property
+    def emergency_alarm_monitor(self) -> EmergencyAlarmMonitor:
+        return self._alarm_monitor
+
+    @property
+    def global_animal_presence_monitor(self) -> GlobalAnimalPresenceMonitor:
+        return self._global_animal_presence_monitor
+
+    @property
+    def external_doors_monitor(self) -> ExternalDoorsMonitor:
+        return self._external_doors_monitor
+
+    @property
+    def pellet_misplaced_monitor(self) -> PelletMisplacedDetector:
+        return self._pellet_misplaced_monitor
+
+    @property
+    def auto_tunnel_sweep_monitor(self) -> AutoTunnelSweepMonitor:
+        return self._auto_tunnel_sweep_monitor
+
+    @property
+    def system_maintenance_monitor(self) -> SystemMaintenanceMonitor:
+        return self._system_maintenance_monitor
+
+    @property
+    def system_fault_monitor(self) -> SystemFaultMonitor:
+        return self._system_fault_monitor
+
+    @property
+    def is_headbar_switch_engaged(self):
+        # TODO - this signal is not currently encapsulated in an object for whatever analysis is needed like the others.
+        #  If it is used in the future, this should probably be refactored similar to the other sub-components.
+        return self._is_headbar_switch_engaged
+
+    def stream_start(self):
+        logger.verbose("SensorAnalysis: stream_start")
+        self._perf_monitor.reset()
+
+    def measurements_received(
+        self,
+        measurements: List[HeadFixMeasurement]
+    ) -> Tuple[List[float], List[bool], List[float], List[float], List[float]] :
+        """Return weight_vals, switch_vals, pressure_vals, temperature_vals, humidity_vals"""
+        # logger.spam("Received %s measures", len(measurements))
+        assert len(measurements) > 0
+
+        switch_vals: List[bool] = []
+        pressure_vals: List[float] = []
+        temperature_vals: List[float] = []
+        humidity_vals: List[float] = []
+
+        fh = self._record_file
+        if fh is not None:
+            now = datetime.now()
+            needs_update = now.hour != self._current_record_interval \
+                if self._interval == ProjectInterval.HOUR \
+                else now.minute != self._current_record_interval
+            if needs_update:
+                self._update_record_file()
+
+        load_cell_mon = self._load_cell_monitor
+
+        for m in measurements:
+            # NB: save all measurements to file
+            switch_vals.append(m.switch)
+            pressure_vals.append(m.pressure)
+            temperature_vals.append(m.temperature)
+            humidity_vals.append(m.humidity)
+
+            fh = self._record_file
+            if fh is not None:
+                try:
+                    fh.write(
+                        f"{m.when}, {m.timestamp}, {m.weight}, {int(m.switch)}, {m.pressure}, "
+                        f"{m.temperature}, {m.humidity}, {int(load_cell_mon.is_engaged)}\n")
+                except Exception as err:
+                    # This could be too much if something major is wrong.  Just output once per file rotation.
+                    if not self._had_write_error:
+                        logger.exception("<sensor-analysis>: unable to write: %s", err)
+                        self._had_write_error = True
+
+        # Load cell monitor. and Auto-Tare monitor
+        weight_vals: List[float] = []
+        filtered_weight_vals: List[float] = []
+        load_cell_cfg = load_cell_mon.config
+        for m in measurements:
+            value = m.weight
+            weight_vals.append(value)
+            if not (load_cell_cfg.weight_min_filter < value < load_cell_cfg.weight_max_filter):
+                filtered_weight_vals.append(math.nan)
+                if not self._filter_invalid_weight_started:
+                    self._filter_invalid_weight_started = True
+                    logger.verbose(
+                        "starting filter value outside accepted range: %s", value
+                    )
+                continue
+            if self._filter_invalid_weight_started:
+                logger.verbose("finished filter value outside accepted range: %s", value)
+                self._filter_invalid_weight_started = False
+            #
+            filtered_weight_vals.append(value)
+            self._load_cell_monitor.update(value, m.when, m.timestamp)
+        # (Auto-)tare detection.
+        self._tare_detector.update(filtered_weight_vals)
+
+        # Headbar analog pressure monitor.
+        first_measure = measurements[0]
+        self._headbar_pressure_monitor.update(pressure_vals, first_measure.when, first_measure.timestamp)
+
+        # Headbar digital switch - no real implementation at this time.
+        self._is_headbar_switch_engaged = numpy.mean(switch_vals) > 0.5
+
+        # Performance monitoring.
+        self._perf_monitor.add_cycles(len(measurements))
+
+        return weight_vals, switch_vals, pressure_vals, temperature_vals, humidity_vals
+
+    def audio_spectrum_received(self, spectrum: AudioSpectrumMessage):
+        if spectrum is None or not spectrum.magnitudes:
+            return
+
+        self._audio_thrashing_monitor.update(spectrum.magnitudes, spectrum.when, spectrum.index)
+
+        cur = self._audio_record_file_writer
+        if cur is not None:
+            file_timestamp = datetime.now()
+            needs_update = file_timestamp.hour != self._current_audio_record_interval \
+                if self._interval == ProjectInterval.HOUR \
+                else file_timestamp.minute != self._current_audio_record_interval
+            if needs_update:
+                self._update_audio_file()
+
+        # May or may not exist after the above.
+        cur = self._audio_record_file_writer
+        if cur is not None:
+            _, writer = cur
+            try:
+                r = dict(
+                    Time=spectrum.when,
+                    Index=spectrum.index,
+                    **{f"Bin {i}": val for i, val in enumerate(spectrum.magnitudes)},
+                )
+                writer.writerow(r)
+            except Exception as err:
+                # This could be too much if something major is wrong.  Just output once per file rotation.
+                if not self._audio_had_write_error:
+                    logger.exception("<sensor-analysis>: unable to write: %s", err)
+                    self._audio_had_write_error = True
+
+    def _update_record_file(self):
+        fh = self._record_file
+        if fh is not None:
+            self._record_file = None
+            try:
+                fh.flush()
+                fh.close()
+            except Exception as err:
+                logger.warning("Failure closing record file: %s", err)
+
+        if self._project_info is None:
+            return
+        interval_file_info = self._project_info.get_monitor_file(interval=self._interval, when=datetime.now())
+        if interval_file_info is None:
+            logger.error("<sensor-analysis>: unable to write to expected monitor file location")
+            return
+        dest_path = Path(interval_file_info.file)
+        try:
+            file_existed = dest_path.exists()
+            fh = dest_path.open("a")
+            if not file_existed:
+                fh.write("Time, Index, Weight, Switch, Pressure, Temperature, Humidity, LoadCellEngaged\n")
+                fh.flush()
+            self._current_record_interval = interval_file_info.current_interval
+            self._had_write_error = False
+            self._record_file = fh  # last
+        except Exception as err:
+            logger.error("<sensor-analysis>: unable to write to %s: %s",dest_path, err)
+        logger.info("<sensor-analysis>: saving to %s", dest_path)
+
+    def _update_audio_file(self) -> None:
+        cur = self._audio_record_file_writer
+        if cur is not None:
+            fh, writer = cur
+            try:
+                fh.flush()
+                fh.close()
+            except Exception as err:
+                logger.warning("audio record file close failed: %s", err)
+            self._audio_record_file_writer = None
+
+        if self._project_info is not None:
+            interval_file_info = self._project_info.get_audio_spectrum_file(
+                interval=self._interval, when=datetime.now())
+
+            if interval_file_info is None:
+                logger.error("<sensor-analysis>: unable to write to expected audio file location")
+                return None
+
+            try:
+                file_existed = os.path.exists(interval_file_info.file)
+
+                fh = open(interval_file_info.file, "a")
+                writer = csv.DictWriter(
+                    fh,
+                    fieldnames=('Time', 'Index', *(f'Bin {i}' for i in range(64))),
+                )
+
+                if not file_existed:
+                    writer.writeheader()
+
+                self._current_audio_record_interval = interval_file_info.current_interval
+                self._audio_record_file_writer = (fh, writer)
+                logger.info(f"<sensor-analysis>: saving audio spectrum to {interval_file_info.file}")
+                self._audio_had_write_error = False
+            except Exception as err:
+                logger.error("<sensor-analysis>: unable to write to %r: %s", interval_file_info.file, err)
+
+        return None

autotrainer/core/analysis/system_fault_monitor.py

@@ -0,0 +1,81 @@
+from typing import Optional, Set, List
+
+import psutil
+
+from .detector import BaseDetector
+from ..configuration.persistence_configuration import PersistenceConfiguration
+from ..configuration.system_fault_config import SystemFaultConfig
+from ..event import post_api_detector_event_content
+from ...api import ApiDetectorKind
+
+
+class SystemFaultMonitor(BaseDetector):
+
+    use_daemon = True  # for free disk space checks
+    default_timer_delay = 30  # secs ; check is very fast so can afford do it regularly
+
+    CONFIG = "config"
+
+    FREE_DISK_SPACE_ENGAGED = "free_disk_space_engaged"
+
+    def __init__(self, *, config: SystemFaultConfig):
+        super().__init__()
+        self._config = config
+        self._max_pellet_loaded_engaged = False
+        self._max_consecutive_failed_load_engaged = False
+        self._free_disk_space_engaged = False
+        self._engaged_reasons: Set[str] = set()
+        self._persistence_cfg = PersistenceConfiguration()
+
+    def set_persistence_config(self, config: PersistenceConfiguration):
+        self._persistence_cfg = config
+        self._logger.verbose("Received persistence config: %s", config)
+
+    @property
+    def config(self) -> SystemFaultConfig:
+        return self._config
+
+    @config.setter
+    def config(self, value: SystemFaultConfig):
+        prev, self._config = self._config, value
+        self._on_property_changed(self.CONFIG, value, prev)
+        self._logger.verbose("Received config: %s", value)
+
+    @property
+    def engaged_reasons(self) -> List[str]:
+        return list(self._engaged_reasons)
+
+    @property
+    def free_disk_space_engaged(self):
+        return self._free_disk_space_engaged
+
+    @free_disk_space_engaged.setter
+    def free_disk_space_engaged(self, value):
+        prev, self._free_disk_space_engaged = self._free_disk_space_engaged, value
+        self._on_property_changed(self.FREE_DISK_SPACE_ENGAGED, value, prev)
+        if value != prev:
+            self.check_state_if_not_detector_thread()
+            post_api_detector_event_content(self._event_manager, ApiDetectorKind.lowFreeDiskSpace,
+                                            value, self._config.use_free_disk_space)
+
+    def _check_free_disk_space(self):
+        cfg = self._config
+        usage = psutil.disk_usage(self._persistence_cfg.output_location)
+        # usage free is in bytes:
+        engaged = usage.free / 2 ** 20 < cfg.free_disk_space_min_limit_mb
+        self.free_disk_space_engaged = engaged
+
+    def _check_state(self) -> Optional[float]:
+        self._check_free_disk_space()
+        cfg = self._config
+        reasons = set()
+        for reason, use, engaged in (
+            (self.FREE_DISK_SPACE_ENGAGED, cfg.use_free_disk_space, self._free_disk_space_engaged),
+        ):
+            if use and engaged:
+                reasons.add(reason)
+        self._engaged_reasons = reasons
+        prev_engaged = self._is_engaged
+        self.is_engaged = len(reasons) > 0
+        if not prev_engaged and self._is_engaged:
+            self._logger.notice("Engaging with %s", reasons)

autotrainer/core/analysis/system_maintenance_monitor.py

@@ -0,0 +1,88 @@
+from typing import Optional, Set, List
+
+import psutil
+
+from .detector import BaseDetector
+from ..configuration.persistence_configuration import PersistenceConfiguration
+from ..configuration.system_maintenance_config import SystemMaintenanceConfig
+from ...api import ApiDetectorKind
+
+
+class SystemMaintenanceMonitor(BaseDetector):
+
+    CONFIG = "config"
+
+    MAX_PELLET_LOADED_ENGAGED = "max_pellet_loaded_engaged"
+    MAX_CONSECUTIVE_FAILED_LOAD_ENGAGED = "max_consecutive_failed_load_engaged"
+
+    def __init__(self, *, config: SystemMaintenanceConfig):
+        super().__init__()
+        self._config = config
+        self._max_pellet_loaded_engaged = False
+        self._max_consecutive_failed_load_engaged = False
+        self._free_disk_space_engaged = False
+        self._engaged_reasons: Set[str] = set()
+
+    @property
+    def config(self) -> SystemMaintenanceConfig:
+        return self._config
+
+    @config.setter
+    def config(self, value):
+        prev, self._config = self._config, value
+        self._on_property_changed(self.CONFIG, value, prev)
+        self._logger.verbose("Received config: %s", value)
+
+    @property
+    def engaged_reasons(self) -> List[str]:
+        return list(self._engaged_reasons)
+
+    @property
+    def max_pellet_loaded_engaged(self):
+        return self._max_pellet_loaded_engaged
+
+    @max_pellet_loaded_engaged.setter
+    def max_pellet_loaded_engaged(self, value):
+        prev, self._max_pellet_loaded_engaged = self._max_pellet_loaded_engaged, value
+        self._on_property_changed(self.MAX_PELLET_LOADED_ENGAGED, value, prev)
+        if value != prev:
+            self.post_detector_event(ApiDetectorKind.pelletRefillCountExceeded, value, self._config.use_max_pellet_loaded)
+            self.check_state_if_not_detector_thread()
+
+    @property
+    def max_consecutive_failed_load_engaged(self):
+        return self._max_consecutive_failed_load_engaged
+
+    @max_consecutive_failed_load_engaged.setter
+    def max_consecutive_failed_load_engaged(self, value):
+        prev, self._max_consecutive_failed_load_engaged = self._max_consecutive_failed_load_engaged, value
+        self._on_property_changed(self.MAX_CONSECUTIVE_FAILED_LOAD_ENGAGED, value, prev)
+        if value != prev:
+            self.post_detector_event(ApiDetectorKind.consectivePelletLoadFailureExceeded, value,
+                                     self._config.use_max_consecutive_failed_load)
+            self.check_state_if_not_detector_thread()
+
+    def _check_state(self) -> Optional[float]:
+        cfg = self._config
+        reasons = set()
+        for reason, use, engaged in (
+            (self.MAX_PELLET_LOADED_ENGAGED, cfg.use_max_pellet_loaded, self._max_pellet_loaded_engaged),
+            (self.MAX_CONSECUTIVE_FAILED_LOAD_ENGAGED, cfg.use_max_consecutive_failed_load, self._max_consecutive_failed_load_engaged),
+        ):
+            if use and engaged:
+                reasons.add(reason)
+        self._engaged_reasons = reasons
+        prev_engaged = self._is_engaged
+        self.is_engaged = len(reasons) > 0
+        if not prev_engaged and self._is_engaged:
+            self._logger.notice("Engaging with %s", reasons)
+
+    def update_pellet_loaded(self, loaded: int):
+        cfg = self._config
+        engaged = loaded >= cfg.max_pellets_loaded_count
+        self.max_pellet_loaded_engaged = engaged
+
+    def update_failed_pellet_load(self, *, consecutive: int):
+        cfg = self._config
+        engaged = consecutive >= cfg.max_consecutive_failed_loaded
+        self.max_consecutive_failed_load_engaged = engaged

autotrainer/core/animal/__init__.py

@@ -0,0 +1 @@
+from .animal_subject import AnimalSubject