add mock neurodata objects

src/pynwb/testing/mock/base.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+from ...base import TimeSeries
+from .utils import name_generator
+
+
+def mock_TimeSeries(
+    name=name_generator("TimeSeries"),
+    data=np.array([1, 2, 3, 4]),
+    unit="volts",
+    resolution=-1.0,
+    conversion=1.0,
+    timestamps=None,
+    starting_time=None,
+    rate=10.0,
+    comments="no comments",
+    description="no description",
+    control=None,
+    control_description=None,
+    continuity=None,
+):
+    return TimeSeries(
+        name=name,
+        data=data,
+        unit=unit,
+        resolution=resolution,
+        conversion=conversion,
+        timestamps=timestamps,
+        starting_time=starting_time,
+        rate=rate,
+        comments=comments,
+        description=description,
+        control=control,
+        control_description=control_description,
+        continuity=continuity,
+    )

src/pynwb/testing/mock/behavior.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+from ...behavior import (
+    PupilTracking,
+    Position,
+    SpatialSeries,
+    CompassDirection,
+)
+from .utils import name_generator
+from .base import mock_TimeSeries
+
+
+def mock_SpatialSeries(
+    name=name_generator("SpatialSeries"),
+    data=np.array([1, 2, 3, 4]),
+    reference_frame="lower left is (0, 0)",
+    unit="meters",
+    conversion=1.0,
+    resolution=-1.0,
+    timestamps=None,
+    starting_time=None,
+    rate=10.0,
+    comments="no comments",
+    description="no description",
+    control=None,
+    control_description=None,
+):
+    return SpatialSeries(
+        name=name,
+        data=data,
+        reference_frame=reference_frame,
+        unit=unit,
+        conversion=conversion,
+        resolution=resolution,
+        timestamps=timestamps,
+        starting_time=starting_time,
+        rate=rate,
+        comments=comments,
+        description=description,
+        control=control,
+        control_description=control_description,
+    )
+
+
+def mock_Position(
+    name=name_generator("Position"), spatial_series=None,
+):
+    return Position(name=name, spatial_series=spatial_series or [mock_SpatialSeries()])
+
+
+def mock_PupilTracking(
+    name=name_generator("PupilTracking"), time_series=None,
+):
+    return PupilTracking(name=name, time_series=time_series or [mock_TimeSeries()])
+
+
+def mock_CompassDirection(name=name_generator("CompassDirection"), spatial_series=None):
+    return CompassDirection(
+        name=name, spatial_series=spatial_series or [mock_SpatialSeries(unit="radians")]
+    )

src/pynwb/testing/mock/device.py

@@ -0,0 +1,15 @@
+from ...device import Device
+
+from .utils import name_generator
+
+
+def mock_Device(
+    name=name_generator("Device"),
+    description="description",
+    manufacturer=None,
+):
+    return Device(
+        name=name,
+        description=description,
+        manufacturer=manufacturer,
+    )

src/pynwb/testing/mock/ecephys.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+from hdmf.common.table import DynamicTableRegion
+
+from ...file import ElectrodeTable
+from ...ecephys import ElectricalSeries, ElectrodeGroup, SpikeEventSeries
+from .device import mock_Device
+from .utils import name_generator
+
+
+def mock_ElectrodeGroup(
+    name=name_generator("ElectrodeGroup"),
+    description="description",
+    location="location",
+    device=mock_Device(),
+    position=None,
+):
+    return ElectrodeGroup(
+        name=name, description=description, location=location, device=device, position=position,
+    )
+
+
+def mock_ElectrodeTable(n_rows=5, group=mock_ElectrodeGroup()):
+    table = ElectrodeTable()
+    for i in range(n_rows):
+        table.add_row(
+            x=1.0,
+            y=2.0,
+            z=3.0,
+            imp=-(i + 1),
+            location="CA1",
+            filtering="none",
+            group=group,
+            group_name=group.name,
+        )
+    return table
+
+
+def mock_electrodes(n_electrodes=5, table=mock_ElectrodeTable(n_rows=5)):
+    return DynamicTableRegion(
+        "electrodes", list(range(n_electrodes)), "the first and third electrodes", table
+    )
+
+
+def mock_ElectricalSeries(
+    name=name_generator("ElectricalSeries"),
+    description="description",
+    data=np.ones((10, 5)),
+    rate=30000.0,
+    timestamps=None,
+    electrodes=mock_electrodes(),
+    filtering="filtering",
+):
+    return ElectricalSeries(
+        name=name,
+        description=description,
+        data=data,
+        rate=rate,
+        timestamps=timestamps,
+        electrodes=electrodes,
+        filtering=filtering,
+    )
+
+
+def mock_SpikeEventSeries(
+    name=name_generator("SpikeEventSeries"),
+    description="description",
+    data=np.ones((10, 5)),
+    timestamps=np.arange(10).astype(float),
+    electrodes=mock_electrodes(),
+):
+    return SpikeEventSeries(
+        name=name,
+        description=description,
+        data=data,
+        timestamps=timestamps,
+        electrodes=electrodes,
+    )

src/pynwb/testing/mock/ophys.py

@@ -0,0 +1,195 @@
+import numpy as np
+
+from hdmf.common.table import DynamicTableRegion
+from ...ophys import (
+    RoiResponseSeries,
+    OpticalChannel,
+    ImagingPlane,
+    TwoPhotonSeries,
+    PlaneSegmentation,
+    ImageSegmentation,
+    DfOverF,
+    Fluorescence,
+)
+from .device import mock_Device
+from .utils import name_generator
+
+
+def mock_OpticalChannel(
+    name=name_generator("OpticalChannel"),
+    description="description",
+    emission_lambda=500.0,
+):
+    return OpticalChannel(
+        name=name, description=description, emission_lambda=emission_lambda,
+    )
+
+
+def mock_ImagingPlane(
+    name=name_generator("ImagingPlane"),
+    optical_channel=mock_OpticalChannel(),
+    description="description",
+    device=mock_Device(),
+    excitation_lambda=500.0,
+    indicator="indicator",
+    location="unknown",
+    imaging_rate=30.0,
+    manifold=None,
+    conversion=1.0,
+    unit="meters",
+    reference_frame=None,
+    origin_coords=None,
+    origin_coords_unit="meters",
+    grid_spacing=None,
+    grid_spacing_unit="meters",
+):
+    return ImagingPlane(
+        name=name,
+        optical_channel=optical_channel,
+        description=description,
+        device=device,
+        excitation_lambda=excitation_lambda,
+        indicator=indicator,
+        location=location,
+        imaging_rate=imaging_rate,
+        manifold=manifold,
+        conversion=conversion,
+        unit=unit,
+        reference_frame=reference_frame,
+        origin_coords=origin_coords,
+        origin_coords_unit=origin_coords_unit,
+        grid_spacing=grid_spacing,
+        grid_spacing_unit=grid_spacing_unit,
+    )
+
+
+def mock_TwoPhotonSeries(
+    name=name_generator("TwoPhotonSeries"),
+    imaging_plane=mock_ImagingPlane(),
+    data=np.ones((20, 5, 5)),
+    rate=50.0,
+    unit="n.a.",
+    format=None,
+    field_of_view=None,
+    pmt_gain=None,
+    scan_line_rate=None,
+    external_file=None,
+    starting_frame=[0],
+    bits_per_pixel=None,
+    dimension=None,
+    resolution=-1.0,
+    conversion=1.0,
+    timestamps=None,
+    starting_time=None,
+    comments="no comments",
+    description="no description",
+    control=None,
+    control_description=None,
+    device=None,
+):
+    return TwoPhotonSeries(
+        name=name,
+        imaging_plane=imaging_plane,
+        data=data,
+        unit=unit,
+        format=format,
+        field_of_view=field_of_view,
+        pmt_gain=pmt_gain,
+        scan_line_rate=scan_line_rate,
+        external_file=external_file,
+        starting_frame=starting_frame,
+        bits_per_pixel=bits_per_pixel,
+        dimension=dimension,
+        resolution=resolution,
+        conversion=conversion,
+        timestamps=timestamps,
+        starting_time=starting_time,
+        rate=rate,
+        comments=comments,
+        description=description,
+        control=control,
+        control_description=control_description,
+        device=device,
+    )
+
+
+def mock_PlaneSegmentation(
+    description="no description",
+    imaging_plane=mock_ImagingPlane(),
+    name=name_generator("PlaneSegmentation"),
+    reference_images=None,
+    n_rois=5,
+):
+    plane_segmentation = PlaneSegmentation(
+        description=description,
+        imaging_plane=imaging_plane,
+        name=name,
+        reference_images=reference_images,
+    )
+
+    for _ in range(n_rois):
+        plane_segmentation.add_roi(image_mask=np.zeros((10, 10)))
+
+    return plane_segmentation
+
+
+def mock_ImageSegmentation(
+    plane_segmentations=None, name="ImageSegmentation",
+):
+    return ImageSegmentation(
+        plane_segmentations=plane_segmentations or [mock_PlaneSegmentation()],
+        name=name,
+    )
+
+
+def mock_RoiResponseSeries(
+    name=name_generator("RoiResponseSeries"),
+    data=np.ones((30, 5)),
+    unit="n.a.",
+    rois=None,
+    resolution=-1.0,
+    conversion=1.0,
+    timestamps=None,
+    starting_time=None,
+    rate=50.0,
+    comments="no comments",
+    description="no description",
+    control=None,
+    control_description=None,
+    n_rois=5,
+):
+    return RoiResponseSeries(
+        name=name,
+        data=data,
+        unit=unit,
+        rois=rois
+        or DynamicTableRegion(
+            name="rois",
+            description="rois",
+            table=mock_PlaneSegmentation(n_rois=n_rois),
+            data=list(range(n_rois)),
+        ),
+        resolution=resolution,
+        conversion=conversion,
+        timestamps=timestamps,
+        starting_time=starting_time,
+        rate=rate,
+        comments=comments,
+        description=description,
+        control=control,
+        control_description=control_description,
+    )
+
+
+def mock_DfOverF(roi_response_series=None, name=name_generator("DfOverF")):
+    return DfOverF(
+        roi_response_series=roi_response_series or [mock_RoiResponseSeries()],
+        name=name,
+    )
+
+
+def mock_Fluorescence(roi_response_series=None, name="Fluorescence"):
+    return Fluorescence(
+        roi_response_series=roi_response_series or [mock_RoiResponseSeries()],
+        name=name,
+    )