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

autotrainer/core/animal/animal_subject.py

@@ -0,0 +1,208 @@
+import dataclasses
+import datetime
+import json
+import logging
+import os
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Optional, Dict, Any, List, Type
+from typing_extensions import Self
+
+from autotrainer.core import Offset3DTuple, get_verbose_logger
+
+logger = get_verbose_logger(__name__)
+
+
+_date_format = "%Y%m%d"
+
+
+def _load_old_format(data: Dict[str, Any]) -> "AnimalSubject":
+    kw = {}
+    if "name" in data:
+        kw['name'] = data["name"]
+    animal = AnimalSubject(**kw)
+    if "pellet_x" in data and "pellet_y" in data and "pellet_z" in data:
+        animal.pellet_x = data["pellet_x"]
+        animal.pellet_y = data["pellet_y"]
+        animal.pellet_z = data["pellet_z"]
+    return animal
+
+
+@dataclass
+class AnimalTraining:
+    """Animal Training configuration"""
+
+    # NB: protocol == plan ; todo: could/should better be moved to auto-trainer-training repo
+
+    current_protocol: Optional[str] = None
+    protocols: List[Dict[str, Any]] = dataclasses.field(default_factory=list)
+
+    def get_plan_progress(self, plan_id: str) -> Optional[Dict[str, Any]]:
+        # {"plan_id": self.plan_id,
+        #                 "progress_state": self.progress_state,
+        #                 "current_phase_id": None if self.current_phase is None else self.current_phase.phase_id,
+        #                 "progress": progress
+        #                 }
+        for prot in self.protocols:
+            if prot.get('plan_id') == plan_id:
+                return prot
+        return None
+
+    def set_plan_progress(self, plan_id: str, progress: Dict[str, Any]):
+        for idx, prog in enumerate(self.protocols):
+            if prog['plan_id'] == plan_id:
+                self.protocols[idx] = progress
+                return
+        self.protocols.append(progress)
+
+
+@dataclass
+class AnimalPelletCounts:
+    presented: int = 0   # == successfully sent/delivered to the animal
+    reaches: int = 0
+    success_reaches: int = 0
+    consumed: int = 0
+
+
+@dataclass
+class _AnimalSubject:
+    """A subject in an animal experiment."""
+
+    version: int = 2
+
+    name: str = ""
+    id: str = None   # handled in post_init
+
+    is_pellet_dcs: bool = False
+    pellet_x: float = 0
+    pellet_y: float = 0
+    pellet_z: float = 0
+
+    training: AnimalTraining = dataclasses.field(default_factory=AnimalTraining)
+
+    pellet_counts_day_date: datetime.date = dataclasses.field(default_factory=datetime.date.today)
+    pellet_counts_day: AnimalPelletCounts = dataclasses.field(default_factory=AnimalPelletCounts)
+    pellet_counts_total: AnimalPelletCounts = dataclasses.field(default_factory=AnimalPelletCounts)
+
+    target_y_limit: Optional[float] = None  # in DCS
+
+    def __post_init__(self):
+        if self.id is None:
+            self.id = str(uuid.uuid4())
+        if not self.name:
+            self.name = f"Mouse-{self.id}"
+
+
+@dataclass
+class AnimalSubject(_AnimalSubject):
+
+    def __init__(self, **kwargs):
+        kwargs.pop("baseline_magnet_intensity", None)
+        super().__init__(**kwargs)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(name={self.name!r}, id={self.id!r})"
+
+    @classmethod
+    def from_file(cls: Type[Self], file_path: Path) -> Optional[Self]:
+        with file_path.open("r") as file:
+            try:
+                data = json.load(file)
+                if not isinstance(data, dict):
+                    if not data:
+                        # assuming empty file
+                        return cls()
+                    raise ValueError(f"Invalid file format in {file_path} ; not a dict: %s", type(data))
+                file_version = data.get("version", None)
+                if file_version is None or file_version != AnimalSubject.version:
+                    logger.notice("Loaded animal version %s vs current Animal version %s",
+                                   file_version, AnimalSubject.version)
+                if "id" not in data:
+                    # old format
+                    animal = _load_old_format(data)
+                else:
+                    reach = data.pop('reach')
+                    pellet_dev = reach.pop('pelletDevice', None)
+                    pellet_dcs = reach.pop('pelletDcs', None)
+                    if pellet_dcs is None:
+                        src = pellet_dev
+                    else:
+                        src = pellet_dcs
+                    pellet_x, pellet_y, pellet_z = src['x'], src['y'], src['z']
+                    training = data.pop('training')
+                    pellet_counts_day_dct = data.pop("pelletCountsDay", {})
+                    pellet_counts_total_dct = data.pop("pelletCountsTotal", {})
+                    count_day_date_str: Optional[str] = data.pop('pelletCountsDayDate', None)
+                    if count_day_date_str is None:
+                        pellet_counts_day_date = datetime.date.today()
+                    else:
+                        pellet_counts_day_date = datetime.datetime.strptime(count_day_date_str, _date_format).date()
+                    animal = cls(
+                        id=data.pop('id'),
+                        name=data.pop('name'),
+                        is_pellet_dcs=pellet_dcs is not None,
+                        target_y_limit=data.pop('targetYLimit', None),
+                        pellet_x=pellet_x,
+                        pellet_y=pellet_y,
+                        pellet_z=pellet_z,
+                        training=AnimalTraining(
+                            current_protocol=training.pop('currentProtocol'),
+                            protocols=training.pop('protocols'),
+                        ),
+                        pellet_counts_day_date=pellet_counts_day_date,
+                        pellet_counts_day=AnimalPelletCounts(**pellet_counts_day_dct),
+                        pellet_counts_total=AnimalPelletCounts(**pellet_counts_total_dct),
+                    )
+            except Exception as err:
+                logger.error("Error loading animal subject from %s: %s", file_path, err)
+                return None
+
+        logger.debug("loaded animal id=%r name=%r pellet=%s is_dcs=%s current_protocol=%s",
+                     animal.id, animal.name,
+                     (animal.pellet_x, animal.pellet_y, animal.pellet_z), animal.is_pellet_dcs,
+                     animal.training.current_protocol)
+
+        return animal
+
+    def to_file(self, file_path: Path):
+        reach: Dict[str, Any] = {}
+        key = "pelletDcs" if self.is_pellet_dcs else "pelletDevice"
+        reach[key] = {
+            'x': self.pellet_x,
+            'y': self.pellet_y,
+            'z': self.pellet_z,
+        }
+        data = {
+            "version": self.version,
+            "id": self.id,
+            "name": self.name,
+            "reach": reach,
+            "training": {
+                'currentProtocol': self.training.current_protocol,
+                'protocols': self.training.protocols,
+            },
+            "targetYLimit": self.target_y_limit,
+            "pelletCountsDayDate": self.pellet_counts_day_date.strftime(_date_format),
+            "pelletCountsDay": dataclasses.asdict(self.pellet_counts_day),
+            "pelletCountsTotal": dataclasses.asdict(self.pellet_counts_total),
+        }
+        xyz = Offset3DTuple(self.pellet_x, self.pellet_y, self.pellet_z)
+        logger.debug("Saving %s to %s ; xyz=%s", self.name, file_path.as_posix(), xyz.humanize())
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with NamedTemporaryFile("w", delete=False, dir=file_path.parent) as fh:
+            json.dump(data, fh, indent=4)
+        os.replace(fh.name, file_path)
+
+    def check_today_date(self) -> bool:
+        """Return True if changed"""
+        today = datetime.date.today()
+        prev = self.pellet_counts_day_date
+        if prev != today:
+            logger.debug("today (%s) != animal prev day date (%s), resetting day counts to 0",
+                         today, prev)
+            self.pellet_counts_day_date = today
+            self.pellet_counts_day = AnimalPelletCounts()
+            return True
+        return False

autotrainer/core/capture.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class CaptureProcessStatus(IntEnum):
+    """Valid VideoCaptureProcess states available through the status Value"""
+
+    TERMINATED = -2
+    """The capture loop is terminated"""
+
+    FAILED = -1
+    """Failed to configure or run process"""
+
+    UNKNOWN = 0
+    """Uninitialized value not yet set by capture process"""
+
+    INITIALIZED = 1
+    """The process is created, but not started"""
+
+    RUNNING = 2
+    """The process is running the capture loop"""
+
+    RECORDING = 3
+    """The process is recording the stream to disk"""

autotrainer/core/configuration/__init__.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import yaml
+
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core import Offset3DTuple
+
+logger = get_verbose_logger(__name__)
+
+
+DEFAULT_3D_CALIB_DIR_NAME = "4mm_6r_8c_4x"
+
+
+def generic_constructor(loader, tag, node):
+    cls_name = node.__class__.__name__
+    if cls_name == "SequenceNode":
+        return loader.construct_sequence(node)
+    elif cls_name == "MappingNode":
+        return loader.construct_mapping(node)
+    else:
+        return loader.construct_scalar(node)
+
+
+class GenericSafeLoader(yaml.SafeLoader):
+    pass
+
+
+GenericSafeLoader.add_multi_constructor("", generic_constructor)
+
+#
+
+class SystemConfigurationLoader(yaml.SafeLoader):
+    """Dedicated yaml loader for SystemConfiguration"""
+    safe_load: bool = False
+
+
+class SystemConfigurationSafeLoader(SystemConfigurationLoader):
+
+    safe_load = True
+
+    def ignore_unknown(self, suffix, node):
+        logger.warning("Skipping/ignoring tag/section %s", suffix)
+        return None
+
+
+def _ignore_unknown(loader, suffix, node):
+    return loader.ignore_unknown(suffix, node)
+
+
+# allow to ignore unknown tags:
+SystemConfigurationSafeLoader.add_multi_constructor('', _ignore_unknown)
+SystemConfigurationSafeLoader.add_multi_constructor('!', _ignore_unknown)
+
+
+#
+_offset3dtag = "!Offset3DTuple"
+_shift_xyz_tag = "!ShiftXYZTarget"
+
+def construct_offset3d_tuple(loader: yaml.Loader, node: yaml.nodes.MappingNode):
+    content = loader.construct_mapping(node)
+    return Offset3DTuple(**content)
+
+
+SystemConfigurationLoader.add_constructor(_offset3dtag, construct_offset3d_tuple)
+SystemConfigurationLoader.add_constructor(_shift_xyz_tag, construct_offset3d_tuple)
+
+#
+
+class SystemConfigurationDumper(yaml.SafeDumper):
+    """Dedicated yaml dumper for SystemConfiguration"""
+
+
+def repr_offset3d_tuple(dumper: SystemConfigurationDumper, obj: Offset3DTuple):
+    x, y, z = obj
+    return dumper.represent_mapping(_offset3dtag, dict(x=x, y=y, z=z))
+
+
+SystemConfigurationDumper.add_representer(Offset3DTuple, repr_offset3d_tuple)
+
+# above must be before below
+
+
+from .behavior_configuration import BehaviorConfiguration, ShiftXYZTarget
+from .camera_configuration import CameraConfiguration, CameraId
+from .hardware_configuration import HardwareConfiguration
+from .inference_configuration import InferenceConfiguration
+from .persistence_configuration import PersistenceConfiguration
+from .system_configuration import SystemConfiguration

autotrainer/core/configuration/alarm_configuration.py

@@ -0,0 +1,55 @@
+
+import dataclasses
+
+
+@dataclasses.dataclass
+class _EmergencyAlarmConfiguration:
+
+    # 1st possible alarm condition
+    use_audio_load_cell_thrash: bool = False
+    auto_resume_on_audio_load_cell_thrash_resume: bool = False
+
+    audio_load_cell_thrash_aggregate_delay: float = 5  # up to how long ago to look at previous results
+    #
+    # ( ( if count of thrashing triggers greater than this (during last aggregate_delay)
+    load_cell_thrash_count: int = 3
+    # or percent of time it is ON during aggregate_delay
+    load_cell_thrash_percent_on: float = 50
+    # )
+    # and
+    # (
+    audio_thrash_count: int = 3  # spectrum thrash count greater than this (during last aggregate_delay)
+    audio_thrash_percent_on: float = 50  # or percent of time it is ON during aggregate_delay
+    # ) )
+
+    # 2nd possible alarm condition
+    use_presence_missing_after_exit_tunnel: bool = False
+    auto_resume_on_presence_seen_after_exit_tunnel: bool = False
+    tunnel_to_cage_presence_missing_delay: float = 5
+
+    # 3rd
+    use_external_doors_open: bool = False
+    auto_resume_on_external_doors_close: bool = False
+
+    # 4rd
+    use_global_animal_presence: bool = False
+    auto_resume_on_global_animal_presence: bool = False
+
+    # 5th
+    use_device_comm_error: bool = True
+    auto_resume_on_device_comm_error: bool = True
+
+    # 6th
+    use_system_maintenance: bool = True
+    auto_resume_on_system_maintenance: bool = True
+
+    # 7th
+    use_system_fault: bool = True
+    auto_resume_on_system_fault: bool = True
+
+
+@dataclasses.dataclass
+class EmergencyAlarmConfiguration(_EmergencyAlarmConfiguration):
+
+    def __init__(self, **kwargs):  # force kwargs
+        super().__init__(**kwargs)

autotrainer/core/configuration/animal_presence_configuration.py

@@ -0,0 +1,17 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class _GlobalAnimalPresenceConfig:
+
+    presence_missing_delay_hours: float = 12
+    # if mouse not seen in tunnel AND not seen in cage longer than the delay, then trigger
+
+
+class GlobalAnimalPresenceConfig(_GlobalAnimalPresenceConfig):
+
+    def __init__(self, *,
+                 presence_missing_delay: float = None,  # noqa
+                 **kwargs):
+        del presence_missing_delay  # old param name  # todo: remove some when later
+        super().__init__(**kwargs)