Merge pull request #18 from SpikeInterface/change-from-functions

Change `from_*` functions

Author: khl02007

.github/workflows/full_tests.yml

@@ -4,15 +4,16 @@ 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']
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
 
     steps:
     - uses: actions/checkout@v3
@@ -27,9 +28,4 @@ jobs:
         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
+        pytest -v

README.md

@@ -9,16 +9,44 @@ pip install ndx_probeinterface
 
 ## Usage
 
-### Going from a `ndx_probeinterface.Probe` object to a `probeinterface.Probe` object 
+### Going from a `probeinterface.Probe`/``ProbeGroup` object to a `ndx_probeinterface.Probe` object 
 ```python
 import ndx_probeinterface
-pi_probe = ndx_probeinterface.to_probeinterface(ndx_probe)
+
+pi_probe = probeinterface.Probe(...)
+pi_probegroup = probeinterface.ProbeGroup()
+
+# from_probeinterface always returns a list of ndx_probeinterface.Probe devices
+ndx_probes1 = ndx_probeinterface.from_probeinterface(pi_probe)
+ndx_probes2 = ndx_probeinterface.from_probeinterface(pi_probegroup)
+
+ndx_probes = ndx_probes1.extend(ndx_probes2)
+
+nwbfile = pynwb.NWBFile(...)
+
+# add Probe as NWB Devices
+for ndx_probe in ndx_probes:
+    nwbfile.add_device(ndx_probe)
 ```
 
-### Going from a `probeinterface.Probe` object to a `ndx_probeinterface.Probe` object 
+### Going from a `ndx_probeinterface.Probe` object to a `probeinterface.Probe` object 
 ```python
 import ndx_probeinterface
-ndx_probe = ndx_probeinterface.from_probe(pi_probe)
+
+# load ndx_probeinterface.Probe objects from NWB file
+io = pynwb.NWBH5IO(file_path, 'r', load_namespaces=True)
+nwbfile = io.read()
+
+ndx_probes = []
+for device in nwbfile:
+    if isinstance(device, ndx_probeinterface.Probe):
+        ndx_probes.append(device)
+
+# convert to probeinterface.Probe objects
+pi_probes = []
+for ndx_probe in ndx_probes:
+    pi_probe = ndx_probeinterface.to_probeinterface(ndx_probe)
+    pi_probes.append(pi_probe)
 ```
 
 ## Future plans

src/pynwb/ndx_probeinterface/__init__.py

@@ -22,8 +22,7 @@
 
 
 # Add custom constructors
-from .io import from_probe, from_probegroup, to_probeinterface
+from .io import from_probeinterface, to_probeinterface
 
-Probe.from_probe = from_probe
-Probe.from_probegroup = from_probegroup
+Probe.from_probeinterface = from_probeinterface
 Probe.to_probeinterface = to_probeinterface

src/pynwb/ndx_probeinterface/io.py

@@ -1,6 +1,7 @@
 from typing import Union, List, Optional
 import numpy as np
 from probeinterface import Probe, ProbeGroup
+from pynwb.file import Device
 
 unit_map = {
     "um": "micrometer",
@@ -10,7 +11,7 @@
 inverted_unit_map = {v: k for k, v in unit_map.items()}
 
 
-def from_probe(probe: Probe):
+def from_probeinterface(probe_or_probegroup: Union[Probe, ProbeGroup]) -> List[Device]:
     """
     Construct ndx-probeinterface Probe devices from a probeinterface.Probe
 
@@ -21,11 +22,18 @@ def from_probe(probe: Probe):
 
     Returns
     -------
-    devices: ndx_probeinterface.Probe
-        The ndx-probeinterface Probe device
+    devices: list
+        The list of ndx-probeinterface Probe devices
     """
-    assert isinstance(probe, Probe)
-    return _single_probe_to_nwb_device(probe)
+    assert isinstance(probe_or_probegroup, (Probe, ProbeGroup)), f"The input must be a Probe or ProbeGroup, not {type(probe_or_probegroup)}"
+    if isinstance(probe_or_probegroup, Probe):
+        probes = [probe_or_probegroup]
+    else:
+        probes = probe_or_probegroup.probes
+    devices = []
+    for probe in probes:
+        devices.append(_single_probe_to_nwb_device(probe))
+    return devices
 
 
 def from_probegroup(probegroup: ProbeGroup):

src/pynwb/tests/test_probe.py

@@ -58,7 +58,8 @@ def test_constructor_from_probe_single_shank(self):
         """Test that the constructor from Probe sets values as expected for single-shank."""
 
         probe = self.probe0
-        device = Probe.from_probe(probe)
+        devices = Probe.from_probeinterface(probe)
+        device = devices[0]
         # assert correct objects
         self.assertIsInstance(device, Device)
         self.assertIsInstance(device, Probe)
@@ -76,7 +77,8 @@ def test_constructor_from_probe_single_shank(self):
         # set channel indices
         device_channel_indices = np.arange(probe.get_contact_count())
         probe.set_device_channel_indices(device_channel_indices)
-        device_w_indices = Probe.from_probe(probe)
+        devices_w_indices = Probe.from_probeinterface(probe)
+        device_w_indices = devices_w_indices[0]
         shank_names = list(device_w_indices.shanks.keys())
         contact_table = device_w_indices.shanks[shank_names[0]].contact_table
         np.testing.assert_array_equal(contact_table["device_channel_index_pi"][:], device_channel_indices)
@@ -85,7 +87,8 @@ def test_constructor_from_probe_multi_shank(self):
         """Test that the constructor from Probe sets values as expected for multi-shank."""
 
         probe = self.probe1
-        device = Probe.from_probe(probe)
+        devices = Probe.from_probeinterface(probe)
+        device = devices[0]
         # assert correct objects
         self.assertIsInstance(device, Device)
         self.assertIsInstance(device, Probe)
@@ -100,7 +103,8 @@ def test_constructor_from_probe_multi_shank(self):
         # set channel indices
         device_channel_indices = np.arange(probe.get_contact_count())
         probe.set_device_channel_indices(device_channel_indices)
-        device_w_indices = Probe.from_probe(probe)
+        devices_w_indices = Probe.from_probeinterface(probe)
+        device_w_indices = devices_w_indices[0]
         for i_s, shank_name in enumerate(shank_names):
             contact_table = device_w_indices.shanks[shank_name].contact_table
             pi_shank = probe.get_shanks()[i_s]
@@ -120,7 +124,7 @@ def test_constructor_from_probegroup(self):
         probegroup = self.probegroup
         global_device_channel_indices = np.arange(probegroup.get_channel_count())
         probegroup.set_global_device_channel_indices(global_device_channel_indices)
-        devices = Probe.from_probegroup(probegroup)
+        devices = Probe.from_probeinterface(probegroup)
         probes = probegroup.probes
         shank_counts = [1, 2]
 
@@ -175,7 +179,8 @@ def tearDown(self):
             remove_test_file(path)
 
     def test_roundtrip_nwb_from_probe_single_shank(self):
-        device = Probe.from_probe(self.probe0)
+        devices = Probe.from_probeinterface(self.probe0)
+        device = devices[0]
         self.nwbfile0.add_device(device)
 
         with NWBHDF5IO(self.path0, mode="w") as io:
@@ -187,7 +192,8 @@ def test_roundtrip_nwb_from_probe_single_shank(self):
             self.assertContainerEqual(device, read_nwbfile.devices[device.name])            
 
     def test_roundtrip_nwb_from_probe_multi_shank(self):
-        device = Probe.from_probe(self.probe1)
+        devices = Probe.from_probeinterface(self.probe1)
+        device = devices[0]
         self.nwbfile1.add_device(device)
 
         with NWBHDF5IO(self.path1, mode="w") as io:
@@ -199,7 +205,7 @@ def test_roundtrip_nwb_from_probe_multi_shank(self):
             self.assertContainerEqual(device, read_nwbfile.devices[device.name])
 
     def test_roundtrip_nwb_from_probegroup(self):
-        devices = Probe.from_probegroup(self.probegroup)
+        devices = Probe.from_probeinterface(self.probegroup)
         for device in devices:
             self.nwbfile2.add_device(device)
 
@@ -213,12 +219,14 @@ def test_roundtrip_nwb_from_probegroup(self):
 
     def test_roundtrip_pi_from_probe_single_shank(self):
         probe_arr = self.probe0.to_numpy()
-        device = Probe.from_probe(self.probe0)
+        devices = Probe.from_probeinterface(self.probe0)
+        device = devices[0]
         np.testing.assert_array_equal(probe_arr, device.to_probeinterface().to_numpy())    
 
     def test_roundtrip_pi_from_probe_multi_shank(self):
         probe_arr = self.probe1.to_numpy()
-        device = Probe.from_probe(self.probe1)
+        devices = Probe.from_probeinterface(self.probe1)
+        device = devices[0]
         np.testing.assert_array_equal(probe_arr, device.to_probeinterface().to_numpy())