Merge pull request #16 from SpikeInterface/add_tests

Add tests for roundtrip

Author: khl02007

.github/workflows/full_tests.yml

@@ -0,0 +1,35 @@
+name: Full tests
+
+on:
+  pull_request:
+      branches: [main]
+      types: [synchronize, opened, reopened]
+  workflow_dispatch:
+  schedule:
+    - cron: "0 12 * * *"  # Daily at noon UTC
+
+
+jobs:
+  build-and-test:
+
+    runs-on: [ubuntu-latest, 'windows-latest', 'macos-latest']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.11"
+    - name: Install package
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements-dev.txt
+        pip install -e .
+    - name: Pytest
+      run: |
+        pytest --cov=probeinterface --cov-report xml:./coverage.xml
+    - uses: codecov/codecov-action@v3
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        fail_ci_if_error: true
+        file: ./coverage.xml

.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,34 @@
+name: Release to PyPI
+
+on:
+  push:
+    tags:
+       - '*'
+jobs:
+  release:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Install Tools
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements-dev.txt
+        pip install .
+        pip install setuptools wheel twine build
+    - name: Test with pytest
+      run: |
+        pytest -v
+    - name: Package and Upload
+      env:
+        STACKMANAGER_VERSION: ${{ github.event.release.tag_name }}
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        python -m build --sdist --wheel
+        twine upload dist/*

spec/ndx-probeinterface.extensions.yaml

@@ -57,14 +57,29 @@ groups:
   neurodata_type_inc: DynamicTable
   doc: Neural probe contacts according to probeinterface specification
   datasets:
-  - name: contact_id
+  - name: contact_position
     neurodata_type_inc: VectorData
-    dtype: text
-    doc: unique ID of the contact
+    dtype: float
+    dims:
+    - - num_contacts
+      - x, y
+    - - num_contacts
+      - x, y, z
+    shape:
+    - - null
+      - 2
+    - - null
+      - 3
+    doc: dimension of the probe
   - name: contact_shape
     neurodata_type_inc: VectorData
     dtype: text
     doc: shape of the contact; e.g. 'circle'
+  - name: contact_id
+    neurodata_type_inc: VectorData
+    dtype: text
+    doc: unique ID of the contact
+    quantity: '?'
   - name: contact_plane_axes
     neurodata_type_inc: VectorData
     dtype: float
@@ -83,21 +98,24 @@ groups:
       - 2
       - 3
     doc: dimension of the probe
-  - name: contact_position
+    quantity: '?'
+  - name: radius
     neurodata_type_inc: VectorData
     dtype: float
-    dims:
-    - - num_contacts
-      - x, y
-    - - num_contacts
-      - x, y, z
-    shape:
-    - - null
-      - 2
-    - - null
-      - 3
-    doc: dimension of the probe
-  - name: device_channel_index
+    doc: Radius of a circular contact
+    quantity: '?'
+  - name: width
+    neurodata_type_inc: VectorData
+    dtype: float
+    doc: Width of a rectangular or square contact
+    quantity: '?'
+  - name: height
+    neurodata_type_inc: VectorData
+    dtype: float
+    doc: Height of a rectangular contact
+    quantity: '?'
+  - name: device_channel_index_pi
     neurodata_type_inc: VectorData
     dtype: int
     doc: ID of the channel connected to the contact
+    quantity: '?'

src/pynwb/ndx_probeinterface/__init__.py

@@ -2,34 +2,28 @@
 from pynwb import load_namespaces, get_class
 
 # Set path of the namespace.yaml file to the expected install location
-ndx_probeinterface_specpath = os.path.join(
-    os.path.dirname(__file__),
-    'spec',
-    'ndx-probeinterface.namespace.yaml'
-)
+ndx_probeinterface_specpath = os.path.join(os.path.dirname(__file__), "spec", "ndx-probeinterface.namespace.yaml")
 
 # If the extension has not been installed yet but we are running directly from
 # the git repo
 if not os.path.exists(ndx_probeinterface_specpath):
-    ndx_probeinterface_specpath = os.path.abspath(os.path.join(
-        os.path.dirname(__file__),
-        '..', '..', '..',
-        'spec',
-        'ndx-probeinterface.namespace.yaml'
-    ))
+    ndx_probeinterface_specpath = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "..", "..", "spec", "ndx-probeinterface.namespace.yaml")
+    )
 
 # Load the namespace
 load_namespaces(ndx_probeinterface_specpath)
 
 # TODO: import your classes here or define your class using get_class to make
 # them accessible at the package level
-Probe = get_class('Probe', 'ndx-probeinterface')
-Shank = get_class('Shank', 'ndx-probeinterface')
-ContactTable = get_class('ContactTable', 'ndx-probeinterface')
+Probe = get_class("Probe", "ndx-probeinterface")
+Shank = get_class("Shank", "ndx-probeinterface")
+ContactTable = get_class("ContactTable", "ndx-probeinterface")
 
 
 # Add custom constructors
 from .io import from_probe, from_probegroup, to_probeinterface
+
 Probe.from_probe = from_probe
 Probe.from_probegroup = from_probegroup
-Probe.to_probeinterface = to_probeinterface
+Probe.to_probeinterface = to_probeinterface

src/pynwb/ndx_probeinterface/io.py

@@ -9,7 +9,6 @@
 }
 inverted_unit_map = {v: k for k, v in unit_map.items()}
 
-shape_words = ['radius', 'width', 'width/height']
 
 def from_probe(probe: Probe):
     """
@@ -19,10 +18,10 @@ def from_probe(probe: Probe):
     ----------
     probe_or_probegroup: Probe or ProbeGroup
         Probe or ProbeGroup to convert to ndx-probeinterface Probe devices
-    
+
     Returns
     -------
-    devices: ndx_probeinterface.Probe 
+    devices: ndx_probeinterface.Probe
         The ndx-probeinterface Probe device
     """
     assert isinstance(probe, Probe)
@@ -50,69 +49,89 @@ def from_probegroup(probegroup: ProbeGroup):
     return devices
 
 
-def to_probeinterface(ndx_Probe)->Probe:
+def to_probeinterface(ndx_probe) -> Probe:
     """
     Construct a probeinterface.Probe from ndx_probeinterface.Probe
 
     Parameters
     ----------
-    ndx_Probe: ndx_probeinterface.Probe
-        ndx_probeinterface.Probe to convert to probeinterface.Probe 
-    
+    ndx_probe: ndx_probeinterface.Probe
+        ndx_probeinterface.Probe to convert to probeinterface.Probe
+
     Returns
     -------
-    Probe: probeinterface.Probe 
+    Probe: probeinterface.Probe
     """
-    ndim = ndx_Probe.ndim
-    unit = inverted_unit_map[ndx_Probe.unit]
-    polygon = ndx_Probe.planar_contour
-    
+    ndim = ndx_probe.ndim
+    unit = inverted_unit_map[ndx_probe.unit]
+    polygon = ndx_probe.planar_contour
+
     positions = []
-    contact_ids = []
     shapes = []
-    shape_params = []
-    shank_ids = []
-    plane_axes = []
-    channel_indices = []
-    for shank in ndx_Probe.shanks.values():
-        positions.append(shank.contact_table['contact_position'][:])
-        contact_ids.append(shank.contact_table['contact_id'][:])
-        shapes.append(shank.contact_table['contact_shape'][:])
-        channel_indices.append(shank.contact_table['device_channel_index'][:])
-        plane_axes.append(shank.contact_table['contact_plane_axes'][:])
-        shank_ids.append([int(shank.shank_id)] * len(shank.contact_table))
-        # WARNING: currently assumes that all the contacts have the same shape
-        shape_word = [shape for shape in shape_words if shape in shank.contact_table[:].columns][0]
-        shape_params.append([{shape_word: val} for val in shank.contact_table[shape_word][:]])
+
+    contact_ids = None
+    shape_params = None
+    shank_ids = None
+    plane_axes = None
+    device_channel_indices = None
+
+    possible_shape_keys = ["radius", "width", "height"]
+    for shank in ndx_probe.shanks.values():
+        positions.append(shank.contact_table["contact_position"][:])
+        shapes.append(shank.contact_table["contact_shape"][:])
+        if "contact_id" in shank.contact_table.colnames:
+            if contact_ids is None:
+                contact_ids = []
+            contact_ids.append(shank.contact_table["contact_id"][:])
+        if "device_channel_index_pi" in shank.contact_table.colnames:
+            if device_channel_indices is None:
+                device_channel_indices = []
+            device_channel_indices.append(shank.contact_table["device_channel_index_pi"][:])
+        if "contact_plane_axes" in shank.contact_table.colnames:
+            if plane_axes is None:
+                plane_axes = []
+            plane_axes.append(shank.contact_table["contact_plane_axes"][:])
+        if shank_ids is None:
+            shank_ids = []
+        shank_ids.append([str(shank.shank_id)] * len(shank.contact_table))
+        for possible_shape_key in possible_shape_keys:
+            if possible_shape_key in shank.contact_table.colnames:
+                if shape_params is None:
+                    shape_params = []
+                shape_params.append([{possible_shape_key: val} for val in shank.contact_table[possible_shape_key][:]])
 
     positions = [item for sublist in positions for item in sublist]
-    contact_ids = [item for sublist in contact_ids for item in sublist]
     shapes = [item for sublist in shapes for item in sublist]
-    plane_axes = [item for sublist in plane_axes for item in sublist]
-    shank_ids = [item for sublist in shank_ids for item in sublist]
-    channel_indices = [item for sublist in channel_indices for item in sublist]
-    shape_params = [item for sublist in shape_params for item in sublist]
 
-    probeinterface_Probe = Probe(ndim=ndim, si_units=unit)
-    probeinterface_Probe.set_contacts(positions=positions,
-                                      shapes=shapes,
-                                      shape_params=shape_params,
-                                      plane_axes=plane_axes,
-                                      shank_ids=shank_ids)
-    probeinterface_Probe.set_contact_ids(contact_ids=contact_ids)
-    probeinterface_Probe.set_device_channel_indices(channel_indices=channel_indices)
+    if contact_ids is not None:
+        contact_ids = [item for sublist in contact_ids for item in sublist]
+    if plane_axes is not None:
+        plane_axes = [item for sublist in plane_axes for item in sublist]
+    if shape_params is not None:
+        shape_params = [item for sublist in shape_params for item in sublist]
+    if shank_ids is not None:
+        shank_ids = [item for sublist in shank_ids for item in sublist]
+    if device_channel_indices is not None:
+        device_channel_indices = [item for sublist in channel_indices for item in sublist]
 
-    probeinterface_Probe.set_planar_contour(polygon)
+    probeinterface_probe = Probe(ndim=ndim, si_units=unit)
+    probeinterface_probe.set_contacts(
+        positions=positions, shapes=shapes, shape_params=shape_params, plane_axes=plane_axes, shank_ids=shank_ids
+    )
+    probeinterface_probe.set_contact_ids(contact_ids=contact_ids)
+    if device_channel_indices is not None:
+        probeinterface_probe.set_device_channel_indices(channel_indices=device_channel_indices)
+    probeinterface_probe.set_planar_contour(polygon)
 
-    return probeinterface_Probe
+    return probeinterface_probe
 
 
 def _single_probe_to_nwb_device(probe: Probe):
     from pynwb import load_namespaces, get_class
 
-    Probe = get_class('Probe', 'ndx-probeinterface')
-    Shank = get_class('Shank', 'ndx-probeinterface')
-    ContactTable = get_class('ContactTable', 'ndx-probeinterface')
+    Probe = get_class("Probe", "ndx-probeinterface")
+    Shank = get_class("Shank", "ndx-probeinterface")
+    ContactTable = get_class("ContactTable", "ndx-probeinterface")
 
     contact_positions = probe.contact_positions
     contact_plane_axes = probe.contact_plane_axes
@@ -150,13 +169,6 @@ def _single_probe_to_nwb_device(probe: Probe):
             name="ContactTable",
             description="Contact Table for ProbeInterface",
         )
-        
-        if probe.device_channel_indices is not None:
-            contact_table.add_column(name="device_channel_index", 
-                                     description="Device channel index")
-        for k in shape_keys:
-            contact_table.add_column(name=k, 
-                                     description="Shape parameter for electrode")
 
         for index in shank_indices:
             kwargs = dict(
@@ -168,12 +180,10 @@ def _single_probe_to_nwb_device(probe: Probe):
             for k in shape_keys:
                 kwargs[k] = contacts_arr[k][index]
             if probe.device_channel_indices is not None:
-                kwargs["device_channel_index"] = probe.device_channel_indices[index]
+                kwargs["device_channel_index_pi"] = probe.device_channel_indices[index]
             contact_table.add_row(kwargs)
         contact_tables.append(contact_table)
-        shank = Shank(name=shank_name,
-                      shank_id=shank_id,
-                      contact_table=contact_table)
+        shank = Shank(name=shank_name, shank_id=shank_id, contact_table=contact_table)
         shanks.append(shank)
 
     if "serial_number" in probe.annotations:
@@ -197,7 +207,7 @@ def _single_probe_to_nwb_device(probe: Probe):
         manufacturer=manufacturer,
         ndim=probe.ndim,
         unit=unit_map[probe.si_units],
-        planar_contour=planar_contour
+        planar_contour=planar_contour,
     )
 
     return probe_device