Merge upstream main to fix out-of-date branch

Author: natinew77-creator

doc/changes/dev/13915.bugfix.rst

@@ -0,0 +1 @@
+Fix iteration errors in :func:`mne.io.read_raw_nihon` when reading log files, by `Tom Ma`_.

doc/changes/dev/13920.bugfix.rst

@@ -0,0 +1 @@
+Fix :func:`mne.set_eeg_reference` so that passing a list of channel types with ``projection=False`` and ``ref_channels="average"`` now references each channel type independently by default (matching the ``projection=True`` path), by :newcontrib:`Ben Tang`. Previously a single average was computed across the union of the listed types. Pass ``joint=True`` for the previous behavior.

doc/changes/dev/13923.other.rst

@@ -0,0 +1 @@
+Convert non-empty ``drop_log`` entries from ``numpy.str_`` to regular Python strings, by `Clemens Brunner`_.

doc/changes/names.inc

@@ -39,6 +39,7 @@
 .. _Baris Talar: https://github.com/baris-talar
 .. _Beige Jin: https://github.com/BeiGeJin
 .. _Ben Beasley: https://github.com/musicinmybrain
+.. _Ben Tang: https://github.com/bentang18
 .. _Benedikt Ehinger: https://www.benediktehinger.de
 .. _Bhargav Kowshik: https://github.com/bkowshik
 .. _Bradley Voytek: https://github.com/voytek

mne/_fiff/reference.py

@@ -402,8 +402,10 @@ def set_eeg_reference(
         re-referencing the data.
     ref_data : array
         Array of reference data subtracted from EEG channels. This will be
-        ``None`` if ``projection=True``, or if ``ref_channels`` is ``"REST"`` or a
-        :class:`dict`.
+        ``None`` if ``projection=True``, if ``ref_channels`` is ``"REST"`` or a
+        :class:`dict`, or if a per-channel-type average reference was applied
+        (``ref_channels="average"`` with a multi-type ``ch_type`` and
+        ``joint=False``).
     %(set_eeg_reference_see_also_notes)s
     """
     from ..forward import Forward
@@ -465,14 +467,32 @@ def set_eeg_reference(
     del projection  # not used anymore
 
     inst = inst.copy() if copy else inst
-    ch_dict = {**{type_: True for type_ in ch_type}, "meg": False, "ref_meg": False}
-    ch_sel = [inst.ch_names[i] for i in pick_types(inst.info, **ch_dict)]
 
     if ref_channels == "REST":
         _validate_type(forward, Forward, 'forward when ref_channels="REST"')
     else:
         forward = None  # signal to _apply_reference not to do REST
 
+    # When ch_type is a list of >1 types and ref_channels="average", default to
+    # computing one reference per channel type so each subset is referenced
+    # independently. Mirrors the projection=True path. Pass joint=True to keep
+    # the legacy union-of-types behavior.
+    if ref_channels == "average" and len(ch_type) > 1 and not joint:
+        for this_ch_type in ch_type:
+            ch_dict = {this_ch_type: True}
+            ch_sel = [inst.ch_names[i] for i in pick_types(inst.info, **ch_dict)]
+            logger.info(
+                f"Applying average reference for "
+                f"{DEFAULTS['titles'][this_ch_type]} channels."
+            )
+            inst, _ = _apply_reference(
+                inst, ch_sel, ch_sel, forward, ch_type=[this_ch_type]
+            )
+        return inst, None
+
+    ch_dict = {**{type_: True for type_ in ch_type}, "meg": False, "ref_meg": False}
+    ch_sel = [inst.ch_names[i] for i in pick_types(inst.info, **ch_dict)]
+
     if ref_channels in ("average", "REST"):
         logger.info(f"Applying {ref_channels} reference.")
         ref_channels = ch_sel

mne/_fiff/tests/test_reference.py

@@ -284,9 +284,17 @@ def test_set_eeg_reference_ch_type(ch_type, msg, projection):
     else:
         ref_ch = raw.copy().pick(picks=ch_type).ch_names
 
+    # joint=True forces the union-of-types behavior so we can keep validating
+    # ref_data against the joint mean; per-type default is covered by
+    # test_set_eeg_reference_ch_type_list_per_type below.
+    joint = isinstance(ch_type, list) and len(ch_type) > 1
     with catch_logging() as log:
         reref, ref_data = set_eeg_reference(
-            raw.copy(), ch_type=ch_type, projection=projection, verbose=True
+            raw.copy(),
+            ch_type=ch_type,
+            projection=projection,
+            joint=joint,
+            verbose=True,
         )
 
     if not projection:
@@ -304,6 +312,47 @@ def test_set_eeg_reference_ch_type(ch_type, msg, projection):
         set_eeg_reference(raw2, ch_type="auto", projection=projection)
 
 
+@pytest.mark.parametrize("projection", [False, True])
+def test_set_eeg_reference_ch_type_list_per_type(projection):
+    """Test list ch_type defaults to one reference per channel type (gh-13913)."""
+    # Build seeg at +10 uV and ecog at -10 uV (constant). Union mean is zero,
+    # so a single union average reference would leave each subset's original
+    # offset intact. A per-type CAR zeros both subsets.
+    sfreq = 1000.0
+    n = 500
+    data = np.vstack([np.full((4, n), 10.0), np.full((4, n), -10.0)]) * 1e-6
+    ch_names = [f"S{i}" for i in range(4)] + [f"E{i}" for i in range(4)]
+    info = create_info(ch_names, sfreq, ["seeg"] * 4 + ["ecog"] * 4)
+    raw = RawArray(data, info)
+
+    # Default joint=False: per-type reference. ref_data is None.
+    reref, ref_data = set_eeg_reference(
+        raw.copy(),
+        ref_channels="average",
+        ch_type=["seeg", "ecog"],
+        projection=projection,
+    )
+    if projection:
+        reref.apply_proj()
+    assert ref_data is None
+    assert_allclose(reref.get_data(picks="seeg").mean(), 0.0, atol=1e-15)
+    assert_allclose(reref.get_data(picks="ecog").mean(), 0.0, atol=1e-15)
+
+    # joint=True: legacy union-of-types behavior. Union mean is zero, so
+    # neither subset gets zeroed.
+    reref_joint, _ = set_eeg_reference(
+        raw.copy(),
+        ref_channels="average",
+        ch_type=["seeg", "ecog"],
+        projection=projection,
+        joint=True,
+    )
+    if projection:
+        reref_joint.apply_proj()
+    assert_allclose(reref_joint.get_data(picks="seeg").mean(), 10e-6, atol=1e-15)
+    assert_allclose(reref_joint.get_data(picks="ecog").mean(), -10e-6, atol=1e-15)
+
+
 @testing.requires_testing_data
 def test_set_eeg_reference_rest():
     """Test setting a REST reference."""

mne/io/base.py

@@ -562,7 +562,7 @@ def _check_bad_segment(
             )
             for descr in annot.description[overlaps]:
                 if descr.lower().startswith("bad"):
-                    return descr
+                    return str(descr)
         return self._getitem((picks, slice(start, stop)), return_times=False)
 
     @verbose

mne/io/nihon/nihon.py

@@ -289,21 +289,23 @@ def _read_nihon_header(fname):
 
 
 def _read_event_log_block(fid, t_block, version):
+    empty_logs = np.empty(0, dtype="|S45")
+
     fid.seek(0x92 + t_block * 20)
     data = np.fromfile(fid, np.uint32, 1)
     if data.size == 0 or data[0] == 0:
-        return
+        return empty_logs
     t_blk_address = data[0]
 
     fid.seek(t_blk_address + 0x1)
     data = np.fromfile(fid, "|S16", 1).astype("U16")
     if data.size == 0 or data[0] != version:
-        return
+        warn(f"Event log version mismatch: expected '{version}', got '{data}'")
 
     fid.seek(t_blk_address + 0x12)
     data = np.fromfile(fid, np.uint8, 1)
     if data.size == 0:
-        return
+        return empty_logs
     n_logs = data[0]
 
     fid.seek(t_blk_address + 0x14)

mne/tests/test_epochs.py

@@ -482,8 +482,9 @@ def _assert_drop_log_types(drop_log):
     assert all(isinstance(log, tuple) for log in drop_log), (
         "drop_log[ii] should be tuple"
     )
-    assert all(isinstance(s, str) for log in drop_log for s in log), (
-        "drop_log[ii][jj] should be str"
+    # enforce exact built-in str (reject np.str_ and other str subclasses)
+    assert all(type(s) is str for log in drop_log for s in log), (
+        "drop_log[ii][jj] should be built-in str"
     )
 
 
@@ -775,6 +776,7 @@ def test_reject_by_annotations_reject_tmin_reject_tmax():
         epochs = mne.Epochs(
             raw, events, tmin=-1, tmax=1, preload=True, reject_by_annotation=True
         )
+    _assert_drop_log_types(epochs.drop_log)
     assert len(epochs) == 0
 
     # Setting `reject_tmin` to prevent rejection of epoch.
@@ -787,6 +789,7 @@ def test_reject_by_annotations_reject_tmin_reject_tmax():
         preload=True,
         reject_by_annotation=True,
     )
+    _assert_drop_log_types(epochs.drop_log)
     assert len(epochs) == 1
 
     # Same check but bad segment overlapping from 2.5s to 3s: use `reject_tmax`
@@ -800,6 +803,7 @@ def test_reject_by_annotations_reject_tmin_reject_tmax():
         preload=True,
         reject_by_annotation=True,
     )
+    _assert_drop_log_types(epochs.drop_log)
     assert len(epochs) == 1
 
 

mne/utils/docs.py

@@ -717,6 +717,10 @@ def _reflow_param_docstring(docstring, has_first_line=True, width=75):
     .. versionadded:: 0.19
     .. versionchanged:: 1.2
        ``list-of-str`` is now supported with ``projection=True``.
+    .. versionchanged:: 1.13
+       ``list-of-str`` with ``projection=False`` and ``ref_channels="average"``
+       now applies a per-channel-type reference by default (set ``joint=True``
+       for the previous union-of-types behavior).
 """
 
 _ch_type_topomap_base = """\
@@ -2310,11 +2314,16 @@ def _reflow_param_docstring(docstring, has_first_line=True, width=75):
 
 docdict["joint_set_eeg_reference"] = """
 joint : bool
-    How to handle list-of-str ``ch_type``. If False (default), one projector
-    is created per channel type. If True, one projector is created across
-    all channel types. This is only used when ``projection=True``.
+    How to handle list-of-str ``ch_type``. If False (default), the reference is
+    computed per channel type (one projector per type when ``projection=True``;
+    one average reference subtracted per type when ``projection=False`` and
+    ``ref_channels="average"``). If True, a single reference is computed across
+    all listed channel types.
 
     .. versionadded:: 1.2
+    .. versionchanged:: 1.13
+       Now also applies when ``projection=False``. Previously, the
+       ``projection=False`` path silently behaved as if ``joint=True``.
 """
 
 # %%