ecgdatakit 2.0.0__tar.gz → 2.0.2__tar.gz

{ecgdatakit-2.0.0/src/ecgdatakit.egg-info → ecgdatakit-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecgdatakit
-Version: 2.0.0
+Version: 2.0.2
 Summary: Multi-format ECG file parsing and signal processing library
 Author-email: Ahmad Fall <ahmad.fall@ird.fr>
 Maintainer-email: Ahmad Fall <ahmad.fall@ird.fr>
@@ -94,7 +94,7 @@ Developed at [UMMISCO](https://www.ummisco.fr) / [IRD](https://www.ird.fr) by Ah
 
 ## Features
 
-### Parsing - 12 ECG formats, one unified data model
+### Parsing - 13 ECG formats, one unified data model
 
 Formats are detected from the file content, not the extension.
 
@@ -112,6 +112,7 @@ Formats are detected from the file content, not the extension.
 | MFER | `.mwf`, `.mfer`, `.mfr` | `MFR ` preamble or a chain of known MFER tags |
 | EDAN ARC Holter (experimental) | `patient.hea` + `ecgraw.dat`, `.arc` | `patient.hea` with sibling `ecgraw.dat`, or an `.arc` with a known signature |
 | AliveCor Kardia JSON | `.json` | JSON object with Kardia recording keys (`recordedAt`, `algorithmDetermination`, ...) |
+| XLE ECG (experimental) | `.xle` | `.xle` file with a 256 KiB header holding the patient field labels |
 
 Parsers report what the file stores. They never compute clinical values (intervals, heart rate, QTc, axes, pacemaker status) or invent dates. The only derived values are those a format requires (duration from the sample count, age from the birth date when no age is stored), and a default taken from a format specification is flagged with a warning and in `raw_metadata`.
 

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/README.md

@@ -18,7 +18,7 @@ Developed at [UMMISCO](https://www.ummisco.fr) / [IRD](https://www.ird.fr) by Ah
 
 ## Features
 
-### Parsing - 12 ECG formats, one unified data model
+### Parsing - 13 ECG formats, one unified data model
 
 Formats are detected from the file content, not the extension.
 
@@ -36,6 +36,7 @@ Formats are detected from the file content, not the extension.
 | MFER | `.mwf`, `.mfer`, `.mfr` | `MFR ` preamble or a chain of known MFER tags |
 | EDAN ARC Holter (experimental) | `patient.hea` + `ecgraw.dat`, `.arc` | `patient.hea` with sibling `ecgraw.dat`, or an `.arc` with a known signature |
 | AliveCor Kardia JSON | `.json` | JSON object with Kardia recording keys (`recordedAt`, `algorithmDetermination`, ...) |
+| XLE ECG (experimental) | `.xle` | `.xle` file with a 256 KiB header holding the patient field labels |
 
 Parsers report what the file stores. They never compute clinical values (intervals, heart rate, QTc, axes, pacemaker status) or invent dates. The only derived values are those a format requires (duration from the sample count, age from the birth date when no age is stored), and a default taken from a format specification is flagged with a warning and in `raw_metadata`.
 

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit/__init__.py

@@ -1,6 +1,6 @@
 """ECGDataKit - Multi-format ECG file parsing and processing library."""
 
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 
 from ecgdatakit.models import (
     AcquisitionSetup,

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit/anonymize/formats/__init__.py

@@ -1,6 +1,7 @@
 """Format handlers, one per ecgdatakit parser.
 
-EDAN Holter is not handled: the format is undocumented.
+EDAN Holter is not handled: the format is undocumented. XLE, also
+undocumented, is handled from its reverse-engineered layout.
 """
 
 from __future__ import annotations
@@ -17,13 +18,14 @@ from ecgdatakit.anonymize.formats.mortara_el250 import MortaraHandler
 from ecgdatakit.anonymize.formats.scp_ecg import SCPHandler
 from ecgdatakit.anonymize.formats.sierra_xml import SierraHandler
 from ecgdatakit.anonymize.formats.wfdb import WFDBHandler
+from ecgdatakit.anonymize.formats.xle import XLEHandler
 
 HANDLERS: dict[str, Handler] = {
     h.parser: h
     for h in (
         HL7Handler(), MuseHandler(), SierraHandler(), MortaraHandler(),
         ISHNEHandler(), EDFHandler(), AliveCorHandler(),
-        SCPHandler(), MFERHandler(), WFDBHandler(), DICOMHandler(),
+        SCPHandler(), MFERHandler(), WFDBHandler(), DICOMHandler(), XLEHandler(),
     )
 }
 """Handler by parser class name."""

ecgdatakit-2.0.2/src/ecgdatakit/anonymize/formats/xle.py

@@ -0,0 +1,88 @@
+"""XLE anonymization (experimental format).
+
+The patient fields are text in the header, with the two bytes of each
+16-bit word swapped, each value after its label and ended by a NUL (see
+:mod:`ecgdatakit.parsing.parsers.xle`). The text area is swapped back,
+edited in place and swapped again: given name emptied, family name and
+patient ID replaced by the patient code, names and IDs inside the history
+and comment replaced. Birth date and sex are kept. XLE has no ECG ID.
+
+Every value keeps to its slot: the bytes up to the alignment spaces of the
+next label, and for the comment, its value and the NULs after it. Only the
+header is held in memory: the samples are copied as a stream.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ecgdatakit.anonymize._identity import Identity, Replacer
+from ecgdatakit.anonymize.formats._base import Codes, Handler, Rewrite, Spliced
+from ecgdatakit.parsing.parsers.xle import _FIELDS, _TEXT_END, _fields, _swap16
+
+
+def _slots(text: bytes) -> dict[str, tuple[int, int]]:
+    """Start and end of the bytes each value may use, in the swapped text."""
+    slots: dict[str, tuple[int, int]] = {}
+    for k, (label, off) in enumerate(_FIELDS):
+        start = off + len(label) + 1
+        if text[start:start + 1] == b" ":
+            start += 1
+        if k + 1 < len(_FIELDS):
+            end = _FIELDS[k + 1][1]
+            end -= len(text[start:end]) - len(text[start:end].rstrip(b" "))
+        else:
+            value = text[start:_TEXT_END].split(b"\x00", 1)[0]
+            end = start + len(value)
+            while end < _TEXT_END and text[end] == 0:
+                end += 1
+        slots[label] = (start, max(start, end))
+    return slots
+
+
+class XLEHandler(Handler):
+    """XLE ECG: patient fields in a byte-swapped header text area."""
+
+    parser = "XLEParser"
+
+    def identity(self, path: Path) -> Identity:
+        with open(path, "rb") as f:
+            fields = _fields(f.read(_TEXT_END))
+        identity = Identity()
+        identity.add("first_names", fields["Given name"])
+        identity.add("last_names", fields["Family name"])
+        identity.add("patient_ids", fields["ID"])
+        return identity
+
+    def rewrite(self, path, out_path, identity: Identity, codes: Codes,
+                replacer: Replacer) -> Rewrite:
+        with open(path, "rb") as f:
+            head = bytearray(f.read(_TEXT_END))
+        text = bytearray(_swap16(bytes(head)))
+        values = _fields(bytes(head))
+        result = Rewrite()
+
+        def put(label: str, value: str) -> None:
+            start, end = _slots(bytes(text))[label]
+            raw = value.encode("latin-1", errors="replace")
+            if len(raw) > end - start:
+                result.notes.append(f"{label} cut to its {end - start}-byte field")
+                raw = raw[:end - start]
+            text[start:end] = raw + b"\x00" * (end - start - len(raw))
+
+        if values["Given name"]:
+            put("Given name", "")
+        if values["Family name"] or identity.has_patient:
+            put("Family name", codes.patient)
+        if values["ID"] and values["ID"] not in codes.keep:
+            put("ID", codes.patient)
+        for label in ("History", "Comment"):
+            if values[label]:
+                put(label, replacer.replace(values[label]))
+
+        head[:len(text)] = _swap16(bytes(text))
+        result.outputs[Path(out_path)] = Spliced(bytes(head), Path(path), len(head))
+        return result
+
+    def free_text(self, data: bytes) -> list[str]:
+        return [v for v in _fields(data[:_TEXT_END]).values() if v]

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit/models.py

@@ -969,13 +969,18 @@ class ECGRecord:
         Leads already in physical units keep their sample array (it is
         shared with this record). Leads whose file gives no physical unit
         (uncalibrated counts) are left raw and reported in a warning.
+        When the scale is not stated in the file but set by the parser
+        (``raw_metadata["scale_warning"]``), that warning is issued.
         """
         skipped: list[str] = []
+        converted: list[str] = []
 
         def convert(lead: Lead) -> Lead:
             if lead.is_raw and lead.resolution != 0.0 and not lead.resolution_unit:
                 skipped.append(lead.label)
                 return lead
+            if lead.is_raw:
+                converted.append(lead.label)
             return lead.to_physical()
 
         leads = [convert(lead) for lead in self.leads]
@@ -987,6 +992,9 @@ class ECGRecord:
                 "left as raw counts.",
                 stacklevel=2,
             )
+        scale_warning = self.raw_metadata.get("scale_warning")
+        if converted and scale_warning:
+            warnings.warn(scale_warning, UserWarning, stacklevel=2)
         return self._with_signals(leads, beats, enhanced)
 
     def convert_units(self, target: str) -> ECGRecord:

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit/parsing/parser.py

@@ -231,6 +231,7 @@ class FileParser:
         """
         raw_labels: list[str] = []
         other_units: list[str] = []
+        converted: list[str] = []
         def root(samples: np.ndarray) -> int:
             while isinstance(samples.base, np.ndarray):
                 samples = samples.base
@@ -272,6 +273,7 @@ class FileParser:
                         other_units.append(f"{lead.label} ({lead.resolution_unit})")
                     return lead.to_physical()
                 factor = _TO_UV[unit] / _TO_UV[target]
+                converted.append(lead.label)
                 return dataclasses.replace(
                     lead,
                     samples=apply(lead.samples, lead.resolution * factor, lead.offset * factor),
@@ -306,4 +308,8 @@ class FileParser:
                 f"converted to {target}.",
                 stacklevel=3,
             )
+        # A scale the file does not state, set by the parser (experimental)
+        scale_warning = record.raw_metadata.get("scale_warning")
+        if converted and scale_warning:
+            warnings.warn(scale_warning, UserWarning, stacklevel=3)
         return record

ecgdatakit-2.0.2/src/ecgdatakit/parsing/parsers/xle.py

@@ -0,0 +1,259 @@
+"""XLE ECG parser (experimental).
+
+The manufacturer gives no public description of this format. The layout
+below was worked out from sample files and a third-party reader of the
+format, and has not been confirmed by a specification or by the
+recorder's own software.
+
+* ``.xle`` files with a 256 KiB (``0x40000`` byte) header followed by the
+  signal up to the end of the file.
+* Header: patient fields stored as text with the two bytes of each 16-bit
+  word swapped, each value after its label (``Given name:``,
+  ``Family name:``, ``ID:``, ``Birth Date:``, ``Sex:``, ``History:``,
+  ``Comment:``) at fixed offsets and ended by a NUL. The recording date
+  (``DD.MM.YY`` or ``MM/DD/YY``) and time (``HH:MM``) are text swapped the
+  same way, at fixed offsets. The other header bytes are not decoded.
+* Signal: 8 channels interleaved, signed 16-bit little-endian, 16 bytes
+  per sample instant. Only the low 16 bits of each value are stored, so a
+  value that drifts past +32767 continues from -32768: consecutive
+  differences are taken modulo 65536 to rebuild a continuous signal, the
+  first stored value being the origin. The channels are I, II, then the
+  six chest leads measured against the right arm (``CR1`` to ``CR6``).
+
+Not stored in the file, and taken from outside it:
+
+* the voltage scale: 0.9375 µV per count (15/16), from the third-party
+  reader and not from the manufacturer's documentation. Samples stay raw
+  counts with this resolution, so ``auto_scale`` converts them. The
+  conversion warns that the scale is not validated
+  (``raw_metadata["scale_warning"]``);
+* the sampling rate: 1000 Hz, the rate that matches the sample files
+  (heart cycle intervals, and mains interference at 50 Hz and its
+  harmonics). ``raw_metadata["sampling_rate_stated"]`` is ``False``.
+
+``XLEParser(wilson_correction=True)`` refers the chest leads to Wilson's
+central terminal, ``V = CR - (I + II) / 3``, and names them ``V1`` to
+``V6``, with a warning. Leads III, aVR, aVL and aVF are not stored and not
+computed.
+"""
+
+from __future__ import annotations
+
+import warnings
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import numpy as np
+
+from ecgdatakit.exceptions import CorruptedFileError
+from ecgdatakit.models import ECGRecord, Lead, PatientInfo, SignalCharacteristics
+from ecgdatakit.parsing.helpers import fill_signal_summary
+from ecgdatakit.parsing.parser import Parser
+
+_EXT = ".xle"
+_HEADER_SIZE = 0x40000
+_CHANNELS = 8
+_FRAME = _CHANNELS * 2
+_SAMPLING_RATE = 1000
+_RESOLUTION_UV = 15 / 16  # not validated by the manufacturer's documentation
+_SCALE_WARNING = (
+    "XLE: the voltage scale is not stored in the file. The samples were "
+    "converted with 0.9375 uV per count, a scale from a third-party reader "
+    "that is not validated by the manufacturer's documentation. Converted "
+    "amplitudes are experimental: check them against the recorder's own "
+    "printout before use."
+)
+
+# Offset of each label in the byte-swapped header, and the field it names
+_FIELDS = (
+    ("Given name", 2673),
+    ("Family name", 2712),
+    ("ID", 2761),
+    ("Birth Date", 2793),
+    ("Sex", 2840),
+    ("History", 2876),
+    ("Comment", 2916),
+)
+_TEXT_END = 3200
+_SEX = {"M": "M", "F": "F", "W": "F"}  # W: weiblich
+# Recording date (8 characters) and time (5 characters), byte-swapped
+_DATE_OFFSET = 182972
+_TIME_OFFSET = 182982
+
+
+def _swap16(data: bytes) -> bytes:
+    """*data* with the two bytes of every 16-bit word exchanged."""
+    out = bytearray(data[: len(data) // 2 * 2])
+    out[0::2], out[1::2] = data[1:len(out):2], data[0:len(out):2]
+    return bytes(out)
+
+
+def _has_labels(header: bytes) -> bool:
+    text = _swap16(header[:_TEXT_END])
+    return all(
+        text[off:off + len(label) + 1] == label.encode("ascii") + b":"
+        for label, off in _FIELDS
+    )
+
+
+def _fields(header: bytes) -> dict[str, str]:
+    """Value of every patient field, decoded up to its NUL."""
+    text = _swap16(header[:_TEXT_END])
+    values: dict[str, str] = {}
+    for k, (label, off) in enumerate(_FIELDS):
+        start = off + len(label) + 1
+        end = _FIELDS[k + 1][1] if k + 1 < len(_FIELDS) else _TEXT_END
+        raw = text[start:end].split(b"\x00", 1)[0]
+        values[label] = raw.decode("latin-1").strip()
+    return values
+
+
+def _unwrap(stored: np.ndarray) -> tuple[np.ndarray, int]:
+    """Continuous signal from 16-bit values stored modulo 65536, and the
+    number of wraps undone."""
+    values = stored.astype(np.int64)
+    diff = np.diff(values, axis=0)
+    wrapped = (diff + 32768) % 65536 - 32768
+    wraps = int(np.count_nonzero(wrapped != diff))
+    out = np.empty_like(values)
+    out[:1] = values[:1]
+    np.cumsum(wrapped, axis=0, out=out[1:])
+    out[1:] += values[:1]
+    return out.astype(np.float64), wraps
+
+
+def _recording_date(data: bytes) -> tuple[datetime | None, str, str]:
+    """Recording start, and the date and time text it was read from.
+    Dates with dots are day first, dates with slashes month first."""
+    date = _swap16(data[_DATE_OFFSET:_DATE_OFFSET + 8]).split(b"\x00", 1)[0]
+    time = _swap16(data[_TIME_OFFSET:_TIME_OFFSET + 6])[:5].split(b"\x00", 1)[0]
+    date_text = date.decode("latin-1").strip()
+    time_text = time.decode("latin-1").strip()
+    fmt = "%d.%m.%y" if "." in date_text else "%m/%d/%y"
+    try:
+        start = datetime.strptime(date_text, fmt)
+    except ValueError:
+        return None, date_text, time_text
+    try:
+        clock = datetime.strptime(time_text, "%H:%M")
+        start = start.replace(hour=clock.hour, minute=clock.minute)
+    except ValueError:
+        pass
+    return start, date_text, time_text
+
+
+class XLEParser(Parser):
+    """Parser for ``.xle`` ECG files (experimental, reverse-engineered)."""
+
+    FORMAT_NAME = "XLE ECG"
+    FORMAT_DESCRIPTION = "XLE 8-channel ECG (.xle), experimental"
+    FILE_EXTENSIONS = [_EXT]
+    PRIORITY = 45
+
+    def __init__(self, wilson_correction: bool = False) -> None:
+        """*wilson_correction*: refer the chest leads, stored against the
+        right arm, to Wilson's central terminal (experimental)."""
+        self.wilson_correction = wilson_correction
+
+    @staticmethod
+    def can_parse(file_path: Path, header: bytes) -> bool:
+        path = Path(file_path)
+        if path.suffix.lower() != _EXT or not path.is_file():
+            return False
+        size = path.stat().st_size
+        if size <= _HEADER_SIZE or (size - _HEADER_SIZE) % _FRAME:
+            return False
+        return len(header) >= _TEXT_END and _has_labels(header)
+
+    def parse(self, file_path: Path) -> ECGRecord:
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {path}")
+        warnings.warn(
+            "XLE support is experimental: the format is not documented by its "
+            "manufacturer. The layout, the 1000 Hz sampling rate and the lead "
+            "order were worked out from sample files and a third-party reader, "
+            "and are not validated by the manufacturer's documentation.",
+            UserWarning,
+            stacklevel=2,
+        )
+        data = path.read_bytes()
+        if len(data) <= _HEADER_SIZE or not _has_labels(data[:_TEXT_END]):
+            raise CorruptedFileError(f"Not an XLE ECG file: {path}")
+        frames = (len(data) - _HEADER_SIZE) // _FRAME
+        leftover = len(data) - _HEADER_SIZE - frames * _FRAME
+        stored = np.frombuffer(data, dtype="<i2", count=frames * _CHANNELS,
+                               offset=_HEADER_SIZE).reshape(frames, _CHANNELS)
+        samples, wraps = _unwrap(stored)
+        chest = "CR"
+        if self.wilson_correction:
+            warnings.warn(
+                "Wilson correction applied to the XLE chest leads, "
+                "V = CR - (I + II) / 3: they are stored against the right arm. "
+                "This correction is experimental and not validated by the "
+                "manufacturer's documentation.",
+                UserWarning,
+                stacklevel=2,
+            )
+            samples[:, 2:] -= (samples[:, :1] + samples[:, 1:2]) / 3
+            chest = "V"
+        labels = ["I", "II"] + [f"{chest}{k}" for k in range(1, 7)]
+
+        fields = _fields(data)
+        patient = PatientInfo(
+            patient_id=fields["ID"],
+            first_name=fields["Given name"],
+            last_name=fields["Family name"],
+            clinical_history=fields["History"],
+        )
+        sex = fields["Sex"]
+        if sex:
+            patient.sex = _SEX.get(sex[0].upper(), "U")
+
+        record = ECGRecord(source_format="xle")
+        record.patient = patient
+        start, date_text, time_text = _recording_date(data)
+        record.recording.date = start
+        record.recording.duration = timedelta(seconds=frames / _SAMPLING_RATE)
+        for ch in range(_CHANNELS):
+            record.leads.append(Lead(
+                label=labels[ch],
+                samples=np.ascontiguousarray(samples[:, ch]),
+                sampling_rate=_SAMPLING_RATE,
+                resolution=_RESOLUTION_UV,
+                resolution_unit="uV",
+                is_raw=True,
+            ))
+        record.recording.acquisition.signal = SignalCharacteristics(
+            sampling_rate=_SAMPLING_RATE,
+            bits_per_sample=16,
+            signal_signed=True,
+            number_channels_allocated=_CHANNELS,
+            number_channels_valid=_CHANNELS,
+            data_encoding="int16",
+            compression="none",
+        )
+
+        meta = record.raw_metadata
+        meta["filepath"] = str(path)
+        meta["reverse_engineered"] = True
+        meta["sampling_rate_stated"] = False
+        meta["resolution_stated"] = False
+        meta["scale_warning"] = _SCALE_WARNING
+        meta["lead_order_stated"] = False
+        meta["wilson_correction"] = self.wilson_correction
+        meta["chest_lead_reference"] = (
+            "Wilson central terminal" if self.wilson_correction else "right arm")
+        meta["header_size"] = _HEADER_SIZE
+        meta["samples_per_channel"] = frames
+        meta["wraps_undone"] = wraps
+        meta["recording_date_text"] = date_text
+        meta["recording_time_text"] = time_text
+        meta["birth_date_text"] = fields["Birth Date"]
+        meta["sex_text"] = sex
+        meta["comment"] = fields["Comment"]
+        if leftover:
+            warnings.warn(f"XLE file ends with a partial frame ({leftover} bytes); ignored.",
+                          UserWarning, stacklevel=2)
+        fill_signal_summary(record)
+        return record

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit/processing/nn/weights/deepfade_exp_1_ddp.pt

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: ecgdatakit-2.0.0/src/ecgdatakit/processing/nn/weights/deepfade_exp_1_ddp.pt
+name: ecgdatakit-2.0.2/src/ecgdatakit/processing/nn/weights/deepfade_exp_1_ddp.pt
 size: 64288532 bytes
 sha256: 80be2980936c57c00106dec23c01c9f51089d5dce724d4c99938dad5b2b92f13

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2/src/ecgdatakit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecgdatakit
-Version: 2.0.0
+Version: 2.0.2
 Summary: Multi-format ECG file parsing and signal processing library
 Author-email: Ahmad Fall <ahmad.fall@ird.fr>
 Maintainer-email: Ahmad Fall <ahmad.fall@ird.fr>
@@ -94,7 +94,7 @@ Developed at [UMMISCO](https://www.ummisco.fr) / [IRD](https://www.ird.fr) by Ah
 
 ## Features
 
-### Parsing - 12 ECG formats, one unified data model
+### Parsing - 13 ECG formats, one unified data model
 
 Formats are detected from the file content, not the extension.
 
@@ -112,6 +112,7 @@ Formats are detected from the file content, not the extension.
 | MFER | `.mwf`, `.mfer`, `.mfr` | `MFR ` preamble or a chain of known MFER tags |
 | EDAN ARC Holter (experimental) | `patient.hea` + `ecgraw.dat`, `.arc` | `patient.hea` with sibling `ecgraw.dat`, or an `.arc` with a known signature |
 | AliveCor Kardia JSON | `.json` | JSON object with Kardia recording keys (`recordedAt`, `algorithmDetermination`, ...) |
+| XLE ECG (experimental) | `.xle` | `.xle` file with a 256 KiB header holding the patient field labels |
 
 Parsers report what the file stores. They never compute clinical values (intervals, heart rate, QTc, axes, pacemaker status) or invent dates. The only derived values are those a format requires (duration from the sample count, age from the birth date when no age is stored), and a default taken from a format specification is flagged with a warning and in `raw_metadata`.
 

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/src/ecgdatakit.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ src/ecgdatakit/anonymize/formats/mortara_el250.py
 src/ecgdatakit/anonymize/formats/scp_ecg.py
 src/ecgdatakit/anonymize/formats/sierra_xml.py
 src/ecgdatakit/anonymize/formats/wfdb.py
+src/ecgdatakit/anonymize/formats/xle.py
 src/ecgdatakit/parsing/__init__.py
 src/ecgdatakit/parsing/batch.py
 src/ecgdatakit/parsing/parser.py
@@ -61,6 +62,7 @@ src/ecgdatakit/parsing/parsers/mortara_el250.py
 src/ecgdatakit/parsing/parsers/scp_ecg.py
 src/ecgdatakit/parsing/parsers/sierra_xml.py
 src/ecgdatakit/parsing/parsers/wfdb.py
+src/ecgdatakit/parsing/parsers/xle.py
 src/ecgdatakit/plotting/__init__.py
 src/ecgdatakit/plotting/_core.py
 src/ecgdatakit/plotting/interactive.py
@@ -115,4 +117,5 @@ tests/test_scp_ecg.py
 tests/test_sierra_xml.py
 tests/test_transforms.py
 tests/test_wfdb.py
+tests/test_xle.py
 tests/test_xml_helpers.py

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/tests/test_anonymize.py

@@ -701,7 +701,12 @@ class TestPatientIdField:
 
 
 ALL_FORMATS = ["hl7_aecg_file", "mortara_file", "ishne_file", "edf_file", "scp_ecg_file",
-               "ge_muse_xml_file", "dicom_12lead_file", "mfer_file", "sierra", "wfdb", "alivecor"]
+               "ge_muse_xml_file", "dicom_12lead_file", "mfer_file", "sierra", "wfdb", "alivecor",
+               "xle"]
+
+XLE_VALUES = {"Given name": "John", "Family name": "Doe", "ID": "PX-7781",
+              "Birth Date": "01.02.03", "Sex": "m", "History": "none",
+              "Comment": "Doe follow-up"}
 
 
 def _any_format_file(name: str, request, tmp_path: Path) -> list[Path]:
@@ -723,6 +728,11 @@ def _any_format_file(name: str, request, tmp_path: Path) -> list[Path]:
         (folder / "rec.hea").write_text("rec 1 100 20\nrec.dat 16 200 16 0 0 0 0 II\n"
                                         "# name: John Doe\n# id: PX-4521\n")
         return [folder / "rec.hea", folder / "rec.dat"]
+    if name == "xle":
+        from tests.test_xle import ecg_like, make_xle
+        path = tmp_path / "make" / "rec.xle"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return [make_xle(path, ecg_like(), XLE_VALUES)]
     if name == "alivecor":
         doc = {"id": "rec8f3kd92jd83", "patientID": "PAT7d9s8f7d9s8", "duration": 1000,
                "recordedAt": "2021-04-16T15:19:09+05:30", "algorithmDetermination": "normal",
@@ -739,6 +749,16 @@ def _main_id(files: list[Path]) -> str:
     return _parse(files[0]).patient.patient_id
 
 
+def _readable(path: Path) -> str:
+    """File content as text, plus the header with its 16-bit words swapped
+    back (XLE stores its text that way)."""
+    data = path.read_bytes()
+    n = min(4096, len(data)) // 2 * 2
+    head = bytearray(n)
+    head[0::2], head[1::2] = data[1:n:2], data[0:n:2]
+    return data.decode("latin-1") + "\n" + bytes(head).decode("latin-1")
+
+
 def _has(text: str, value: str) -> bool:
     return bool(re.search(rf"(?<![^\W_]){re.escape(value)}(?![^\W_])", text, re.IGNORECASE))
 
@@ -759,7 +779,7 @@ class TestPatientIdAllFormats:
         with open(dataset / "anonymization_catalog.csv", newline="") as fh:
             [row] = list(csv.DictReader(fh))
         out = dataset / row["anonymized_path"]
-        return patient_id, row, _parse(out), out.read_bytes().decode("latin-1")
+        return patient_id, row, _parse(out), _readable(out)
 
     @pytest.mark.parametrize("name", ALL_FORMATS)
     def test_without_grouping_the_id_is_kept(self, name, request, tmp_path):
@@ -1032,6 +1052,9 @@ def _longer_id(name: str, files: list[Path], pid: str) -> str:
         old = mfer_tlv(0x82, b"MFER001^EXAM9")
         assert old in data
         path.write_bytes(data.replace(old, mfer_tlv(0x82, new_id.encode() + b"^EXAM9")))
+    elif name == "xle":
+        from tests.test_xle import ecg_like, make_xle
+        make_xle(path, ecg_like(), dict(XLE_VALUES, ID=new_id))
     else:  # text formats: XML, WFDB header, JSON
         text = data.decode("utf-8")
         assert pid in text
@@ -1060,7 +1083,7 @@ class TestFolderNameInsideIdAllFormats:
             [row] = list(csv.DictReader(fh))
         out = dataset / row["anonymized_path"]
         after = _parse(out)
-        text = out.read_bytes().decode("latin-1")
+        text = _readable(out)
         assert after.patient.patient_id == row["anonymized_patient_id"]
         assert not _has(text, pid) and "V1" not in after.patient.patient_id
         assert pid not in row["risk_reason"] and new_id not in row["risk_reason"]

{ecgdatakit-2.0.0 → ecgdatakit-2.0.2}/tests/test_parser.py

@@ -41,13 +41,14 @@ class TestFileParserDiscovery:
         assert "DICOMWaveformParser" in names
         assert "EDANARCHolterParser" in names
         assert "AliveCorKardiaParser" in names
+        assert "XLEParser" in names
         # Removed from the release: no public spec and no real sample
         assert "BeneHeartR12Parser" not in names
         assert "GEMAC2000Parser" not in names
 
     def test_discovers_correct_count(self):
-        # 12 parsers (DICOM is discovered even without pydicom installed)
-        assert len(FileParser().parsers) == 12
+        # 13 parsers (DICOM is discovered even without pydicom installed)
+        assert len(FileParser().parsers) == 13
 
     def test_discovers_each_parser_once(self):
         names = [p.__name__ for p in FileParser().parsers]