Format package sources for CI

Author: richrobe

src/carwatch/compliance.py

@@ -576,8 +576,10 @@ def _clear_removed_wide_samples(
         return result
     removed_index = removed.reset_index()[["participant", "day", "scheduled_sample"]]
     if drop_entire_day:
-        for participant, day in removed_index[["participant", "day"]].drop_duplicates().itertuples(
-            index=False
+        for participant, day in (
+            removed_index[["participant", "day"]]
+            .drop_duplicates()
+            .itertuples(index=False)
         ):
             columns = [column for column in result.columns if column[0] == day]
             _clear_wide_values(result, participant, columns)

src/carwatch/example_data.py

@@ -257,7 +257,9 @@ def _participants(n_participants: int, *, prefix: str) -> tuple[str, ...]:
     if not isinstance(prefix, str) or not prefix:
         raise ValueError("'participant_prefix' must be a non-empty string.")
     width = max(2, len(str(n_participants)))
-    return tuple(f"{prefix}{number:0{width}d}" for number in range(1, n_participants + 1))
+    return tuple(
+        f"{prefix}{number:0{width}d}" for number in range(1, n_participants + 1)
+    )
 
 
 def _config_value(
@@ -312,16 +314,16 @@ def _parse_study_config(
         "study_name",
     )
     participant_prefix = _as_non_empty_string(
-        _config_value(
-            config, "participant_prefix", "participantPrefix", default="VP_"
-        ),
+        _config_value(config, "participant_prefix", "participantPrefix", default="VP_"),
         "participant_prefix",
     )
     sample_prefix = _as_non_empty_string(
         _config_value(config, "sample_prefix", "samplePrefix", default="S"),
         "sample_prefix",
     )
-    start_sample = _config_value(config, "start_sample_from_zero", "startSampleFromZero")
+    start_sample = _config_value(
+        config, "start_sample_from_zero", "startSampleFromZero"
+    )
     qr_start_sample = _config_value(config, "SS")
     if qr_start_sample is not None:
         qr_prefix, qr_zero = _parse_qr_start_sample(qr_start_sample)
@@ -363,16 +365,24 @@ def _parse_study_config(
         )
     has_evening_sample = _as_bool(
         _config_value(
-            config, "has_evening_sample", "hasEveningSample", "E", default=bool(absolute_times)
+            config,
+            "has_evening_sample",
+            "hasEveningSample",
+            "E",
+            default=bool(absolute_times),
         ),
         "has_evening_sample",
     )
     check_duplicates = _as_bool(
-        _config_value(config, "check_duplicates", "checkDuplicates", "FD", default=False),
+        _config_value(
+            config, "check_duplicates", "checkDuplicates", "FD", default=False
+        ),
         "check_duplicates",
     )
     enable_manual_scan = _as_bool(
-        _config_value(config, "enable_manual_scan", "enableManualScan", "FM", default=False),
+        _config_value(
+            config, "enable_manual_scan", "enableManualScan", "FM", default=False
+        ),
         "enable_manual_scan",
     )
     configured_participants = _config_value(
@@ -455,7 +465,11 @@ def _decode_qr_config(payload: str) -> dict[str, Any]:
             except ValueError as error:
                 raise ValueError(f"QR field {key!r} must be 0 or 1.") from error
     if "T" in decoded:
-        decoded["T"] = [] if not decoded["T"] else [int(value) for value in decoded["T"].split(",")]
+        decoded["T"] = (
+            []
+            if not decoded["T"]
+            else [int(value) for value in decoded["T"].split(",")]
+        )
     if "A" in decoded:
         decoded["A"] = [] if not decoded["A"] else decoded["A"].split(",")
     return decoded
@@ -475,7 +489,9 @@ def _parse_registrations(
                 "registration_date": "2026-01-04",
             }
         ]
-    if isinstance(registrations, (str, bytes)) or not isinstance(registrations, Sequence):
+    if isinstance(registrations, (str, bytes)) or not isinstance(
+        registrations, Sequence
+    ):
         raise TypeError("'registrations' must be a sequence of mappings.")
     if not registrations:
         raise ValueError("'registrations' must contain at least one registration.")
@@ -509,18 +525,32 @@ def _parse_registrations(
             _config_value(
                 raw_registration,
                 "registration_date",
-                default=(pd.Timestamp("2026-01-04") + pd.Timedelta(days=7 * (number - 1))).date().isoformat(),
+                default=(
+                    pd.Timestamp("2026-01-04") + pd.Timedelta(days=7 * (number - 1))
+                )
+                .date()
+                .isoformat(),
             ),
             f"registrations[{number - 1}].registration_date",
         )
         raw_dates = _config_value(raw_registration, "collection_dates", default=None)
         if raw_dates is None:
             start = pd.Timestamp(date) + pd.Timedelta(days=1)
-            dates = tuple((start + pd.Timedelta(days=day)).date().isoformat() for day in range(study_days))
+            dates = tuple(
+                (start + pd.Timedelta(days=day)).date().isoformat()
+                for day in range(study_days)
+            )
         else:
-            if isinstance(raw_dates, (str, bytes)) or not isinstance(raw_dates, Sequence):
-                raise TypeError(f"registrations[{number - 1}].collection_dates must be a sequence.")
-            dates = tuple(_as_date(value, f"registrations[{number - 1}].collection_dates") for value in raw_dates)
+            if isinstance(raw_dates, (str, bytes)) or not isinstance(
+                raw_dates, Sequence
+            ):
+                raise TypeError(
+                    f"registrations[{number - 1}].collection_dates must be a sequence."
+                )
+            dates = tuple(
+                _as_date(value, f"registrations[{number - 1}].collection_dates")
+                for value in raw_dates
+            )
             if len(dates) != study_days:
                 raise ValueError(
                     f"registrations[{number - 1}].collection_dates has {len(dates)} dates, "
@@ -531,18 +561,28 @@ def _parse_registrations(
             saliva_ids = None
         else:
             if isinstance(raw_ids, (str, bytes)) or not isinstance(raw_ids, Sequence):
-                raise TypeError(f"registrations[{number - 1}].saliva_ids must be a sequence.")
-            saliva_ids = tuple(_as_non_empty_string(value, "saliva_ids") for value in raw_ids)
-            if len(saliva_ids) != sample_count or len(set(saliva_ids)) != len(saliva_ids):
+                raise TypeError(
+                    f"registrations[{number - 1}].saliva_ids must be a sequence."
+                )
+            saliva_ids = tuple(
+                _as_non_empty_string(value, "saliva_ids") for value in raw_ids
+            )
+            if len(saliva_ids) != sample_count or len(set(saliva_ids)) != len(
+                saliva_ids
+            ):
                 raise ValueError(
                     f"registrations[{number - 1}].saliva_ids must contain {sample_count} unique identifiers."
                 )
         condition = _config_value(raw_registration, "condition", default=None)
         if condition is not None:
             condition = _as_non_empty_string(condition, "condition")
-        parsed.append(_Registration(name, study_days, date, dates, saliva_ids, condition))
+        parsed.append(
+            _Registration(name, study_days, date, dates, saliva_ids, condition)
+        )
     if len({registration.study_name for registration in parsed}) != len(parsed):
-        raise ValueError("Registration study_name values must be unique within a synthetic study.")
+        raise ValueError(
+            "Registration study_name values must be unique within a synthetic study."
+        )
     return tuple(parsed)
 
 
@@ -644,7 +684,9 @@ def _as_absolute_schedule(value: Any) -> tuple[str, ...]:
         if isinstance(item, (int, np.integer)):
             item = f"{int(item):04d}"
         if not isinstance(item, str):
-            raise TypeError("'saliva_alarm_times' entries must be strings or HHMM integers.")
+            raise TypeError(
+                "'saliva_alarm_times' entries must be strings or HHMM integers."
+            )
         compact = item.replace(":", "")
         if len(compact) != 4 or not compact.isdigit():
             raise ValueError(f"Invalid fixed saliva alarm time: {item!r}.")
@@ -681,7 +723,12 @@ def _parse_qr_start_sample(value: Any) -> tuple[str, bool]:
 
 def _filename_token(value: Any) -> str:
     text = _as_non_empty_string(value, "filename_token")
-    return "".join(character if character.isalnum() else "-" for character in text).strip("-") or "study"
+    return (
+        "".join(character if character.isalnum() else "-" for character in text).strip(
+            "-"
+        )
+        or "study"
+    )
 
 
 def _timestamp(value: str) -> pd.Timestamp:
@@ -690,7 +737,9 @@ def _timestamp(value: str) -> pd.Timestamp:
 
 def _event(value: pd.Timestamp, action: str, payload: dict[str, object]) -> str:
     milliseconds = int(value.timestamp() * 1_000)
-    return f"{milliseconds};local;{action};{json.dumps(payload, separators=(',', ':'))}\n"
+    return (
+        f"{milliseconds};local;{action};{json.dumps(payload, separators=(',', ':'))}\n"
+    )
 
 
 def _sample_ids(study: _SyntheticStudy, registration: _Registration) -> tuple[str, ...]:
@@ -793,14 +842,16 @@ def _deviation_minutes(
     tolerance = 15.0 if absolute else 5.0
     if absolute:
         lower, upper = (
-            (tolerance + 2, tolerance + 20)
-            if non_compliant
-            else (0, tolerance - 1.0)
+            (tolerance + 2, tolerance + 20) if non_compliant else (0, tolerance - 1.0)
         )
         magnitude = rng.uniform(lower, upper)
         return magnitude if rng.random() >= 0.5 else -magnitude
     if first_relative:
-        return rng.uniform(tolerance + 2, tolerance + 20) if non_compliant else rng.uniform(0, tolerance - 1.0)
+        return (
+            rng.uniform(tolerance + 2, tolerance + 20)
+            if non_compliant
+            else rng.uniform(0, tolerance - 1.0)
+        )
     if relative_interval is None:
         raise RuntimeError("Relative sample deviations require their interval.")
     lower, upper = (
@@ -875,7 +926,9 @@ def _write_study(
         participant_root = logs_root / participant
         participant_root.mkdir()
         canonical_day = 0
-        for registration_number, configuration in enumerate(study.registrations, start=1):
+        for registration_number, configuration in enumerate(
+            study.registrations, start=1
+        ):
             metadata_timestamp = _timestamp(f"{configuration.registration_date} 18:00")
             metadata_file = participant_root / _source_filename(
                 study, participant, metadata_timestamp
@@ -905,7 +958,9 @@ def _write_study(
                 events: list[tuple[pd.Timestamp, str, dict[str, object]]] = []
                 day_key = (participant, registration_number, registration_day)
                 if day_key not in missing_awakenings:
-                    action = "alarm_stop" if rng.random() < 0.35 else "spontaneous_awakening"
+                    action = (
+                        "alarm_stop" if rng.random() < 0.35 else "spontaneous_awakening"
+                    )
                     events.append((awakening, action, {"id": -1}))
                 for position, (sample_id, sampling_time) in enumerate(
                     zip(sample_ids, sample_times, strict=True), start=1
@@ -948,9 +1003,7 @@ def _write_study(
                         "date": collection_date,
                         "awakening_time": awakening.strftime("%H:%M"),
                         **{
-                            f"sampling_time_{position}": sampling_time.strftime(
-                                "%H:%M"
-                            )
+                            f"sampling_time_{position}": sampling_time.strftime("%H:%M")
                             for position, sampling_time in enumerate(
                                 sample_times, start=1
                             )
@@ -1003,9 +1056,7 @@ def _write_cortisol_data(
             for participant in participants:
                 for position, multiplier in enumerate(profile, start=1):
                     condition_multiplier = (
-                        1.12
-                        if condition.casefold() == "challenge"
-                        else 1.0
+                        1.12 if condition.casefold() == "challenge" else 1.0
                     )
                     value = (
                         participant_baselines[participant]
@@ -1128,7 +1179,9 @@ def _write_issue_decisions(
     create_cortisol_data: bool,
     validate: bool,
 ) -> None:
-    folders = {participant: study_root / "logs" / participant for participant in participants}
+    folders = {
+        participant: study_root / "logs" / participant for participant in participants
+    }
     raw_logs, source_audit = io.load_raw_logs_from_participant_folders(
         folders, create_report=True
     )
@@ -1177,7 +1230,9 @@ def _write_issue_decisions(
     if final_report["issues"]["resolution_status"].eq("unresolved").any():
         raise RuntimeError("Final conversion still contains unresolved issues.")
     samples = logs.extract_sample_events_from_summary(final)
-    expected_samples = len(participants) * study.canonical_day_count * study.sample_count
+    expected_samples = (
+        len(participants) * study.canonical_day_count * study.sample_count
+    )
     if len(samples) != expected_samples or samples["sampling_time"].isna().any():
         raise RuntimeError("Final conversion does not contain every expected sample.")
     actual_non_compliant = samples["sample_compliant"].eq(False).sum()
@@ -1189,10 +1244,10 @@ def _write_issue_decisions(
     source_values = set(samples["sampling_time_source"].dropna())
     if not source_values.issubset({"app", "manual_diary"}):
         raise RuntimeError(f"Unexpected sampling-time sources: {source_values}.")
-    if samples["sampling_time_source"].eq("manual_diary").sum() != len(
-        missing_samples
-    ):
-        raise RuntimeError("Manual diary patch count does not match missing raw samples.")
+    if samples["sampling_time_source"].eq("manual_diary").sum() != len(missing_samples):
+        raise RuntimeError(
+            "Manual diary patch count does not match missing raw samples."
+        )
     if create_cortisol_data:
         cortisol = pd.read_csv(study_root / "cortisol.csv").set_index(
             ["participant", "day", "sample_position", "condition"]

src/carwatch/io/_raw_logs.py

@@ -242,7 +242,7 @@ def load_raw_logs_from_participant_folders(
         na_position="last",
     ).reset_index(drop=True)
     audit["raw_event_count"] = pd.array(audit["raw_event_count"], dtype="Int64")
-    #for column in _SOURCE_AUDIT_COLUMNS[:-1]:
+    # for column in _SOURCE_AUDIT_COLUMNS[:-1]:
     #    audit[column] = pd.array(audit[column], dtype="string")
     audit = audit[_SOURCE_AUDIT_COLUMNS]
     return result, audit

src/carwatch/io/_study_manager.py

@@ -424,10 +424,10 @@ def _validate_saved_study_results(data: pd.DataFrame) -> None:
             continue
         day_level = str(sample) == _DAY_SAMPLE
         sample_variable = str(variable) in {
-                *_SAMPLE_VARIABLES,
-                *_COMPLIANCE_SAMPLE_VARIABLES,
-                "sampling_time_source",
-                "sample_position",
+            *_SAMPLE_VARIABLES,
+            *_COMPLIANCE_SAMPLE_VARIABLES,
+            "sampling_time_source",
+            "sample_position",
             "day_expected",
             "day_scanned",
         }

src/carwatch/merge.py

@@ -231,8 +231,8 @@ def _merge_events_into_summary(
 ) -> pd.DataFrame:
     """Place merged long fields back into the canonical wide result schema."""
     events = merged.reset_index()
-    missing_context = events[["participant", "day", "scheduled_sample"]].isna().any(
-        axis=1
+    missing_context = (
+        events[["participant", "day", "scheduled_sample"]].isna().any(axis=1)
     )
     if missing_context.any():
         values = events.loc[
@@ -249,7 +249,10 @@ def _merge_events_into_summary(
         variable for variable in dict.fromkeys(added_variables) if variable in events
     ]
     for variable in available:
-        if variable in {"recorded_sample_in_schedule"} and events[variable].isna().all():
+        if (
+            variable in {"recorded_sample_in_schedule"}
+            and events[variable].isna().all()
+        ):
             continue
         if _is_day_metadata(events, variable):
             _add_day_variable(result, events, variable)
@@ -278,7 +281,9 @@ def _is_day_metadata(events: pd.DataFrame, variable: str) -> bool:
     return bool(counts.le(1).all())
 
 
-def _add_day_variable(result: pd.DataFrame, events: pd.DataFrame, variable: str) -> None:
+def _add_day_variable(
+    result: pd.DataFrame, events: pd.DataFrame, variable: str
+) -> None:
     values = (
         events[["participant", "day", variable]]
         .groupby(["participant", "day"], as_index=False, sort=False)[variable]
@@ -290,9 +295,11 @@ def _add_day_variable(result: pd.DataFrame, events: pd.DataFrame, variable: str)
         result.at[row["participant"], (row["day"], "day", variable)] = row[variable]
 
 
-def _add_sample_variable(result: pd.DataFrame, events: pd.DataFrame, variable: str) -> None:
-    for day, sample in events[["day", "scheduled_sample"]].drop_duplicates().itertuples(
-        index=False
+def _add_sample_variable(
+    result: pd.DataFrame, events: pd.DataFrame, variable: str
+) -> None:
+    for day, sample in (
+        events[["day", "scheduled_sample"]].drop_duplicates().itertuples(index=False)
     ):
         result[(day, sample, variable)] = pd.NA
     for row in events.to_dict(orient="records"):