Social schema

aeon/dj_pipeline/acquisition.py

@@ -5,7 +5,7 @@
 import pandas as pd
 
 from aeon.io import api as io_api
-from aeon.schema import dataset as aeon_schema
+from aeon.io import schemas as aeon_schema
 from aeon.io import reader as io_reader
 from aeon.analysis import utils as analysis_utils
 

aeon/io/api.py

@@ -115,7 +115,8 @@ def load(root, reader, start=None, end=None, time=None, tolerance=None, epoch=No
                 # to fill missing values
                 previous = reader.read(files[i - 1])
                 data = pd.concat([previous, frame])
-                data = data.reindex(values, method="pad", tolerance=tolerance)
+                data = data.reindex(values, tolerance=tolerance)
+                data.dropna(inplace=True)
             else:
                 data.drop(columns="time", inplace=True)
             dataframes.append(data)

aeon/io/device.py

@@ -1,41 +1,40 @@
 import inspect
 
 
-def compositeStream(pattern, *args):
-    """Merges multiple data streams into a single composite stream."""
-    composite = {}
+def register(pattern, *args):
+    """Merges multiple Readers into a single registry."""
+    registry = {}
     if args:
-        for stream in args:
-            if inspect.isclass(stream):
-                for method in vars(stream).values():
+        for binder_fn in args:
+            if inspect.isclass(binder_fn):
+                for method in vars(binder_fn).values():
                     if isinstance(method, staticmethod):
-                        composite.update(method.__func__(pattern))
+                        registry.update(method.__func__(pattern))
             else:
-                composite.update(stream(pattern))
-    return composite
+                registry.update(binder_fn(pattern))
+    return registry
 
 
 class Device:
-    """Groups multiple data streams into a logical device.
+    """Groups multiple Readers into a logical device.
 
-    If a device contains a single stream with the same pattern as the device
-    `name`, it will be considered a singleton, and the stream reader will be
-    paired directly with the device without nesting.
+    If a device contains a single stream reader with the same pattern as the device `name`, it will be 
+    considered a singleton, and the stream reader will be paired directly with the device without nesting.
 
     Attributes:
         name (str): Name of the device.
-        args (Any): Data streams collected from the device.
+        args (any): A binder function or class that returns a dictionary of Readers.
         pattern (str, optional): Pattern used to find raw chunk files,
             usually in the format `<Device>_<DataStream>`.
     """
 
     def __init__(self, name, *args, pattern=None):
         self.name = name
-        self.stream = compositeStream(name if pattern is None else pattern, *args)
+        self.registry = register(name if pattern is None else pattern, *args)
 
     def __iter__(self):
-        if len(self.stream) == 1:
-            singleton = self.stream.get(self.name, None)
+        if len(self.registry) == 1:
+            singleton = self.registry.get(self.name, None)
             if singleton:
                 return iter((self.name, singleton))
-        return iter((self.name, self.stream))
+        return iter((self.name, self.registry))

aeon/io/reader.py

@@ -212,7 +212,7 @@ def read(self, file):
         specified unique identifier.
         """
         data = super().read(file)
-        data = data[data.event & self.value > 0]
+        data = data[(data.event & self.value) == self.value]
         data["event"] = self.tag
         return data
 

aeon/schema/core.py

@@ -24,7 +24,7 @@ def encoder(pattern):
 
 def environment(pattern):
     """Metadata for environment mode and subjects."""
-    return _device.compositeStream(pattern, environment_state, subject_state)
+    return _device.register(pattern, environment_state, subject_state)
 
 
 def environment_state(pattern):
@@ -37,7 +37,7 @@ def subject_state(pattern):
     return {"SubjectState": _reader.Subject(f"{pattern}_SubjectState_*")}
 
 
-def messageLog(pattern):
+def message_log(pattern):
     """Message log data."""
     return {"MessageLog": _reader.Log(f"{pattern}_MessageLog_*")}
 

aeon/schema/foraging.py

@@ -58,14 +58,14 @@ def region(pattern):
     return {"Region": _RegionReader(f"{pattern}_201_*")}
 
 
-def depletionFunction(pattern):
+def depletion_function(pattern):
     """State of the linear depletion function for foraging patches."""
     return {"DepletionState": _PatchState(f"{pattern}_State_*")}
 
 
 def feeder(pattern):
     """Feeder commands and events."""
-    return _device.compositeStream(pattern, beam_break, deliver_pellet)
+    return _device.register(pattern, beam_break, deliver_pellet)
 
 
 def beam_break(pattern):
@@ -80,12 +80,12 @@ def deliver_pellet(pattern):
 
 def patch(pattern):
     """Data streams for a patch."""
-    return _device.compositeStream(pattern, depletionFunction, _stream.encoder, feeder)
+    return _device.register(pattern, depletion_function, _stream.encoder, feeder)
 
 
 def weight(pattern):
     """Weight measurement data streams for a specific nest."""
-    return _device.compositeStream(pattern, weight_raw, weight_filtered, weight_subject)
+    return _device.register(pattern, weight_raw, weight_filtered, weight_subject)
 
 
 def weight_raw(pattern):

aeon/schema/schemas.py

@@ -0,0 +1,112 @@
+from dotmap import DotMap
+from aeon.io.device import Device
+from aeon.schema import core, foraging, octagon
+
+exp02 = DotMap(
+    [
+        Device("Metadata", core.metadata),
+        Device("ExperimentalMetadata", core.environment, core.message_log),
+        Device("CameraTop", core.video, core.position, foraging.region),
+        Device("CameraEast", core.video),
+        Device("CameraNest", core.video),
+        Device("CameraNorth", core.video),
+        Device("CameraPatch1", core.video),
+        Device("CameraPatch2", core.video),
+        Device("CameraSouth", core.video),
+        Device("CameraWest", core.video),
+        Device("Nest", foraging.weight),
+        Device("Patch1", foraging.patch),
+        Device("Patch2", foraging.patch),
+    ]
+)
+
+exp01 = DotMap(
+    [
+        Device("SessionData", foraging.session),
+        Device("FrameTop", core.video, core.position),
+        Device("FrameEast", core.video),
+        Device("FrameGate", core.video),
+        Device("FrameNorth", core.video),
+        Device("FramePatch1", core.video),
+        Device("FramePatch2", core.video),
+        Device("FrameSouth", core.video),
+        Device("FrameWest", core.video),
+        Device("Patch1", foraging.depletion_function, core.encoder, foraging.feeder),
+        Device("Patch2", foraging.depletion_function, core.encoder, foraging.feeder),
+    ]
+)
+
+octagon01 = DotMap(
+    [
+        Device("Metadata", core.metadata),
+        Device("CameraTop", core.video, core.position),
+        Device("CameraColorTop", core.video),
+        Device("ExperimentalMetadata", core.subject_state),
+        Device("Photodiode", octagon.photodiode),
+        Device("OSC", octagon.OSC),
+        Device("TaskLogic", octagon.TaskLogic),
+        Device("Wall1", octagon.Wall),
+        Device("Wall2", octagon.Wall),
+        Device("Wall3", octagon.Wall),
+        Device("Wall4", octagon.Wall),
+        Device("Wall5", octagon.Wall),
+        Device("Wall6", octagon.Wall),
+        Device("Wall7", octagon.Wall),
+        Device("Wall8", octagon.Wall),
+    ]
+)
+
+# All recorded social01 streams:
+
+# *Note* regiser 8 is always the harp heartbeat for any device that has this stream.
+
+# - Metadata.yml
+# - Environment_BlockState
+# - Environment_EnvironmentState
+# - Environment_LightEvents
+# - Environment_MessageLog
+# - Environment_SubjectState
+# - Environment_SubjectVisits
+# - Environment_SubjectWeight
+# - CameraTop (200, 201, avi, csv, <model_path>,)
+#     - 200: position
+#     - 201: region
+# - CameraNorth (avi, csv)
+# - CameraEast (avi, csv)
+# - CameraSouth (avi, csv)
+# - CameraWest (avi, csv)
+# - CameraPatch1 (avi, csv)
+# - CameraPatch2 (avi, csv)
+# - CameraPatch3 (avi, csv)
+# - CameraNest (avi, csv)
+# - ClockSynchronizer (8, 36)
+#     - 36: 
+# - Nest (200, 201, 202, 203)
+#     - 200: weight_raw
+#     - 201: weight_tare
+#     - 202: weight_filtered
+#     - 203: weight_baseline
+#     - 204: weight_subject
+# - Patch1 (8, 32, 35, 36, 87, 90, 91, 200, 201, 202, 203, State)
+#     - 32: beam_break
+#     - 35: delivery_set
+#     - 36: delivery_clear
+#     - 87: expansion_board
+#     - 90: enocder_read
+#     - 91: encoder_mode
+#     - 200: dispenser_state
+#     - 201: delivery_manual
+#     - 202: missed_pellet
+#     - 203: delivery_retry
+# - Patch2 (8, 32, 35, 36, 87, 90, 91, State)
+# - Patch3 (8, 32, 35, 36, 87, 90, 91, 200, 203, State)
+# - RfidEventsGate (8, 32, 35)
+#     - 32: entry_id
+#     - 35: hardware_notifications
+# - RfidEventsNest1 (8, 32, 35)
+# - RfidEventsNest2 (8, 32, 35)
+# - RfidEventsPatch1 (8, 32, 35)
+# - RfidEventsPatch2 (8, 32, 35)
+# - RfidEventsPatch3 (8, 32, 35)
+# - VideoController (8, 32, 33, 34, 35, 36, 45, 52)
+#     - 32: frame_number

aeon/schema/social.py

@@ -32,7 +32,7 @@ def read(
     ) -> pd.DataFrame:
         """Reads data from the Harp-binarized tracking file."""
         # Get config file from `file`, then bodyparts from config file.
-        model_dir = Path(file.stem.replace("_", "/")).parent
+        model_dir = Path(*Path(file.stem.replace("_", "/")).parent.parts[1:])
         config_file_dir = ceph_proc_dir / model_dir
         if not config_file_dir.exists():
             raise FileNotFoundError(f"Cannot find model dir {config_file_dir}")