physioex 2.0.3__tar.gz → 2.0.4__tar.gz

{physioex-2.0.3 → physioex-2.0.4}/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to PhysioEx are documented here. Versions follow the
 `physioex.__version__` string (read dynamically by the build) and the `v*` git tags
 that publish to PyPI.
 
+## 2.0.4 — 2026-10-16
+
+Data-layer fixes found by an audit of what physioex reads against the raw files of every dataset. Label caches of
+Sleep-EDF, WSC and Alzheimers are recomputed on first use (`LABELS_REVISION` 2, 2 and 3). Cached WSC events are not
+versioned: delete `events/<subject>.json` of the 26 allscore nights whose events changed.
+
+### Fixed
+- **WSC `.allscore.txt`:** labels and events are anchored at `START RECORDING`. A `STAGE - NO STAGE` line timed before it
+  moved the time origin back by hours and shifted every later label (45 of 743 files). Midnight is a backward jump of
+  the clock, `PAUSED` to `RECORDING RESUMED` stretches are removed (the EDF has no samples there), and labels or events
+  past the end of the EDF are dropped. A file without `START RECORDING` yields no labels, as before.
+- **Sleep-EDF:** the hypnogram always runs to 24 h; its tail is cut at the end of the PSG instead of being paired with
+  zero padding (in one night 614 epochs of `Wake`).
+- **Alzheimers:** labels past the end of a truncated EDF are dropped.
+- **MESA:** `*_Off` electrode-status flags (1 Hz) are classified `OTHER`, not EEG/EOG/EMG.
+
+### Added
+- **WSC events from `.sco.txt`** (the 1827 Gamma-system nights; only the 743 Twin-system `.allscore.txt` nights had
+  events). Same event types as the allscore parser. `Scan # x2` counts samples at twice the EDF rate; a few files write
+  the scan with two extra digits (the clock column is used) and 548 write the length ×100 with a negative sign.
+
 ## 2.0.3 — 2026-10-15
 
 CCSHS dataset, opt-in utilities for multi-dataset training, and three data-layer fixes. STAGES and Alzheimers label

{physioex-2.0.3 → physioex-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: physioex
-Version: 2.0.3
+Version: 2.0.4
 Summary: A python package for explainable sleep staging via deep learning
 Project-URL: Homepage, https://github.com/guidogagl/physioex
 Project-URL: Documentation, https://guidogagl.github.io/physioex

physioex-2.0.4/physioex/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.0.4"

{physioex-2.0.3 → physioex-2.0.4}/physioex/data/datasets/alzheimers.py

@@ -42,7 +42,8 @@ class AlzheimersDataset(BasePhysioDataset):
     DATASET_NAME = "alzheimers"
     DATASET_SUBDIR = "AlzheimerData"
     #: 2: labels are indexed by event onset (gaps stay -1); revision-1 caches are compacted and misaligned.
-    LABELS_REVISION = 2
+    #: 3: labels past the end of the EDF are dropped (truncated recordings).
+    LABELS_REVISION = 3
     DEFAULT_EPOCH_LENGTH_SEC = 30.0
 
     # Channel preference lists.
@@ -208,4 +209,10 @@ class AlzheimersDataset(BasePhysioDataset):
         for epoch_idx, stage in rows:
             labels[epoch_idx] = stage
 
-        return labels
+        # Some EDFs are shorter than the annotated night (truncated recordings): labels
+        # past the end of the signal are dropped instead of being paired with zero padding.
+        import pyedflib
+
+        with pyedflib.EdfReader(str(spec.edf_path)) as f:
+            n_signal = int(f.getFileDuration() // self.epoch_length_sec)
+        return labels[:n_signal]

{physioex-2.0.3 → physioex-2.0.4}/physioex/data/datasets/sleepedf.py

@@ -50,6 +50,8 @@ class SleepEDFDataset(BasePhysioDataset):
     """PhysioNet Sleep-EDF Cassette dataset (~153 recordings, ~78 subjects)."""
 
     DATASET_NAME = "sleepedf"
+    #: 2: hypnogram labels are cut at the end of the PSG (the 24 h hypnogram tail is dropped).
+    LABELS_REVISION = 2
     DATASET_SUBDIR = "physionet-sleep-data"
     DEFAULT_EPOCH_LENGTH_SEC = 30.0
 
@@ -190,6 +192,11 @@ class SleepEDFDataset(BasePhysioDataset):
 
         # Total recording span determines number of epochs
         total_sec = max(float(o) + float(d) for o, d in zip(onsets, durations))
+        # The Sleep-EDF hypnograms always run to 24 h (86400 s) while the PSG stops earlier;
+        # the tail is "Sleep stage ?" or, in some nights, "Sleep stage W". Labels past the
+        # end of the signal would be paired with zero padding, so they are dropped here.
+        with pyedflib.EdfReader(str(spec.edf_path)) as g:
+            total_sec = min(total_sec, float(g.getFileDuration()))
         n_epochs = int(total_sec // self.epoch_length_sec)
         labels = np.full(n_epochs, -1, dtype=np.int16)
 

{physioex-2.0.3 → physioex-2.0.4}/physioex/data/datasets/wsc.py

@@ -67,6 +67,8 @@ class WSCDataset(BasePhysioDataset):
     """
 
     DATASET_NAME = "wsc"
+    #: 2: allscore labels anchored at START RECORDING (paused stretches removed), labels cut at the EDF end.
+    LABELS_REVISION = 2
     DATASET_SUBDIR = "wsc"
     DEFAULT_EPOCH_LENGTH_SEC = 30.0
 
@@ -199,11 +201,17 @@ class WSCDataset(BasePhysioDataset):
         path = spec.label_path
         suffix = str(path)
         if suffix.endswith(".allscore.txt"):
-            return self._parse_allscore(path)
+            labels = self._parse_allscore(path)
         elif suffix.endswith(".stg.txt"):
-            return self._parse_stg(path)
+            labels = self._parse_stg(path)
         else:
             return np.array([], dtype=np.int16)
+        # In some nights the scoring runs past the end of the EDF; labels without signal are dropped.
+        import pyedflib
+
+        with pyedflib.EdfReader(str(spec.edf_path)) as f:
+            n_signal = int(f.getFileDuration() // self.epoch_length_sec)
+        return labels[:n_signal]
 
     # ------------------------------------------------------------------
     # .stg.txt parser
@@ -247,6 +255,48 @@ class WSCDataset(BasePhysioDataset):
     # .allscore.txt parser
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _allscore_offsets(lines):
+        """Seconds from "START RECORDING" for every line of an ``.allscore.txt``, ``None`` where unusable.
+
+        Only lines from the START RECORDING line on are timed: some files list a
+        ``STAGE - NO STAGE`` line with a clock time before the recording starts, which
+        used to pull the time origin back by hours and shift every later label.
+        Midnight is detected as a large backward jump of the clock, not by the hour of day.
+        The time between a PAUSED line and the next RECORDING RESUMED line is removed,
+        because the EDF has no samples for it.
+        Returns ``None`` when there is no START RECORDING line.
+        """
+
+        def _clock(line):
+            t = datetime.datetime.strptime(line.split("\t")[0].strip(), "%H:%M:%S.%f")
+            return t.hour * 3600 + t.minute * 60 + t.second + t.microsecond / 1e6
+
+        start_i = next((i for i, ln in enumerate(lines) if "START RECORDING" in ln), None)
+        if start_i is None:
+            return None
+        start_sec = _clock(lines[start_i])
+        offsets = [None] * len(lines)
+        day, prev = 0, start_sec
+        skipped, pause_start = 0.0, None   # the EDF does not contain the paused stretches
+        for i in range(start_i, len(lines)):
+            try:
+                t = _clock(lines[i])
+            except (ValueError, TypeError):
+                continue
+            if t < prev - 6 * 3600:
+                day += 1
+            prev = t
+            raw = day * 86400 + t - start_sec
+            if "RECORDING RESUMED" in lines[i]:
+                if pause_start is not None:
+                    skipped += raw - pause_start
+                    pause_start = None
+            elif "PAUSED" in lines[i] and pause_start is None:
+                pause_start = raw
+            offsets[i] = raw - skipped
+        return offsets
+
     @staticmethod
     def _parse_allscore(path: Path) -> np.ndarray:
         """Parse a WSC ``.allscore.txt`` file.
@@ -261,23 +311,16 @@ class WSCDataset(BasePhysioDataset):
         with open(path, encoding="latin1") as f:
             lines = f.readlines()
 
-        # Find START RECORDING time
-        start_time = None
-        for line in lines:
-            if "START RECORDING" in line:
-                time_str = line.split("\t")[0]
-                start_time = datetime.datetime.strptime(time_str, "%H:%M:%S.%f")
-                break
-
-        if start_time is None:
+        offsets = WSCDataset._allscore_offsets(lines)
+        if offsets is None:
             return np.array([], dtype=np.int16)
 
         stages = []
-        current_time = start_time
+        current = 0.0
         stage = 7  # unscored at the beginning (maps to -1)
 
-        for line in lines:
-            if "STAGE - " not in line:
+        for line, off in zip(lines, offsets):
+            if off is None or "STAGE - " not in line:
                 continue
 
             new_stage_str = line.split("STAGE - ")[-1].strip()
@@ -286,35 +329,20 @@ class WSCDataset(BasePhysioDataset):
                 # Unrecognised stage label -- treat as unscored
                 new_stage = -1
 
-            stage_time_str = line.split("\t")[0]
-            stage_time = datetime.datetime.strptime(stage_time_str, "%H:%M:%S.%f")
-
-            # Handle midnight crossing: hours <= 12 assumed next day
-            if stage_time.hour <= 12:
-                stage_time += datetime.timedelta(days=1)
-
-            # Fill epochs from current_time to stage_time with the previous stage
-            time_passed = stage_time - current_time
-            passed_epochs = int(time_passed.total_seconds() / 30)
+            # Fill epochs from the current stage onset to this one with the previous stage
+            passed_epochs = int((off - current) / 30)
             # Map the initial "unscored" sentinel (7) to -1
             fill_val = -1 if stage == 7 else stage
-            stages.extend([fill_val] * passed_epochs)
+            stages.extend([fill_val] * max(passed_epochs, 0))
 
             stage = new_stage
-            current_time = stage_time
+            current = max(off, current)
 
-        # Handle the tail: last STAGE event to end of file
-        if lines:
-            end_time_str = lines[-1].split("\t")[0]
-            try:
-                end_time = datetime.datetime.strptime(end_time_str, "%H:%M:%S.%f")
-                end_time += datetime.timedelta(days=1)
-                time_passed = end_time - current_time
-                passed_epochs = int(time_passed.total_seconds() / 30)
-                fill_val = -1 if stage == 7 else stage
-                stages.extend([fill_val] * passed_epochs)
-            except ValueError:
-                pass  # malformed last line -- ignore
+        # Tail: last stage event to the last timed line of the file
+        last = max((o for o in offsets if o is not None), default=current)
+        passed_epochs = int((last - current) / 30)
+        fill_val = -1 if stage == 7 else stage
+        stages.extend([fill_val] * max(passed_epochs, 0))
 
         return np.array(stages, dtype=np.int16)
 
@@ -324,11 +352,136 @@ class WSCDataset(BasePhysioDataset):
 
     def _read_subject_events(self, spec):
         """Parse non-stage events from WSC .allscore.txt annotation files."""
-        if spec.label_path is None or not str(spec.label_path).endswith(
-            ".allscore.txt"
-        ):
+        if spec.label_path is None:
             return []
-        return self._parse_allscore_events(spec.label_path)
+        label = str(spec.label_path)
+        events = self._read_subject_events_unfiltered(spec, label)
+        if not events:
+            return events
+        # A few EDFs are cuts of a longer recording: events past the end of the signal are dropped.
+        import pyedflib
+
+        with pyedflib.EdfReader(str(spec.edf_path)) as f:
+            end = float(f.getFileDuration())
+        return [e for e in events if e.onset_sec <= end]
+
+    def _read_subject_events_unfiltered(self, spec, label):
+        if label.endswith(".allscore.txt"):
+            return self._parse_allscore_events(spec.label_path)
+        if label.endswith(".stg.txt"):
+            # Gamma-system nights (2000-2009): events are in the ``.sco.txt`` next to the ``.stg.txt``
+            sco = Path(label[: -len(".stg.txt")] + ".sco.txt")
+            if sco.exists():
+                import pyedflib
+
+                # "Scan # x2" counts samples at twice the EDF rate (200/s for the 100 Hz
+                # files, 256/s for the 128 Hz ones); checked against the clock column.
+                with pyedflib.EdfReader(str(spec.edf_path)) as f:
+                    scans_per_sec = 2.0 * float(f.getSampleFrequency(0))
+                    start = f.getStartdatetime()
+                start_sec = start.hour * 3600 + start.minute * 60 + start.second
+                return self._parse_sco_events(sco, scans_per_sec, start_sec)
+        return []
+
+    @staticmethod
+    def _sco_event(text: str):
+        """Map the ``Marker Text`` of a ``.sco.txt`` row to ``(type, concept)``; ``None`` to skip it."""
+        t = text.strip().lower()
+        if not t:
+            return None
+        if "arousal" in t or t in ("respa", "spona"):
+            if t.startswith("resp"):
+                return "arousal", "Respiratory arousal"
+            if t.startswith("spon"):
+                return "arousal", "Spontaneous arousal"
+            return "arousal", "Arousal"
+        if "hypopnea" in t:
+            return "respiratory", "Central hypopnea" if t.startswith("central") else "Hypopnea"
+        if "apnea" in t or t == "oa":
+            if t.startswith(("obs", "oa")):
+                return "respiratory", "Obstructive apnea"
+            if t.startswith("central"):
+                return "respiratory", "Central apnea"
+            if t.startswith("mixed"):
+                return "respiratory", "Mixed apnea"
+            return "respiratory", "Apnea"
+        if t == "ca":
+            return "respiratory", "Central apnea"
+        if t == "ma":
+            return "respiratory", "Mixed apnea"
+        if t == "sao2":
+            return "desaturation", "SaO2 desaturation"
+        if t.startswith("plm"):
+            return "limb_movement", "Periodic limb movement"
+        if t in ("lma", "lm a"):
+            return "limb_movement", "Limb movement with arousal"
+        if t == "lm":
+            return "limb_movement", "Limb movement"
+        if t.startswith("bad ") or "artifact" in t:
+            return "artifact", text.strip()
+        return None
+
+    @staticmethod
+    def _parse_sco_events(
+        path: Path, scans_per_sec: float = 200.0, start_clock_sec: Optional[float] = None
+    ):
+        """Parse the event rows of a WSC ``.sco.txt`` (Gamma system, 2000-2009).
+
+        Columns: ``Epoch#, Scan # x2, Length (Scanx2), Marker Code, Marker Text,
+        Channel #, Time, Value, Drop, Length``. Onset and duration are scans divided
+        by ``scans_per_sec`` (the length is not measured for limb movements and arousals; a negative
+        length means the value was written 100 times too large). Rows without a marker code are padding.
+
+        A few files write the scan columns with two extra digits. When ``start_clock_sec``
+        (clock time of the EDF start, in seconds) is given, the ``Time`` column is used as a
+        check and, where it disagrees with the scan by more than 5 s, it gives the onset.
+        """
+        from physioex.data.events import SleepEvent
+
+        rate = float(scans_per_sec)
+        events = []
+        with open(path, encoding="latin1") as f:
+            rows = f.read().splitlines()[1:]
+        for line in rows:
+            parts = [x.strip() for x in line.split("\t")]
+            if len(parts) < 7 or not parts[3] or not parts[1]:
+                continue
+            kind = WSCDataset._sco_event(parts[4])
+            if kind is None:
+                continue
+            try:
+                onset = float(parts[1]) / rate
+                length = float(parts[2]) if parts[2] else 0.0
+                # Some files store the length with two extra digits and a negative sign
+                duration = length / rate if length >= 0 else -length / (rate * 100.0)
+            except ValueError:
+                continue
+            if start_clock_sec is not None:
+                try:
+                    h, m, sec = (float(x) for x in parts[6].split(":")[:3] + ["0"] * (3 - len(parts[6].split(":"))))
+                    clock = (h * 3600 + m * 60 + sec - start_clock_sec) % 86400
+                except ValueError:
+                    clock = None
+                if clock is not None and abs(onset - clock) > 5.0:
+                    scale = 100.0 if onset > 50 * max(clock, 1.0) else 1.0   # the "two extra digits" files
+                    onset, duration = clock, duration / scale
+            extra = {}
+            if kind[0] == "desaturation":
+                for key, idx in (("spO2_min", 7), ("spO2_drop", 8)):
+                    try:
+                        extra[key] = float(parts[idx])
+                    except (ValueError, IndexError):
+                        pass
+            events.append(
+                SleepEvent(
+                    type=kind[0],
+                    concept=kind[1],
+                    onset_sec=onset,
+                    duration_sec=duration,
+                    extra=extra,
+                )
+            )
+        return events
 
     @staticmethod
     def _parse_allscore_events(path: Path):
@@ -344,26 +497,10 @@ class WSCDataset(BasePhysioDataset):
         with open(path, encoding="latin1") as f:
             lines = f.readlines()
 
-        # Find START RECORDING time to compute absolute offsets
-        start_time = None
-        for line in lines:
-            if "START RECORDING" in line:
-                time_str = line.split("\t")[0]
-                start_time = datetime.datetime.strptime(time_str, "%H:%M:%S.%f")
-                break
-
-        if start_time is None:
+        offsets = WSCDataset._allscore_offsets(lines)
+        if offsets is None:
             return []
 
-        def _to_seconds(time_str: str) -> float:
-            """Convert a time string to seconds from recording start."""
-            t = datetime.datetime.strptime(time_str.strip(), "%H:%M:%S.%f")
-            # Handle midnight crossing: hours <= 12 assumed next day
-            if t.hour <= 12:
-                t += datetime.timedelta(days=1)
-            diff = t - start_time
-            return diff.total_seconds()
-
         # Patterns for event lines
         dur_pattern = re.compile(r"DUR:\s*([\d.]+)\s*SEC", re.IGNORECASE)
         desat_pattern = re.compile(r"DESAT\s+([\d.]+)\s*%", re.IGNORECASE)
@@ -372,7 +509,9 @@ class WSCDataset(BasePhysioDataset):
         )
 
         events = []
-        for line in lines:
+        for line, onset in zip(lines, offsets):
+            if onset is None:
+                continue
             parts = line.split("\t")
             if len(parts) < 2:
                 continue
@@ -385,14 +524,6 @@ class WSCDataset(BasePhysioDataset):
             if "LIGHTS OFF" in content or "LIGHTS ON" in content:
                 continue
 
-            try:
-                onset = _to_seconds(time_str)
-            except (ValueError, TypeError):
-                continue
-
-            if onset < 0:
-                continue
-
             # Extract duration if present
             dur_match = dur_pattern.search(content)
             duration = float(dur_match.group(1)) if dur_match else 0.0

{physioex-2.0.3 → physioex-2.0.4}/physioex/data/modality.py

@@ -62,6 +62,10 @@ def infer_channel_modality(channel_name: str, hint: Optional[str] = None) -> Mod
     u = n.upper()
     c = re.sub(r"[-_\s.()#/]", "", u)
 
+    # Electrode-off status flags (MESA "EEG1_Off", "EOG-L_Off", ...) are 1 Hz indicators, not signals.
+    if re.search(r"[_\s-]OFF$", u):
+        return ModalityType.OTHER
+
     # ── EEG ──
     if (
         c.startswith("EEG")

{physioex-2.0.3 → physioex-2.0.4}/tests/data/test_modality.py

@@ -115,3 +115,13 @@ def test_empty_channel_name_is_device():
     # Empty/whitespace collapses to "" which the DEVICE bucket claims.
     assert infer_channel_modality("") == ModalityType.DEVICE
     assert infer_channel_modality("   ") == ModalityType.DEVICE
+
+
+@pytest.mark.parametrize("name", ["EEG1_Off", "EEG3_Off", "EOG-L_Off", "EOG-R_Off", "EMG_Off", "EKG_Off"])
+def test_electrode_off_flags_are_other(name):
+    assert infer_channel_modality(name) == ModalityType.OTHER
+
+
+def test_off_rule_does_not_touch_signals():
+    assert infer_channel_modality("EEG1") == ModalityType.EEG
+    assert infer_channel_modality("EOG-L") == ModalityType.EOG

{physioex-2.0.3 → physioex-2.0.4}/tests/test_alzheimers_parkinsons.py

@@ -41,6 +41,8 @@ def make_alzheimers_subject(
     stages: list = None,
     channel_names=None,
     duration_sec: float = 150.0,
+    fs: int = 200,
+    onset_sec: int = 0,
 ):
     """Create a fake Alzheimer's subject: EDF + TSV with comment headers."""
     if channel_names is None:
@@ -58,14 +60,14 @@ def make_alzheimers_subject(
         n_channels=len(channel_names),
         duration_sec=duration_sec,
         channel_names=channel_names,
-        fs_per_channel=[200] * len(channel_names),
+        fs_per_channel=[fs] * len(channel_names),
     )
 
     tsv_path = data_dir / f"{subj_id}_r1_a1.tsv"
-    _write_alzheimers_tsv(tsv_path, stages, subj_id=subj_id)
+    _write_alzheimers_tsv(tsv_path, stages, subj_id=subj_id, onset_sec=onset_sec)
 
 
-def _write_alzheimers_tsv(path: Path, stages: list, subj_id: str = "AD008"):
+def _write_alzheimers_tsv(path: Path, stages: list, subj_id: str = "AD008", onset_sec: int = 0):
     """Write a fake Alzheimer's TSV with comment header lines."""
     with open(path, "w") as f:
         f.write(f"# Source: Alzheimer disease Database UZ Leuven\n")
@@ -75,7 +77,7 @@ def _write_alzheimers_tsv(path: Path, stages: list, subj_id: str = "AD008"):
         f.write(f"# Offset wrt orignal PSG: 900\n")
         f.write(f"#Start & end of sleep annotations: 40830.02- 78564.14 \n")
         f.write(f"\n")  # blank line after comments
-        onset = 40860
+        onset = onset_sec
         for stage in stages:
             end = onset + 30
             f.write(f"{onset}\t{end}\t{stage}\t\n")
@@ -266,9 +268,8 @@ def test_alz_tsv_parsing():
         )
         spec = ds._subjects[0]
         labels = ds._read_subject_labels(spec)
-        # Labels are aligned by absolute onset epoch (onset 40860s / 30s =
-        # epoch 1362): pre-sleep epochs are -1, the 5 scored epochs carry the
-        # stages. Assert the scored (non-masked) sequence, robust to the offset.
+        # Labels are aligned by absolute onset epoch; unscored epochs are -1.
+        # Assert the scored (non-masked) sequence.
         scored = [int(x) for x in labels if x != -1]
         report("ALZ TSV parsing (onset-aligned scored epochs)",
                scored == [0, 1, 2, 3, 4],
@@ -751,3 +752,16 @@ def test_real_data_smoke():
             report(f"{name} channels probe", False, f"SKIP: {e}")
 
 
+
+
+def test_alz_labels_aligned_by_onset_and_cut_at_signal_end():
+    with tempfile.TemporaryDirectory() as data_dir, tempfile.TemporaryDirectory() as cache_dir:
+        data_dir = Path(data_dir)
+        # 1 Hz EDF of 600 s (20 epochs); 5 scored epochs from 480 s (epoch 16): epochs 16..19 fit, epoch 20 is past the signal
+        make_alzheimers_subject(data_dir, "AD001", stages=["Wake", "S1", "S2", "S3", "REM"],
+                                duration_sec=600.0, fs=1, onset_sec=480)
+        ds = AlzheimersDataset(root=str(data_dir), channels=["EEG"], pipelines="raw", sequence_length=1, cache_dir=cache_dir)
+        labels = ds._read_subject_labels(ds._subjects[0])
+        assert len(labels) == 20
+        assert list(labels[:16]) == [-1] * 16
+        assert list(labels[16:]) == [0, 1, 2, 3]

{physioex-2.0.3 → physioex-2.0.4}/tests/test_data_layer_hardening.py

@@ -205,3 +205,14 @@ def test_stages_spo2_artifact_is_its_own_type(tmp_path):
     by = {e.concept: e.type for e in events}
     assert by["SpO2 artifact"] == "artifact"
     assert by["Desaturation"] == "desaturation"
+
+
+def test_label_readers_fixed_in_the_dataset_audit_have_a_new_revision():
+    """Caches written by the old readers (shifted WSC labels, SleepEDF tail, truncated Alzheimer EDFs) are recomputed."""
+    from physioex.data.datasets.alzheimers import AlzheimersDataset
+    from physioex.data.datasets.sleepedf import SleepEDFDataset
+    from physioex.data.datasets.wsc import WSCDataset
+
+    assert SleepEDFDataset.LABELS_REVISION >= 2
+    assert WSCDataset.LABELS_REVISION >= 2
+    assert AlzheimersDataset.LABELS_REVISION >= 3

{physioex-2.0.3 → physioex-2.0.4}/tests/test_phase_b_datasets.py

@@ -236,6 +236,20 @@ def test_sleepedf_label_parsing():
         )
 
 
+def test_sleepedf_labels_cut_at_end_of_signal():
+    """Hypnogram longer than the PSG (Sleep-EDF runs to 24 h): labels stop where the signal stops."""
+    stages = ["Sleep stage W"] * 4 + ["Sleep stage 2"] * 4 + ["Sleep stage ?"] * 3 + ["Sleep stage W"] * 5  # 16 epochs of labels
+    with tempfile.TemporaryDirectory() as data_dir, tempfile.TemporaryDirectory() as cache_dir:
+        data_dir = Path(data_dir)
+        make_sleepedf_subject(data_dir, "SC4001E0-PSG.edf", "SC4001EC-Hypnogram.edf", stages=stages)
+        write_fake_edf(data_dir / "SC4001E0-PSG.edf", n_channels=3, duration_sec=10 * 30.0, fs_per_channel=[100] * 3,
+                       channel_names=["EEG Fpz-Cz", "EOG horizontal", "EMG submental"])  # signal of 10 epochs
+        ds = SleepEDFDataset(root=str(data_dir), channels=["EEG"], pipelines="raw", sequence_length=5, cache_dir=cache_dir)
+        labels = ds._read_subject_labels(ds._subjects[0])
+        assert len(labels) == 10
+        assert list(labels) == [0] * 4 + [2] * 4 + [-1] * 2
+
+
 def test_sleepedf_end_to_end():
     """6. ds[0] returns a valid dict with expected keys and shapes."""
     stages = ["Sleep stage W"] * 5 + ["Sleep stage R"] * 5