Merge branch 'master' into zm711-matlabio

Author: apdavison

.github/workflows/black-formatting.yml

@@ -0,0 +1,29 @@
+name: Black formatting
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 12 * * 0"  # Weekly at noon UTC on Sundays
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Check and apply black formatting
+        id: black-check
+        uses: psf/black@stable
+        with:
+            options: "--check --verbose"
+        continue-on-error: true
+
+      - name: Create PR
+        uses: peter-evans/create-pull-request@v5
+        if : ${{ steps.black-check.outcome == 'failure' }}
+        with:
+            commit-message: black formatting
+            title: Black formatting
+            body: Reformatting code with black style
+            branch: black-formatting

.github/workflows/io-test.yml

@@ -46,10 +46,10 @@ jobs:
           key: ${{ runner.os }}-datasets-${{ steps.ephy_testing_data.outputs.dataset_hash }}
           restore-keys: ${{ runner.os }}-datasets-
 
-      - uses: conda-incubator/setup-miniconda@v2.2.0
+      - uses: conda-incubator/setup-miniconda@v3
         with:
           activate-environment: neo-test-env
-          python-version: ${{ matrix.python-version }}
+          python-version: "${{ matrix.python-version }}"
 
       - name: Get current dependencies hash
         id: dependencies
@@ -81,6 +81,11 @@ jobs:
           git config --global user.email "neo_ci@fake_mail.com"
           git config --global user.name "neo CI"
 
+      - name: Python version
+        run: |
+          which python
+          python --version
+
       - name: Install neo including dependencies
         # installation with dependencies is only required if no cache was found
         # restore-key hits should result in `cache-hit` == 'false'

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

@@ -0,0 +1,51 @@
+name: Release to Test PyPI
+
+on:
+  push:
+    tags:
+       - '*'
+jobs:
+  release:
+    environment: TEST_PYPI_API_TOKEN
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Install Tools
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine build
+        pip install .
+    - name: Get the tag version
+      id: get-version
+      run: |
+        echo ${GITHUB_REF#refs/tags/}
+        echo ::set-output name=TAG::${GITHUB_REF#refs/tags/}
+    - name: Test version/tag correspondence
+      id: version-check
+      run: |
+        neo_version=$(python -c "import neo; print(neo.__version__)")
+        tag_version=${{ steps.get-version.outputs.TAG }}
+        echo $neo_version
+        echo $tag_version
+        if [[ $tag_version == $neo_version ]]; then
+            echo "VERSION_TAG_MATCH=true" >> $GITHUB_OUTPUT
+            echo "Version matches tag, proceeding with release to Test PyPI"
+        else
+            echo "VERSION_TAG_MATCH=false" >> $GITHUB_OUTPUT
+            echo "Version does not match tag! Fix this before proceeding."
+            exit 1
+        fi
+    - name: Package and Upload
+      env:
+        STACKMANAGER_VERSION: ${{ github.event.release.tag_name }}
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }}
+      if: ${{ steps.version-check.outputs.VERSION_TAG_MATCH == 'true' }}
+      run: |
+        python -m build --sdist --wheel
+        twine upload --repository testpypi dist/*

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

@@ -0,0 +1,28 @@
+name: Release to PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  release:
+    environment: PYPI_API_TOKEN
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+    - name: Install Tools
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine build
+    - 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/*

doc/source/authors.rst

@@ -60,6 +60,7 @@ and may not be the current affiliation of a contributor.
 * Etienne Combrisson [6]
 * Ben Dichter [24]
 * Elodie Legouée [21]
+* Oliver Kloss [13]
 * Heberto Mayorquin [24]
 * Thomas Perret [25]
 * Kyle Johnsen [26, 27]

neo/core/__init__.py

@@ -10,7 +10,9 @@
 Classes:
 
 .. autoclass:: Block
+.. automethod:: Block.filter
 .. autoclass:: Segment
+.. automethod:: Segment.filter
 .. autoclass:: Group
 
 .. autoclass:: AnalogSignal
@@ -35,6 +37,9 @@
 from neo.core.analogsignal import AnalogSignal
 from neo.core.irregularlysampledsignal import IrregularlySampledSignal
 
+# Import FilterClasses
+from neo.core import filters
+
 from neo.core.event import Event
 from neo.core.epoch import Epoch
 

neo/core/baseneo.py

@@ -154,7 +154,11 @@ def _container_name(class_name):
     referenced by `block.segments`. The attribute name `segments` is
     obtained by calling `_container_name_plural("Segment")`.
     """
-    return _reference_name(class_name) + 's'
+    if "RegionOfInterest" in class_name:
+        # this is a hack, pending a more principled way to handle this
+        return "regionsofinterest"
+    else:
+        return _reference_name(class_name) + 's'
 
 
 class BaseNeo:

neo/core/block.py

@@ -12,7 +12,6 @@
 from neo.core.container import Container, unique_objs
 from neo.core.group import Group
 from neo.core.objectlist import ObjectList
-from neo.core.regionofinterest import RegionOfInterest
 from neo.core.segment import Segment
 
 
@@ -91,7 +90,6 @@ def __init__(self, name=None, description=None, file_origin=None,
         self.index = index
         self._segments = ObjectList(Segment, parent=self)
         self._groups = ObjectList(Group, parent=self)
-        self._regionsofinterest = ObjectList(RegionOfInterest, parent=self)
 
     segments = property(
         fget=lambda self: self._get_object_list("_segments"),
@@ -105,12 +103,6 @@ def __init__(self, name=None, description=None, file_origin=None,
         doc="list of Groups contained in this block"
     )
 
-    regionsofinterest = property(
-        fget=lambda self: self._get_object_list("_regionsofinterest"),
-        fset=lambda self, value: self._set_object_list("_regionsofinterest", value),
-        doc="list of RegionOfInterest objects contained in this block"
-    )
-
     @property
     def data_children_recur(self):
         '''

neo/core/container.py

@@ -6,6 +6,8 @@
 """
 
 from copy import deepcopy
+
+from neo.core import filters
 from neo.core.baseneo import BaseNeo, _reference_name, _container_name
 from neo.core.objectlist import ObjectList
 from neo.core.spiketrain import SpikeTrain
@@ -21,24 +23,25 @@ def unique_objs(objs):
     return [obj for obj in objs
             if id(obj) not in seen and not seen.add(id(obj))]
 
-
 def filterdata(data, targdict=None, objects=None, **kwargs):
     """
     Return a list of the objects in data matching *any* of the search terms
     in either their attributes or annotations.  Search terms can be
     provided as keyword arguments or a dictionary, either as a positional
-    argument after data or to the argument targdict.  targdict can also
-    be a list of dictionaries, in which case the filters are applied
-    sequentially.  If targdict and kwargs are both supplied, the
-    targdict filters are applied first, followed by the kwarg filters.
-    A targdict of None or {} and objects = None corresponds to no filters
-    applied, therefore returning all child objects.
-    Default targdict and objects is None.
+    argument after data or to the argument targdict.
+    A key of a provided dictionary is the name of the requested annotation
+    and the value is a FilterCondition object.
+    E.g.: Equal(x), LessThan(x), InRange(x, y).
 
+    targdict can also
+    be a list of dictionaries, in which case the filters are applied
+    sequentially.
 
-    objects (optional) should be the name of a Neo object type,
-    a neo object class, or a list of one or both of these.  If specified,
-    only these objects will be returned.
+    A list of dictionaries is handled as follows: [ { or } and { or } ]
+    If targdict and kwargs are both supplied, the
+    targdict filters are applied first, followed by the kwarg filters.
+    A targdict of None or {} corresponds to no filters applied, therefore
+    returning all child objects. Default targdict is None.
     """
 
     # if objects are specified, get the classes
@@ -72,20 +75,26 @@ def filterdata(data, targdict=None, objects=None, **kwargs):
     else:
         # do the actual filtering
         results = []
-        for key, value in sorted(targdict.items()):
-            for obj in data:
-                if (hasattr(obj, key) and getattr(obj, key) == value and
-                        all([obj is not res for res in results])):
+        for obj in data:
+            for key, value in sorted(targdict.items()):
+                if hasattr(obj, key) and getattr(obj, key) == value:
                     results.append(obj)
-                elif (key in obj.annotations and obj.annotations[key] == value and
-                          all([obj is not res for res in results])):
+                    break
+                if isinstance(value, filters.FilterCondition) and key in obj.annotations:
+                    if value.evaluate(obj.annotations[key]):
+                        results.append(obj)
+                        break
+                if key in obj.annotations and obj.annotations[key] == value:
                     results.append(obj)
+                    break
+
+    # remove duplicates from results
+    results = list({ id(res): res for res in results }.values())
 
     # keep only objects of the correct classes
     if objects:
         results = [result for result in results if
-                   result.__class__ in objects or
-                   result.__class__.__name__ in objects]
+               result.__class__ in objects or result.__class__.__name__ in objects]
 
     if results and all(isinstance(obj, SpikeTrain) for obj in results):
         return SpikeTrainList(results)
@@ -366,9 +375,17 @@ def filter(self, targdict=None, data=True, container=False, recursive=True,
         Return a list of child objects matching *any* of the search terms
         in either their attributes or annotations.  Search terms can be
         provided as keyword arguments or a dictionary, either as a positional
-        argument after data or to the argument targdict.  targdict can also
+        argument after data or to the argument targdict.
+        A key of a provided dictionary is the name of the requested annotation
+        and the value is a FilterCondition object.
+        E.g.: equal(x), less_than(x), InRange(x, y).
+
+        targdict can also
         be a list of dictionaries, in which case the filters are applied
-        sequentially.  If targdict and kwargs are both supplied, the
+        sequentially.
+
+        A list of dictionaries is handled as follows: [ { or } and { or } ]
+        If targdict and kwargs are both supplied, the
         targdict filters are applied first, followed by the kwarg filters.
         A targdict of None or {} corresponds to no filters applied, therefore
         returning all child objects. Default targdict is None.
@@ -391,6 +408,8 @@ def filter(self, targdict=None, data=True, container=False, recursive=True,
             >>> obj.filter(name="Vm")
             >>> obj.filter(objects=neo.SpikeTrain)
             >>> obj.filter(targdict={'myannotation':3})
+            >>> obj.filter(name=neo.core.filters.Equal(5))
+            >>> obj.filter({'name': neo.core.filters.LessThan(5)})
         """
 
         if isinstance(targdict, str):