diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/emip/__init__.py b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/__init__.py new file mode 100644 index 000000000..214a11c60 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/__init__.py @@ -0,0 +1,4 @@ +"""Connectors for the EMIP eye movements in programming dataset.""" + +# Keep this a regular package, not a namespace package. pkgutil.walk_packages finds the +# connector packages below it only through this __init__.py. diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/__init__.py b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/__init__.py new file mode 100644 index 000000000..cbec0fa20 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/__init__.py @@ -0,0 +1,6 @@ +"""EMIP programmer gaze: fixation sequences while reading code, labelled with programming expertise.""" + +from timenet_connectors.datasets.emip.programmer_gaze.connector import ( + CONNECTOR as CONNECTOR, + EmipProgrammerGazeConnector as EmipProgrammerGazeConnector, +) diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/connector.py b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/connector.py new file mode 100644 index 000000000..e7eb2b501 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/connector.py @@ -0,0 +1,360 @@ +"""The EMIP connector: programmer eye fixations while reading code, labelled with programming expertise. + +EMIP (Bednarik et al., 2020) recorded 216 programmers with an SMI RED250 eye tracker at 250 Hz while +each read two short programs, ``rectangle`` and ``vehicle``, in Java, Python or Scala. The release +holds raw gaze samples, one TSV file per participant, and a questionnaire file with the self-reported +programming expertise of each participant. + +Each code-reading trial becomes one Record of four irregular signals, one value per fixation: the +gaze x and y position on the 1920x1080 screen, the fixation duration, and the mean pupil diameter. +Each Record gets one ClassificationTask whose target is the participant's self-reported +``expertise_programming`` (none, low, medium or high). + +Fixations come from a dispersion-threshold (I-DT) pass over the right-eye samples, as in the +EMIP-Toolkit (Al Madi et al., 2021): a fixation is a run of valid samples whose dispersion +``(max x - min x) + (max y - min y)`` stays within 25 px and that lasts at least 80 ms. A sample is +valid when the tracker marks the right eye valid, the point of regard lies on the screen, and the +pupil diameter is positive. The tracker reports a lost eye (a blink, a look away) as a "valid" +sample at (0, 0) with a zero pupil, so the last two checks drop those. An invalid sample ends the +running fixation, so no fixation spans a blink. +""" + +from collections.abc import Iterator, Mapping +import csv +from dataclasses import dataclass +from pathlib import Path +from typing import Self + +import numpy as np + +from timenet.connectors import BaseConnector +from timenet.dataset import Record, Signal, Source, TimeFDataset +from timenet.errors import TimeNetConnectorError +from timenet.types import Annotation, ClassificationTask, Label, LabelSet, TimeSeriesSpec, ureg +from timenet_connectors.download import ensure_archive + + +EMIP_URL = "https://osf.io/download/3vh28/" +"""``emip_dataset.zip`` in the OSF project https://osf.io/53kts (released September 27, 2018).""" +EMIP_SHA256 = "716c035b6b03d374f2e2531d1744926d0c95b683fa5c312a02d53f5e6a509968" +RELEASE_DIR = "emip_dataset" +METADATA_FILE = "emip_metadata.csv" + +SCREEN_WIDTH_PX = 1920.0 +SCREEN_HEIGHT_PX = 1080.0 +SAMPLE_PERIOD_US = 4_000 +"""The tracker samples at 250 Hz.""" +MAX_DISPERSION_PX = 25.0 +MIN_FIXATION_US = 80_000 + +# Columns of a sample (SMP) line of the SMI export. A message (MSG) line holds its text in column 3. +_TIME, _TYPE = 0, 1 +_MIN_CELLS = 3 +"""Time, type and trial: the cells that every data line has.""" +_MESSAGE = 3 +_R_PUPIL_MM = 12 +_R_POR_X, _R_POR_Y = 23, 24 +_R_VALIDITY = 27 + +TASKS = ("rectangle", "vehicle") +"""The two comprehension programs. Their stimulus images are named ``_[2].jpg``.""" + +EXPERTISE = LabelSet( + name="programming_expertise", + labels=( + Label(name="none", description="The participant reported no programming expertise."), + Label(name="low", description="The participant reported low programming expertise."), + Label(name="medium", description="The participant reported medium programming expertise."), + Label(name="high", description="The participant reported high programming expertise."), + ), +) + +GAZE_X = TimeSeriesSpec(spec_type="gaze_x", name="Gaze X", unit_value=ureg.pixel, dtype="float64") +GAZE_Y = TimeSeriesSpec(spec_type="gaze_y", name="Gaze Y", unit_value=ureg.pixel, dtype="float64") +FIXATION_DURATION = TimeSeriesSpec( + spec_type="fixation_duration", + name="Fixation duration", + unit_value=ureg.millisecond, + dtype="float64", +) +PUPIL_DIAMETER = TimeSeriesSpec( + spec_type="pupil_diameter", + name="Pupil diameter", + unit_value=ureg.millimeter, + dtype="float64", +) + + +@dataclass(frozen=True) +class Fixations: + """The fixations of one trial, as parallel arrays in time order.""" + + onset_us: np.ndarray + """Fixation onset in microseconds since the stimulus appeared.""" + x_px: np.ndarray + y_px: np.ndarray + duration_ms: np.ndarray + pupil_mm: np.ndarray + + def __len__(self) -> int: + return len(self.onset_us) + + +def detect_fixations(samples: list[tuple[int, float, float, float, bool]], onset_us: int) -> Fixations: + """Group gaze samples into fixations with the I-DT algorithm. + + Args: + samples: ``(time_us, x_px, y_px, pupil_mm, valid)`` per sample, in time order. + onset_us: The time the stimulus appeared, the zero of the returned onsets. + + Returns: + The fixations of the samples. + """ + rows: list[tuple[int, float, float, float, float]] = [] + window: list[tuple[int, float, float, float]] = [] + + def flush() -> None: + if not window: + return + duration_us = window[-1][0] - window[0][0] + SAMPLE_PERIOD_US + if duration_us >= MIN_FIXATION_US: + points = np.array(window, dtype=np.float64) + rows.append( + ( + window[0][0] - onset_us, + float(points[:, 1].mean()), + float(points[:, 2].mean()), + duration_us / 1000.0, + float(points[:, 3].mean()), + ) + ) + + min_x = max_x = min_y = max_y = 0.0 + for time_us, x, y, pupil, valid in samples: + if not valid: + flush() + window = [] + continue + if window: + new_min_x, new_max_x = min(min_x, x), max(max_x, x) + new_min_y, new_max_y = min(min_y, y), max(max_y, y) + if (new_max_x - new_min_x) + (new_max_y - new_min_y) <= MAX_DISPERSION_PX: + window.append((time_us, x, y, pupil)) + min_x, max_x, min_y, max_y = new_min_x, new_max_x, new_min_y, new_max_y + continue + flush() + window = [(time_us, x, y, pupil)] + min_x = max_x = x + min_y = max_y = y + flush() + + table = np.array(rows, dtype=np.float64).reshape(-1, 5) + return Fixations( + onset_us=table[:, 0].astype(np.int64), + x_px=table[:, 1], + y_px=table[:, 2], + duration_ms=table[:, 3], + pupil_mm=table[:, 4], + ) + + +def _task_of(stimulus: str) -> str | None: + """Return the comprehension task a stimulus image shows, or ``None`` for any other screen.""" + stem = stimulus.removesuffix(".jpg") + task, _, _ = stem.partition("_") + return task if stimulus.endswith(".jpg") and task in TASKS and "_" in stem else None + + +def read_trials(path: Path) -> Iterator[tuple[str, Fixations]]: + """Read the code-reading trials of one participant's raw gaze file. + + A trial runs from the message that shows a ``rectangle_*`` or ``vehicle_*`` stimulus image to the + next message that shows any image. Mouse-click messages do not end a trial. + + Args: + path: The participant's ``_rawdata.tsv`` file. + + Yields: + The stimulus name (such as ``rectangle_java2``) and the fixations of each trial, in file order. + + Raises: + TimeNetConnectorError: If a sample line is malformed. + """ + stimulus: str | None = None + onset_us = 0 + samples: list[tuple[int, float, float, float, bool]] = [] + with path.open(encoding="latin-1", newline="") as stream: + for number, line in enumerate(stream, start=1): + if line.startswith(("#", "Time")): + continue + cells = line.rstrip("\r\n").split("\t") + if len(cells) < _MIN_CELLS: + continue + if cells[_TYPE] == "MSG": + image = cells[_MESSAGE].split()[-1] if len(cells) > _MESSAGE else "" + if not image.endswith(".jpg"): + continue + if stimulus is not None: + yield stimulus, detect_fixations(samples, onset_us) + stimulus = image.removesuffix(".jpg") if _task_of(image) else None + onset_us = int(cells[_TIME]) + samples = [] + elif cells[_TYPE] == "SMP" and stimulus is not None: + try: + time_us = int(cells[_TIME]) + x, y = float(cells[_R_POR_X]), float(cells[_R_POR_Y]) + pupil = float(cells[_R_PUPIL_MM]) + except (IndexError, ValueError) as exc: + raise TimeNetConnectorError(f"{path.name} line {number}: malformed sample") from exc + valid = ( + cells[_R_VALIDITY] != "-1" + and 0.0 < x <= SCREEN_WIDTH_PX + and 0.0 < y <= SCREEN_HEIGHT_PX + and pupil > 0.0 + ) + samples.append((time_us, x, y, pupil, valid)) + if stimulus is not None: + yield stimulus, detect_fixations(samples, onset_us) + + +@dataclass(frozen=True) +class Participant: + """One participant: the raw gaze file and the questionnaire answers.""" + + participant_id: int + gaze_file: Path + answers: Mapping[str, str] + + @property + def expertise(self) -> str: + """The self-reported programming expertise, a label of :data:`EXPERTISE`. + + Raises: + TimeNetConnectorError: If the answer is not a label of the label set. + """ + value = self.answers.get("expertise_programming", "") + if value not in EXPERTISE.names: + raise TimeNetConnectorError( + f"participant {self.participant_id}: expertise_programming {value!r} is not one of {EXPERTISE.names}" + ) + return value + + def create_record(self, stimulus: str, fixations: Fixations) -> Record: + """Create the Record of one trial, with one irregular Signal per fixation feature. + + Returns: + The Record, not yet added to a dataset. + """ + offsets = fixations.onset_us + signals = ( + Signal.from_irregular(fixations.x_px, time_offsets_us=offsets, spec=GAZE_X, name="x"), + Signal.from_irregular(fixations.y_px, time_offsets_us=offsets, spec=GAZE_Y, name="y"), + Signal.from_irregular( + fixations.duration_ms, time_offsets_us=offsets, spec=FIXATION_DURATION, name="duration" + ), + Signal.from_irregular(fixations.pupil_mm, time_offsets_us=offsets, spec=PUPIL_DIAMETER, name="pupil"), + ) + task = _task_of(f"{stimulus}.jpg") or "" + return Record( + sources=(Source(name="Fixations", signals=signals),), + metadata={ + "participant_id": self.participant_id, + "stimulus": stimulus, + "task_id": task, + "experiment_language": self.answers.get("experiment_language", ""), + }, + annotations=( + Annotation(key="expertise_programming", value=self.expertise), + Annotation(key="expertise_experiment_language", value=self.answers["expertise_experiment_language"]), + Annotation(key="task", value=task), + Annotation(key="trial_order", value=int(self.answers[f"order_{task}"])), + Annotation(key="answer_correct", value=self.answers[f"correct_{task}"] == "1"), + ), + ) + + def create_classification_task(self, record: Record) -> ClassificationTask: + """Create the task that asks for the participant's programming expertise. + + Returns: + The task, not yet added to a dataset. + """ + return ClassificationTask(inputs=(record,), targets=(self.expertise,), label_set=EXPERTISE) + + +def read_participants(root: Path) -> list[Participant]: + """Pair each raw gaze file of the release with its questionnaire row. + + Args: + root: The extracted ``emip_dataset`` directory. + + Returns: + The participants in id order. + + Raises: + TimeNetConnectorError: If a gaze file has no questionnaire row, or the reverse. + """ + with (root / METADATA_FILE).open(encoding="utf-8-sig", newline="") as stream: + answers = {int(row["id"]): row for row in csv.DictReader(stream)} + files = {int(path.name.split("_")[0]): path for path in (root / "rawdata").glob("*_rawdata.tsv")} + if answers.keys() != files.keys(): + raise TimeNetConnectorError( + f"gaze files and questionnaire rows differ: {sorted(answers.keys() ^ files.keys())}" + ) + return [Participant(participant_id=key, gaze_file=files[key], answers=answers[key]) for key in sorted(files)] + + +@dataclass(frozen=True) +class EmipRelease: + """The extracted EMIP release.""" + + root: Path + + @classmethod + def at(cls, extracted: Path) -> Self: + """Locate the release directory inside an extraction directory. + + Returns: + The release. + """ + return cls(root=extracted / RELEASE_DIR) + + +class EmipProgrammerGazeConnector(BaseConnector[EmipRelease]): + """Connector for the EMIP eye movements in programming dataset.""" + + async def download_async(self, cache_dir: Path) -> list[EmipRelease]: # ruff: ignore[no-self-use] + """Download and extract the release archive once. + + Args: + cache_dir: The directory that holds the extracted files. + + Returns: + The extracted release. + """ + extracted = await ensure_archive(EMIP_URL, cache_dir, filename="emip_dataset.zip", sha256=EMIP_SHA256) + return [EmipRelease.at(extracted)] + + def convert(self, raw_refs: list[EmipRelease]) -> TimeFDataset: + """Create one Record and one ClassificationTask for each code-reading trial. + + A trial with no fixation (the tracker lost the eye for the whole trial) has no series to + store, so it gets no Record. + + Args: + raw_refs: The release from :meth:`download_async`. + + Returns: + The populated dataset. + """ + dataset = TimeFDataset(metadata=self.metadata()) + for release in raw_refs: + for participant in read_participants(release.root): + for stimulus, fixations in read_trials(participant.gaze_file): + if len(fixations) == 0: + continue + record = dataset.add_record(record=participant.create_record(stimulus, fixations)) + dataset.add_task(task=participant.create_classification_task(record)) + return dataset + + +CONNECTOR = EmipProgrammerGazeConnector diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/dataset.yaml b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/dataset.yaml new file mode 100644 index 000000000..3ab9a9cd3 --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/dataset.yaml @@ -0,0 +1,34 @@ +# yaml-language-server: $schema=https://docs.timenet.ai/schemas/dataset-card-v1.schema.json +yaml_schema_version: 1 +dataset_id: emip/programmer-gaze +dataset_version: 1.0.0 +name: EMIP Programmer Gaze +description: >- + Eye fixations of 216 programmers while they read two short programs (rectangle and vehicle) to + answer a comprehension question, recorded with an SMI RED250 eye tracker at 250 Hz on a + 1920x1080 screen. Each code-reading trial is one record with four irregular series, + one value per fixation: gaze x and y in pixels, fixation duration in milliseconds, and mean pupil + diameter in millimeters. The connector detects fixations from the raw right-eye samples with a + dispersion-threshold (I-DT) pass: at most 25 px dispersion and at least 80 ms. It drops samples + where the tracker lost the eye, and no fixation spans such a gap. Each record has one + classification task whose target is the participant's self-reported programming expertise + (none 11, low 45, medium 120, high 40 participants). 207 participants read Java, 5 Python and 4 + Scala. Record metadata keeps the participant id, so a split can keep each participant on one + side. Annotations add the expertise in the experiment language, the trial order, and whether + the comprehension answer was correct. The release defines no train/test split. +license: CC-BY-4.0 +source_url: https://osf.io/53kts +citation: >- + Bednarik, R., Busjahn, T., Gibaldi, A., Ahadi, A., et al. (2020). EMIP: The eye movements in + programming dataset. Science of Computer Programming, 198, 102520. + https://doi.org/10.1016/j.scico.2020.102520 +domains: + - general +tags: + - eye-tracking + - gaze + - fixations + - program-comprehension + - expertise + - classification + - irregular diff --git a/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/tests/test_connector.py b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/tests/test_connector.py new file mode 100644 index 000000000..579d6069e --- /dev/null +++ b/packages/timenet-connectors/src/timenet_connectors/datasets/emip/programmer_gaze/tests/test_connector.py @@ -0,0 +1,170 @@ +import csv +from pathlib import Path + +import pytest + +from timenet.errors import TimeNetConnectorError +from timenet.types import ClassificationTask +from timenet.types.text import read_value +from timenet_connectors.datasets.emip.programmer_gaze.connector import ( + EXPERTISE, + MIN_FIXATION_US, + SAMPLE_PERIOD_US, + EmipProgrammerGazeConnector, + EmipRelease, + detect_fixations, +) + + +_HEADER = [ + "Time", "Type", "Trial", "L Raw X [px]", "L Raw Y [px]", "R Raw X [px]", "R Raw Y [px]", + "L Dia X [px]", "L Dia Y [px]", "L Mapped Diameter [mm]", "R Dia X [px]", "R Dia Y [px]", + "R Mapped Diameter [mm]", "L CR1 X [px]", "L CR1 Y [px]", "L CR2 X [px]", "L CR2 Y [px]", + "R CR1 X [px]", "R CR1 Y [px]", "R CR2 X [px]", "R CR2 Y [px]", "L POR X [px]", "L POR Y [px]", + "R POR X [px]", "R POR Y [px]", "Timing", "L Validity", "R Validity", "Pupil Confidence", +] # fmt: skip +_START_US = 1_000_000_000 +_SAMPLES_PER_FIXATION = 30 +"""120 ms at 250 Hz, above the 80 ms minimum.""" + + +def _sample(time_us: int, x: float, y: float, pupil: float = 3.2, validity: str = "1") -> str: + cells = ["0"] * len(_HEADER) + cells[0], cells[1], cells[2] = str(time_us), "SMP", "1" + cells[12], cells[23], cells[24], cells[27] = f"{pupil}", f"{x}", f"{y}", validity + return "\t".join(cells) + + +def _message(time_us: int, text: str) -> str: + return f"{time_us}\tMSG\t1\t# Message: {text}" + + +class _Trace: + """Writes the lines of a raw gaze file with a running clock.""" + + def __init__(self) -> None: + self.now = _START_US + self.lines = ["## [iView]", "## Sample Rate:\t250", "\t".join(_HEADER)] + + def message(self, text: str) -> None: + self.lines.append(_message(self.now, text)) + + def fixation(self, x: float, y: float, *, samples: int = _SAMPLES_PER_FIXATION, pupil: float = 3.2) -> None: + for index in range(samples): + # Jitter of 2 px keeps the run inside the 25 px dispersion. + self.lines.append(_sample(self.now, x + index % 2 * 2, y, pupil)) + self.now += SAMPLE_PERIOD_US + + def blink(self, samples: int = 10) -> None: + for _ in range(samples): + self.lines.append(_sample(self.now, 0.0, 0.0, 0.0)) + self.now += SAMPLE_PERIOD_US + + +def _participant_file(directory: Path, participant_id: int, *, language: str = "java") -> None: + trace = _Trace() + trace.message("instruction_comprehension.jpg") + trace.fixation(960, 540) + trace.message(f"rectangle_{language}.jpg") + trace.fixation(500, 300) + trace.blink() + trace.fixation(700, 300, pupil=3.6) + trace.message("UE-mouseclick left x=479 y=370") + trace.fixation(900, 320) + trace.message("mupliple_choice_rectangle.jpg") + trace.fixation(400, 400) + trace.message(f"vehicle_{language}.jpg") + trace.fixation(600, 600) + trace.message("mupliple_choice_vehicle.jpg") + path = directory / "rawdata" / f"{participant_id}_rawdata.tsv" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("\n".join(trace.lines) + "\n", encoding="latin-1") + + +_ANSWERS = { + 1: {"expertise_programming": "high", "expertise_experiment_language": "medium", "experiment_language": "Java"}, + 2: {"expertise_programming": "none", "expertise_experiment_language": "none", "experiment_language": "Java"}, +} + + +def _write_metadata(directory: Path, answers: dict[int, dict[str, str]]) -> None: + fields = [ + "id", "expertise_programming", "expertise_experiment_language", "experiment_language", + "correct_rectangle", "order_rectangle", "correct_vehicle", "order_vehicle", + ] # fmt: skip + with (directory / "emip_metadata.csv").open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=fields) + writer.writeheader() + for participant_id, row in answers.items(): + writer.writerow( + { + "id": participant_id, + **row, + "correct_rectangle": "1", + "order_rectangle": "2", + "correct_vehicle": "0", + "order_vehicle": "1", + } + ) + + +def _release(tmp_path: Path, answers: dict[int, dict[str, str]] = _ANSWERS) -> EmipRelease: + release = EmipRelease.at(tmp_path) + release.root.mkdir() + _write_metadata(release.root, answers) + for participant_id in answers: + _participant_file(release.root, participant_id) + return release + + +def test_each_code_trial_becomes_a_record_and_a_classification_task(tmp_path): + dataset = EmipProgrammerGazeConnector().convert([_release(tmp_path)]) + tasks = dataset.tasks_of(ClassificationTask) + assert len(tasks) == 4 + stimuli = [(task.inputs[0].metadata["participant_id"], task.inputs[0].metadata["stimulus"]) for task in tasks] + assert stimuli == [(1, "rectangle_java"), (1, "vehicle_java"), (2, "rectangle_java"), (2, "vehicle_java")] + assert all(task.targets is not None for task in tasks) + assert [read_value(task.targets[0]) for task in tasks if task.targets is not None] == [ + "high", + "high", + "none", + "none", + ] + for task in tasks: + assert task.label_set == EXPERTISE + (record,) = task.inputs + assert sorted(signal.name for signal in record.signals) == ["duration", "pupil", "x", "y"] + + +def test_a_trial_runs_to_the_next_image_and_a_blink_splits_fixations(tmp_path): + dataset = EmipProgrammerGazeConnector().convert([_release(tmp_path)]) + record = dataset.tasks_of(ClassificationTask)[0].inputs[0] + values = {signal.name: signal.to_numpy() for signal in record.signals} + x, y, duration, pupil = (values[name] for name in ("x", "y", "duration", "pupil")) + # The blink splits two fixations, and the mouse click does not end the trial. + assert x == pytest.approx([501.0, 701.0, 901.0], abs=0.1) + assert y == pytest.approx([300.0, 300.0, 320.0]) + assert duration == pytest.approx([_SAMPLES_PER_FIXATION * SAMPLE_PERIOD_US / 1000] * 3) + assert pupil == pytest.approx([3.2, 3.6, 3.2]) + + +def test_detect_fixations_drops_runs_shorter_than_the_minimum(): + short = MIN_FIXATION_US // SAMPLE_PERIOD_US - 1 + samples = [(index * SAMPLE_PERIOD_US, 100.0, 100.0, 3.0, True) for index in range(short)] + samples += [(index * SAMPLE_PERIOD_US, 900.0, 900.0, 3.0, True) for index in range(short, short + 25)] + fixations = detect_fixations(samples, onset_us=0) + assert len(fixations) == 1 + assert fixations.onset_us.tolist() == [short * SAMPLE_PERIOD_US] + + +def test_an_unknown_expertise_label_fails(tmp_path): + answers = {1: {**_ANSWERS[1], "expertise_programming": "guru"}} + with pytest.raises(TimeNetConnectorError, match="expertise_programming 'guru'"): + EmipProgrammerGazeConnector().convert([_release(tmp_path, answers)]) + + +def test_a_gaze_file_without_a_questionnaire_row_fails(tmp_path): + release = _release(tmp_path) + _participant_file(release.root, 3) + with pytest.raises(TimeNetConnectorError, match=r"differ: \[3\]"): + EmipProgrammerGazeConnector().convert([release])