From 6e5ef75f9c70efb26d569a5ce2de920cb8629e16 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 11 Jun 2026 17:56:11 -0700 Subject: [PATCH 01/28] feat: start adding qc module --- .../qc/__init__.py | 55 ++++ .../qc/_behavior.py | 234 ++++++++++++++ .../qc/_contract_qa.py | 119 ++++++++ src/dynamic_foraging_processing/qc/_plots.py | 286 ++++++++++++++++++ 4 files changed, 694 insertions(+) create mode 100644 src/dynamic_foraging_processing/qc/__init__.py create mode 100644 src/dynamic_foraging_processing/qc/_behavior.py create mode 100644 src/dynamic_foraging_processing/qc/_contract_qa.py create mode 100644 src/dynamic_foraging_processing/qc/_plots.py diff --git a/src/dynamic_foraging_processing/qc/__init__.py b/src/dynamic_foraging_processing/qc/__init__.py new file mode 100644 index 0000000..00f0d45 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/__init__.py @@ -0,0 +1,55 @@ +"""Quality control for dynamic foraging datasets. + +Builds an ``aind_data_schema`` ``QualityControl`` object from primitive behavior +data (lick times, per-trial choices) plus the contraqctor-based contract QA. +""" + +from dynamic_foraging_processing.qc._behavior import ( + calculate_lick_intervals, + compute_rolling_bias, + compute_side_bias, + lick_interval_results, + side_bias_result, +) +from dynamic_foraging_processing.qc._builder import ( + DEFAULT_GROUPING, + behavior_qc_results, + build_quality_control, +) +from dynamic_foraging_processing.qc._contract_qa import ( + contract_qc_metrics, + results_to_metrics, +) +from dynamic_foraging_processing.qc._plots import plot_lick_intervals, plot_side_bias +from dynamic_foraging_processing.qc._result import QCResult, to_metrics +from dynamic_foraging_processing.qc._schema import ( + STATUS_CONVERTER, + bool_to_status, + make_metric, + now_seattle, + now_utc, + to_builtin, +) + +__all__ = [ + "DEFAULT_GROUPING", + "STATUS_CONVERTER", + "QCResult", + "behavior_qc_results", + "bool_to_status", + "build_quality_control", + "calculate_lick_intervals", + "compute_rolling_bias", + "compute_side_bias", + "contract_qc_metrics", + "lick_interval_results", + "make_metric", + "now_seattle", + "now_utc", + "plot_lick_intervals", + "plot_side_bias", + "results_to_metrics", + "side_bias_result", + "to_builtin", + "to_metrics", +] diff --git a/src/dynamic_foraging_processing/qc/_behavior.py b/src/dynamic_foraging_processing/qc/_behavior.py new file mode 100644 index 0000000..c1f7709 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_behavior.py @@ -0,0 +1,234 @@ +"""Behavior QC metrics computed from primitive arrays. + +These functions are agnostic to where the data came from: the caller supplies +plain numpy arrays (lick times, per-trial choice codes), and the functions +return ``QCMetric`` objects. The lick-interval computation is ported from the +old ``aind-dynamic-foraging-qc`` capsule's ``calculate_lick_intervals``, +adapted to take arrays directly instead of a ``behavior.json`` dict. +""" + +import typing as t + +import numpy as np + +from dynamic_foraging_processing.qc._result import QCResult + +#: Reference plot assets shared by the behavior metrics. +SIDE_BIAS_PLOT = "side_bias.png" +LICK_INTERVALS_PLOT = "lick_intervals.png" + +#: ``animal_response`` choice codes. +_LEFT, _RIGHT, _IGNORE = 0, 1, 2 + + +def calculate_lick_intervals( + left_lick_times: np.ndarray, right_lick_times: np.ndarray +) -> t.Dict[str, float]: + """Compute inter-lick-interval percentages from left/right lick times. + + Ported from the old capsule's ``calculate_lick_intervals``; the inputs are + arrays of lick timestamps (seconds) rather than a ``behavior.json`` dict. + + Parameters + ---------- + left_lick_times : numpy.ndarray + Timestamps (s) of left-port licks. + right_lick_times : numpy.ndarray + Timestamps (s) of right-port licks. + + Returns + ------- + dict of str to float + ``LeftLickIntervalPercent``, ``RightLickIntervalPercent``, + ``SameSideIntervalPercent``, ``CrossSideIntervalPercent``, and + ``ArtifactPercent``. + """ + left = np.asarray(left_lick_times, dtype=float) + right = np.asarray(right_lick_times, dtype=float) + same_side_l = np.diff(left) + same_side_r = np.diff(right) + + threshold = 0.05 # time in s to consider as a fast interval + + if (len(left) == 0) and (len(right) == 0): + ArtifactPercent = 0.0 + else: + all_licks = np.sort(np.concatenate([left, right])) + all_diffs = np.sort(np.diff(all_licks)) + ArtifactPercent = float(np.mean(all_diffs < 0.0005) * 100) + + if len(left) > 1: + same_side_l_frac = round(float(np.mean(same_side_l <= threshold)), 4) + LeftLickIntervalPercent = same_side_l_frac * 100 + else: + LeftLickIntervalPercent = 0.0 + + if len(right) > 1: + same_side_r_frac = round(float(np.mean(same_side_r <= threshold)), 4) + RightLickIntervalPercent = same_side_r_frac * 100 + else: + RightLickIntervalPercent = 0.0 + + if len(right) > 0 and len(left) > 0: + same_side_combined = np.concatenate([same_side_l, same_side_r]) + same_side_frac = round( + float(np.sum(same_side_combined <= threshold) / (len(right) + len(left))), 4 + ) + # Pair each lick time with a direction code (+1 right, -1 left), sort by + # time, then look at adjacent pairs that switch sides. + right_dummy = np.ones(np.shape(right)) + left_dummy = np.negative(np.ones(np.shape(left))) + stacked_right = np.column_stack((right_dummy, right)) + stacked_left = np.column_stack((left_dummy, left)) + merged_sorted = np.array( + sorted(np.concatenate((stacked_right, stacked_left)), key=lambda x: x[1]) + ) + diffs = np.diff(merged_sorted[:, 0]) + cross_sides = np.array( + [merged_sorted[i + 1, 1] - merged_sorted[i, 1] for i in np.where(diffs != 0)] + )[0] + cross_side_frac = round( + float(np.sum(cross_sides <= threshold) / (len(left) + len(right))), 4 + ) + CrossSideIntervalPercent = cross_side_frac * 100 + SameSideIntervalPercent = same_side_frac * 100 + else: + CrossSideIntervalPercent = 0.0 + SameSideIntervalPercent = 0.0 + + return { + "LeftLickIntervalPercent": LeftLickIntervalPercent, + "RightLickIntervalPercent": RightLickIntervalPercent, + "SameSideIntervalPercent": SameSideIntervalPercent, + "CrossSideIntervalPercent": CrossSideIntervalPercent, + "ArtifactPercent": ArtifactPercent, + } + + +def compute_side_bias(animal_response: np.ndarray) -> float: + """Compute the average side bias over responded trials. + + Bias is ``mean(is_right) - mean(is_left)`` across trials where the animal + responded (``ignore`` trials excluded). The result lies in ``[-1, +1]``; + positive means a rightward bias. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + + Returns + ------- + float + The average side bias, or ``0.0`` if no trial was responded to. + """ + responses = np.asarray(animal_response) + responded = responses != _IGNORE + if not responded.any(): + return 0.0 + chosen = responses[responded] + return float(np.mean(chosen == _RIGHT) - np.mean(chosen == _LEFT)) + + +def compute_rolling_bias( + animal_response: np.ndarray, window: int = 20 +) -> t.Tuple[np.ndarray, np.ndarray]: + """Compute a trailing-window side-bias trace with a normal-approx CI. + + For each trial, the bias is ``p_right - p_left`` over responded trials in + the trailing ``window``; the confidence band is a 95% normal approximation + for that difference. Replaces the GUI-precomputed ``B_Bias`` / ``B_Bias_CI``. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + window : int, optional + Number of trailing trials in the rolling window. Defaults to ``20``. + + Returns + ------- + tuple of numpy.ndarray + ``(bias, ci)`` where ``bias`` has shape ``(n_trials,)`` and ``ci`` has + shape ``(n_trials, 2)``. Trials with no responses are ``nan``. + """ + responses = np.asarray(animal_response) + n = len(responses) + bias = np.full(n, np.nan) + ci = np.full((n, 2), np.nan) + for i in range(n): + window_slice = responses[max(0, i - window + 1) : i + 1] + chosen = window_slice[window_slice != _IGNORE] + if len(chosen) == 0: + continue + p_right = float(np.mean(chosen == _RIGHT)) + b = 2.0 * p_right - 1.0 # p_right - p_left, since p_left + p_right == 1 + se = 2.0 * np.sqrt(p_right * (1.0 - p_right) / len(chosen)) + bias[i] = b + ci[i] = (b - 1.96 * se, b + 1.96 * se) + return bias, ci + + +def side_bias_result(animal_response: np.ndarray) -> QCResult: + """Build the average-side-bias ``QCResult``. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + + Returns + ------- + QCResult + Passes when ``abs(mean_bias) < 0.5``; tagged ``{"behavior": ...}`` and + referencing ``side_bias.png``. + """ + mean_bias = compute_side_bias(animal_response) + name = "average side bias" + return QCResult( + name=name, + value=mean_bias, + passed=abs(mean_bias) < 0.5, + description="Average side bias over responded trials (right minus left).", + reference=SIDE_BIAS_PLOT, + tags={"behavior": name}, + ) + + +def lick_interval_results( + left_lick_times: np.ndarray, right_lick_times: np.ndarray +) -> t.List[QCResult]: + """Build the four inter-lick-interval ``QCResult`` objects. + + Parameters + ---------- + left_lick_times : numpy.ndarray + Timestamps (s) of left-port licks. + right_lick_times : numpy.ndarray + Timestamps (s) of right-port licks. + + Returns + ------- + list of QCResult + ``Left``/``Right``/``Cross Side`` lick-interval results (pass ``< 10``) + and ``Artifact Percent`` (pass ``< 1``), all referencing + ``lick_intervals.png``. + """ + results = calculate_lick_intervals(left_lick_times, right_lick_times) + specs = [ + ("Left Lick Interval (%)", results["LeftLickIntervalPercent"], 10.0), + ("Right Lick Interval (%)", results["RightLickIntervalPercent"], 10.0), + ("Cross Side Lick Interval (%)", results["CrossSideIntervalPercent"], 10.0), + ("Artifact Percent (%)", results["ArtifactPercent"], 1.0), + ] + return [ + QCResult( + name=name, + value=value, + passed=value < limit, + description=f"{name} of inter-lick intervals; passes when < {limit}.", + reference=LICK_INTERVALS_PLOT, + tags={"behavior": name}, + ) + for name, value, limit in specs + ] diff --git a/src/dynamic_foraging_processing/qc/_contract_qa.py b/src/dynamic_foraging_processing/qc/_contract_qa.py new file mode 100644 index 0000000..af27bf8 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_contract_qa.py @@ -0,0 +1,119 @@ +"""Convert ``contraqctor`` QA runner results into ``QCMetric`` objects. + +The dynamic foraging contract QA (Harp devices, cameras, CSV streams, the data +contract, and task-specific checks) is provided by +``aind_behavior_dynamic_foraging.data_qc.make_qc_runner``. This module runs that +runner over a dataset and maps each ``contraqctor`` ``Result`` onto a schema +``QCMetric``, tagged so the QC portal groups them under ``test_suite``. +""" + +import os +import re +import typing as t + +import matplotlib.figure +from aind_behavior_dynamic_foraging.data_qc.suite import make_qc_runner +from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage +from aind_data_schema_models.modalities import Modality +from contraqctor import contract, qc + +from dynamic_foraging_processing.qc._schema import STATUS_CONVERTER, now_utc, to_builtin + +#: Group value used when a runner result has no group. +NO_GROUP = "NoGroup" + + +def _sanitize(name: str) -> str: + """Make ``name`` safe to use as a filename component.""" + return re.sub(r"[^0-9A-Za-z._-]+", "_", name) + + +def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optional[str]: + """Save a result's figure asset (if any) and return its relative path. + + Parameters + ---------- + result : contraqctor.qc.Result + A single QA result; its ``context["asset"]`` may be a matplotlib figure. + results_folder : str or None + Directory to save figures into. If ``None``, nothing is saved. + + Returns + ------- + str or None + The saved figure's filename, or ``None`` when there is no figure asset + (or no ``results_folder``). + """ + context = result.context + if not isinstance(context, dict): + return None + asset = context.get("asset") + if not isinstance(asset, matplotlib.figure.Figure) or results_folder is None: + return None + filename = f"{_sanitize(result.suite_name)}_{_sanitize(result.test_name)}.png" + asset.savefig(os.path.join(results_folder, filename), dpi=300, bbox_inches="tight") + return filename + + +def results_to_metrics( + results: t.Dict[t.Optional[str], t.List[qc.Result]], + results_folder: t.Optional[str] = None, +) -> t.List[QCMetric]: + """Convert grouped ``contraqctor`` results into ``QCMetric`` objects. + + Parameters + ---------- + results : dict + Mapping of group name to list of ``contraqctor`` ``Result`` objects, as + returned by ``contraqctor.qc.Runner.run_all``. + results_folder : str, optional + Directory to save figure assets into. If ``None``, assets are skipped. + + Returns + ------- + list of QCMetric + One metric per result, tagged ``{"test_suite": suite, suite: group}``. + """ + metrics: t.List[QCMetric] = [] + for group, group_results in results.items(): + group_name = group if group is not None else NO_GROUP + for result in group_results: + status = QCStatus( + evaluator="Automated", + status=STATUS_CONVERTER[result.status], + timestamp=now_utc(), + ) + metrics.append( + QCMetric( + name=f"{result.suite_name}::{result.test_name}", + modality=Modality.BEHAVIOR, + stage=Stage.RAW, + value=to_builtin(result.result), + status_history=[status], + description=f"Test: {result.description} // Message: {result.message}", + reference=_save_asset(result, results_folder), + tags={"test_suite": result.suite_name, result.suite_name: group_name}, + ) + ) + return metrics + + +def contract_qc_metrics( + dataset: contract.Dataset, results_folder: t.Optional[str] = None +) -> t.List[QCMetric]: + """Run the dynamic foraging contract QA over a dataset and convert results. + + Parameters + ---------- + dataset : contraqctor.contract.Dataset + A dynamic foraging dataset (e.g. ``RawDataLoader.dataset``). + results_folder : str, optional + Directory to save figure assets into. If ``None``, assets are skipped. + + Returns + ------- + list of QCMetric + Converted QA metrics for every suite the runner wires up. + """ + runner = make_qc_runner(dataset) + return results_to_metrics(runner.run_all(), results_folder) diff --git a/src/dynamic_foraging_processing/qc/_plots.py b/src/dynamic_foraging_processing/qc/_plots.py new file mode 100644 index 0000000..6b5e4da --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_plots.py @@ -0,0 +1,286 @@ +"""QC plots for the dynamic foraging behavior metrics. + +Ported from the old ``aind-dynamic-foraging-qc`` capsule, adapted to take +primitive arrays / DataFrames instead of a ``behavior.json`` dict. The Agg +backend is forced so the plots render headlessly (no display required). +""" + +import os +import typing as t + +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +from dynamic_foraging_processing.qc._behavior import ( + LICK_INTERVALS_PLOT, + SIDE_BIAS_PLOT, + compute_rolling_bias, +) + +#: Column -> color mapping for the lickspout-position panel. +_LICKSPOUT_COLORS = {"x": "r", "y1": "b", "y2": "lightblue", "y": "b", "z": "m"} + + +def plot_lick_intervals( + left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: str +) -> str: + """Save the five-panel inter-lick-interval histogram. + + Panels: left licks, right licks, left-to-right, right-to-left, all licks. + + Parameters + ---------- + left_lick_times : numpy.ndarray + Timestamps (s) of left-port licks. + right_lick_times : numpy.ndarray + Timestamps (s) of right-port licks. + results_folder : str + Directory to write ``lick_intervals.png`` into. + + Returns + ------- + str + The plot filename (``lick_intervals.png``), for use as a metric + ``reference``. + """ + left = np.asarray(left_lick_times, dtype=float) + right = np.asarray(right_lick_times, dtype=float) + + fig, ax = plt.subplots(1, 5, figsize=(8, 3), sharex=True, sharey=True) + titles = [ + "left licks", + "right licks", + "left to right licks", + "right to left licks", + "all licks", + ] + for axis, title in zip(ax, titles): + axis.set_title(title) + axis.set_xlabel("time (s)") + axis.spines["top"].set_visible(False) + axis.spines["right"].set_visible(False) + ax[0].set_xlim(-0.01, 0.3) + ax[0].set_ylabel("counts") + + bins = np.linspace(-0.3, 0.3, 100) + left_index = np.zeros_like(left) + right_index = np.ones_like(right) + all_licks = np.concatenate((left, right)) + all_index = np.concatenate((left_index, right_index)) + sort_order = np.argsort(all_licks) + all_licks_sorted_diff = np.diff(all_licks[sort_order]) + index_sorted_diff = np.diff(all_index[sort_order]) + left_to_right = all_licks_sorted_diff[index_sorted_diff == 1] + right_to_left = all_licks_sorted_diff[index_sorted_diff == -1] + + ax[0].hist(np.diff(left), bins=bins, color="red", alpha=0.7) + ax[1].hist(np.diff(right), bins=bins, color="blue", alpha=0.7) + ax[2].hist(left_to_right, bins=bins, color="black", alpha=0.7) + ax[3].hist(right_to_left, bins=bins, color="black", alpha=0.7) + ax[4].hist(all_licks_sorted_diff, bins=bins, color="black", alpha=0.7) + + fig.tight_layout() + fig.savefig(os.path.join(results_folder, LICK_INTERVALS_PLOT), dpi=300, bbox_inches="tight") + plt.close(fig) + return LICK_INTERVALS_PLOT + + +def _add_bias_plot(ax: plt.Axes, animal_response: np.ndarray, window: int) -> None: + """Draw the rolling side-bias trace with its confidence band.""" + ax.set_xlabel("Trial #") + ax.set_ylabel("Side Bias") + ax.axhline(+0.7, color="r", linestyle="--") + ax.axhline(-0.7, color="r", linestyle="--") + ax.axhline(0, color="k", linestyle="--") + ax.set_ylim([-1, +1]) + + bias, ci = compute_rolling_bias(animal_response, window=window) + trials = np.arange(len(bias)) + ax.fill_between(trials, ci[:, 0], ci[:, 1], color="gray", alpha=0.5) + ax.plot(trials, bias, "k", linewidth=2) + if len(bias): + ax.set_xlim([0, len(bias)]) + + +def _add_lickspout_position_plot(ax: plt.Axes, stage_positions: t.Optional[pd.DataFrame]) -> None: + """Draw lickspout x/y/z positions relative to session start (mm).""" + ax.set_xlabel("Trial #") + ax.set_ylabel("Lickspout Position \n relative to session start (mm)") + if stage_positions is None or len(stage_positions) == 0: + return + for col in stage_positions.columns: + if col not in _LICKSPOUT_COLORS: + continue + series = stage_positions[col].to_numpy(dtype=float) + ax.plot(series - series[0], _LICKSPOUT_COLORS[col], label=col.upper()) + ax.legend() + + +def _time_to_trial_index(go_cue_times: np.ndarray, times: np.ndarray) -> t.List[int]: + """Map event times to the index of the most recent preceding go cue.""" + go_cue_times = np.asarray(go_cue_times, dtype=float) + trial_index = [] + for event_time in np.asarray(times, dtype=float): + if len(go_cue_times) == 0 or event_time < go_cue_times[0]: + trial_index.append(-1) + else: + trial_index.append(int(np.where(go_cue_times < event_time)[0][-1])) + return trial_index + + +def _add_behavior_plot( + ax: plt.Axes, + animal_response: np.ndarray, + rewarded_history: t.Optional[pd.DataFrame], + auto_water: t.Optional[pd.DataFrame], + manual_left_times: t.Optional[np.ndarray], + manual_right_times: t.Optional[np.ndarray], + go_cue_times: t.Optional[np.ndarray], +) -> None: + """Draw the per-trial behavior raster (choices, rewards, water).""" + choices = np.asarray(animal_response) + ax.vlines(np.where(choices == 1)[0], 0.8, 1, linewidth=1, color="gray", label="Choice") + ax.vlines(np.where(choices == 0)[0], 0, 0.2, linewidth=1, color="gray") + ax.vlines(np.where(choices == 2)[0], 0.4, 0.6, linewidth=1, color="darkviolet", label="ignore") + + if rewarded_history is not None: + left_rewards = np.where(rewarded_history["left"].to_numpy())[0] + right_rewards = np.where(rewarded_history["right"].to_numpy())[0] + ax.vlines(left_rewards, -0.2, 0, linewidth=1, color="black", label="Earned Water") + ax.vlines(right_rewards, 1, 1.2, linewidth=1, color="black") + + if manual_right_times is not None and go_cue_times is not None: + ax.vlines( + _time_to_trial_index(go_cue_times, manual_right_times), + 1.2, + 1.4, + linewidth=1, + color="blue", + label="Manual Water", + ) + if manual_left_times is not None and go_cue_times is not None: + ax.vlines( + _time_to_trial_index(go_cue_times, manual_left_times), + -0.4, + -0.2, + linewidth=1, + color="blue", + ) + + if auto_water is not None: + ax.vlines( + np.where(auto_water["right"].to_numpy() == 1)[0], + 1.2, + 1.4, + linewidth=1, + color="cyan", + label="Auto Water", + ) + ax.vlines( + np.where(auto_water["left"].to_numpy() == 1)[0], -0.4, -0.2, linewidth=1, color="cyan" + ) + + ax.set_ylim([-0.4, 1.4]) + ax.set_xlim([0, len(choices)]) + ax.set_xlabel("Trial #") + ax.set_yticks( + [-0.3, -0.1, 0.1, 0.5, 0.9, 1.1, 1.3], + labels=[ + "L Auto Water", + "L Reward", + "L Choice", + "Ignore", + "R Choice", + "R Reward", + "R Auto Water", + ], + ) + + +def _add_reward_probabilities( + ax: plt.Axes, + reward_probability_left: t.Optional[np.ndarray], + reward_probability_right: t.Optional[np.ndarray], +) -> None: + """Draw the per-trial left/right reward probabilities.""" + ax.set_xlabel("Trial #") + ax.set_ylim([0, 1]) + if reward_probability_left is not None: + ax.plot(reward_probability_left, "b", label="Prob. L") + if reward_probability_right is not None: + ax.plot(reward_probability_right, "r", label="Prob. R") + ax.legend() + + +def plot_side_bias( + animal_response: np.ndarray, + results_folder: str, + *, + stage_positions: t.Optional[pd.DataFrame] = None, + rewarded_history: t.Optional[pd.DataFrame] = None, + reward_probability_left: t.Optional[np.ndarray] = None, + reward_probability_right: t.Optional[np.ndarray] = None, + go_cue_times: t.Optional[np.ndarray] = None, + auto_water: t.Optional[pd.DataFrame] = None, + manual_left_times: t.Optional[np.ndarray] = None, + manual_right_times: t.Optional[np.ndarray] = None, + bias_window: int = 20, +) -> str: + """Save the four-panel side-bias figure. + + Panels: rolling side bias (with CI), lickspout position, behavior raster, + and reward probabilities. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + results_folder : str + Directory to write ``side_bias.png`` into. + stage_positions : pandas.DataFrame, optional + Per-trial lickspout positions (columns among ``x``/``y1``/``y2``/``z``). + rewarded_history : pandas.DataFrame, optional + Boolean ``left``/``right`` reward columns per trial. + reward_probability_left, reward_probability_right : numpy.ndarray, optional + Per-trial reward probabilities. + go_cue_times : numpy.ndarray, optional + Go-cue timestamps (s), used to map manual-water times to trials. + auto_water : pandas.DataFrame, optional + ``left``/``right`` autowater indicators per trial. + manual_left_times, manual_right_times : numpy.ndarray, optional + Manual-water delivery timestamps (s). + bias_window : int, optional + Trailing window for the rolling bias. Defaults to ``20``. + + Returns + ------- + str + The plot filename (``side_bias.png``), for use as a metric + ``reference``. + """ + fig, ax = plt.subplots(nrows=4, figsize=(10, 12)) + for axis in ax: + axis.spines["top"].set_visible(False) + axis.spines["right"].set_visible(False) + + _add_bias_plot(ax[0], animal_response, bias_window) + _add_lickspout_position_plot(ax[1], stage_positions) + _add_behavior_plot( + ax[2], + animal_response, + rewarded_history, + auto_water, + manual_left_times, + manual_right_times, + go_cue_times, + ) + _add_reward_probabilities(ax[3], reward_probability_left, reward_probability_right) + + fig.savefig(os.path.join(results_folder, SIDE_BIAS_PLOT), dpi=300, bbox_inches="tight") + plt.close(fig) + return SIDE_BIAS_PLOT From 2e9992ba4a4f7939bf3f289a329e2cf1d14a1e16 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 11 Jun 2026 17:56:28 -0700 Subject: [PATCH 02/28] feat: add rest of initial qc module --- .../qc/_builder.py | 119 +++++++++++++++ src/dynamic_foraging_processing/qc/_result.py | 75 +++++++++ src/dynamic_foraging_processing/qc/_schema.py | 143 ++++++++++++++++++ 3 files changed, 337 insertions(+) create mode 100644 src/dynamic_foraging_processing/qc/_builder.py create mode 100644 src/dynamic_foraging_processing/qc/_result.py create mode 100644 src/dynamic_foraging_processing/qc/_schema.py diff --git a/src/dynamic_foraging_processing/qc/_builder.py b/src/dynamic_foraging_processing/qc/_builder.py new file mode 100644 index 0000000..75defea --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_builder.py @@ -0,0 +1,119 @@ +"""Assemble the dynamic foraging ``QualityControl`` object. + +Combines the behavior metrics (computed from primitive arrays) with the +contraqctor-based contract QA metrics into a single ``QualityControl``, wiring +up ``default_grouping`` so the QC portal lays out ``behavior`` and +``test_suite`` as sibling top-level groups. +""" + +import typing as t + +import numpy as np +import pandas as pd +from aind_data_schema.core.quality_control import QCMetric, QualityControl + +from dynamic_foraging_processing.qc._behavior import lick_interval_results, side_bias_result +from dynamic_foraging_processing.qc._plots import plot_lick_intervals, plot_side_bias +from dynamic_foraging_processing.qc._result import QCResult + +#: Tag keys laid out as siblings at the top level of the QC portal. +DEFAULT_GROUPING = ["behavior", "test_suite"] + + +def behavior_qc_results( + animal_response: np.ndarray, + left_lick_times: np.ndarray, + right_lick_times: np.ndarray, + results_folder: t.Optional[str] = None, + *, + stage_positions: t.Optional[pd.DataFrame] = None, + rewarded_history: t.Optional[pd.DataFrame] = None, + reward_probability_left: t.Optional[np.ndarray] = None, + reward_probability_right: t.Optional[np.ndarray] = None, + go_cue_times: t.Optional[np.ndarray] = None, + auto_water: t.Optional[pd.DataFrame] = None, + manual_left_times: t.Optional[np.ndarray] = None, + manual_right_times: t.Optional[np.ndarray] = None, +) -> t.List[QCResult]: + """Build the behavior QC results (side bias + lick intervals). + + When ``results_folder`` is provided, the supporting ``side_bias.png`` and + ``lick_intervals.png`` plots are written there so the result references + resolve. Convert the returned results to schema metrics with + ``to_metrics`` / ``QCResult.to_metric`` when assembling a ``QualityControl``. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + left_lick_times, right_lick_times : numpy.ndarray + Timestamps (s) of left/right-port licks. + results_folder : str, optional + Directory to write the plots into. If ``None``, plots are skipped. + stage_positions, rewarded_history, auto_water : pandas.DataFrame, optional + Optional per-trial data passed through to the side-bias figure. + reward_probability_left, reward_probability_right, go_cue_times, \ +manual_left_times, manual_right_times : numpy.ndarray, optional + Optional per-trial / event data passed through to the side-bias figure. + + Returns + ------- + list of QCResult + The average-side-bias result followed by the four lick-interval results. + """ + results = [ + side_bias_result(animal_response), + *lick_interval_results(left_lick_times, right_lick_times), + ] + if results_folder is not None: + plot_side_bias( + animal_response, + results_folder, + stage_positions=stage_positions, + rewarded_history=rewarded_history, + reward_probability_left=reward_probability_left, + reward_probability_right=reward_probability_right, + go_cue_times=go_cue_times, + auto_water=auto_water, + manual_left_times=manual_left_times, + manual_right_times=manual_right_times, + ) + plot_lick_intervals(left_lick_times, right_lick_times, results_folder) + return results + + +def build_quality_control( + metrics: t.List[QCMetric], + *, + default_grouping: t.Optional[t.List[str]] = None, + allow_tag_failures: t.Optional[t.List[str]] = None, + key_experimenters: t.Optional[t.List[str]] = None, + notes: t.Optional[str] = None, +) -> QualityControl: + """Wrap a flat list of metrics into a ``QualityControl`` object. + + Parameters + ---------- + metrics : list of QCMetric + All metrics (behavior + contract QA). + default_grouping : list of str, optional + Tag keys the portal groups by. Defaults to ``["behavior", "test_suite"]``. + allow_tag_failures : list of str, optional + Tag values whose metric failures should not fail the overall QC. + key_experimenters : list of str, optional + Experimenters associated with the session. + notes : str, optional + Free-text notes. + + Returns + ------- + QualityControl + The assembled quality-control object. + """ + return QualityControl( + metrics=metrics, + default_grouping=default_grouping if default_grouping is not None else DEFAULT_GROUPING, + allow_tag_failures=allow_tag_failures if allow_tag_failures is not None else [], + key_experimenters=key_experimenters, + notes=notes, + ) diff --git a/src/dynamic_foraging_processing/qc/_result.py b/src/dynamic_foraging_processing/qc/_result.py new file mode 100644 index 0000000..53e6d52 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_result.py @@ -0,0 +1,75 @@ +"""The per-check ``QCResult`` and its conversion to a schema ``QCMetric``. + +A ``QCResult`` is the raw outcome of one behavior QC check (a name, value, and +pass/fail). It converts into an ``aind_data_schema`` ``QCMetric`` via +``to_metric``; the assembly step collects those metrics into a +``QualityControl``. +""" + +import dataclasses +import typing as t + +from aind_data_schema.core.quality_control import QCMetric + +from dynamic_foraging_processing.qc._schema import bool_to_status, make_metric + + +@dataclasses.dataclass(frozen=True) +class QCResult: + """The raw outcome of a single QC check. + + Attributes + ---------- + name : str + Metric name. + value : Any + The computed value. + passed : bool + Whether the check passed. + description : str, optional + Human-readable description. + reference : str, optional + Relative path to a supporting asset (e.g. a plot). + tags : dict of str to str + Grouping tags (e.g. ``{"behavior": name}``). + """ + + name: str + value: t.Any + passed: bool + description: t.Optional[str] = None + reference: t.Optional[str] = None + tags: t.Dict[str, str] = dataclasses.field(default_factory=dict) + + def to_metric(self) -> QCMetric: + """Convert this result into a schema ``QCMetric``. + + Returns + ------- + QCMetric + A metric carrying this result's value, pass/fail status, and tags. + """ + return make_metric( + name=self.name, + value=self.value, + status=bool_to_status(self.passed), + description=self.description, + reference=self.reference, + tags=self.tags, + ) + + +def to_metrics(results: t.Sequence[QCResult]) -> t.List[QCMetric]: + """Convert a sequence of ``QCResult`` into schema ``QCMetric`` objects. + + Parameters + ---------- + results : sequence of QCResult + The per-check results to convert. + + Returns + ------- + list of QCMetric + One metric per result. + """ + return [result.to_metric() for result in results] diff --git a/src/dynamic_foraging_processing/qc/_schema.py b/src/dynamic_foraging_processing/qc/_schema.py new file mode 100644 index 0000000..de8b025 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_schema.py @@ -0,0 +1,143 @@ +"""Schema helpers for building dynamic foraging quality-control objects. + +These helpers stamp the boilerplate that every ``QCMetric`` shares (modality, +stage, evaluator, timestamps) and convert ``contraqctor`` statuses onto the +``aind_data_schema`` quality-control schema (v2.4.1+). +""" + +import datetime +import typing as t +from zoneinfo import ZoneInfo + +import numpy as np +from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage, Status +from aind_data_schema_models.modalities import Modality +from contraqctor import qc + +#: Pacific timezone used for behavior-metric timestamps (schema requires +#: timezone-aware datetimes). +SEATTLE_TZ = ZoneInfo("America/Los_Angeles") + +#: Map ``contraqctor`` test statuses onto schema statuses. Warnings become +#: ``PENDING`` (needs review); skips count as passing. +STATUS_CONVERTER: t.Dict[qc.Status, Status] = { + qc.Status.PASSED: Status.PASS, + qc.Status.SKIPPED: Status.PASS, + qc.Status.WARNING: Status.PENDING, + qc.Status.FAILED: Status.FAIL, + qc.Status.ERROR: Status.FAIL, +} + + +def now_seattle() -> datetime.datetime: + """Return the current timezone-aware time in the Seattle timezone. + + Returns + ------- + datetime.datetime + Timezone-aware current time. + """ + return datetime.datetime.now(SEATTLE_TZ) + + +def now_utc() -> datetime.datetime: + """Return the current timezone-aware time in UTC. + + Returns + ------- + datetime.datetime + Timezone-aware current UTC time. + """ + return datetime.datetime.now(datetime.timezone.utc) + + +def bool_to_status(passed: bool, timestamp: t.Optional[datetime.datetime] = None) -> QCStatus: + """Convert a boolean pass/fail into an automated ``QCStatus``. + + Parameters + ---------- + passed : bool + ``True`` for a passing metric, ``False`` for a failing one. + timestamp : datetime.datetime, optional + Timezone-aware evaluation time. Defaults to the current Seattle time. + + Returns + ------- + QCStatus + An ``"Automated"`` status with ``PASS`` or ``FAIL``. + """ + timestamp = timestamp if timestamp is not None else now_seattle() + status = Status.PASS if passed else Status.FAIL + return QCStatus(evaluator="Automated", status=status, timestamp=timestamp) + + +def to_builtin(value: t.Any) -> t.Any: + """Convert numpy scalars/arrays to JSON-serializable Python builtins. + + Parameters + ---------- + value : Any + A value that may be a numpy scalar or array. + + Returns + ------- + Any + The equivalent Python builtin (``list`` for arrays, ``item()`` for + scalars), or ``value`` unchanged when it is not a numpy type. + """ + if isinstance(value, np.ndarray): + return value.tolist() + if isinstance(value, np.generic): + return value.item() + return value + + +def make_metric( + *, + name: str, + value: t.Any, + status: QCStatus, + description: t.Optional[str] = None, + reference: t.Optional[str] = None, + tags: t.Optional[t.Dict[str, str]] = None, + modality: Modality = Modality.BEHAVIOR, + stage: Stage = Stage.RAW, +) -> QCMetric: + """Build a ``QCMetric`` with shared modality/stage/tag boilerplate. + + Replaces the old capsule's ``create_evaluation`` + per-metric wiring. + + Parameters + ---------- + name : str + Metric name. + value : Any + Metric value; numpy types are converted to Python builtins. + status : QCStatus + The single status entry for this metric's ``status_history``. + description : str, optional + Human-readable description. + reference : str, optional + Relative path to a supporting asset (e.g. a plot). + tags : dict of str to str, optional + Grouping tags (e.g. ``{"behavior": name}``). Defaults to ``{}``. + modality : Modality, optional + Defaults to ``Modality.BEHAVIOR``. + stage : Stage, optional + Defaults to ``Stage.RAW``. + + Returns + ------- + QCMetric + The assembled metric. + """ + return QCMetric( + name=name, + modality=modality, + stage=stage, + value=to_builtin(value), + status_history=[status], + description=description, + reference=reference, + tags=tags if tags is not None else {}, + ) From 403e4063f257d2ff007a05f3b6a4c4e59b74302a Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 11 Jun 2026 17:56:42 -0700 Subject: [PATCH 03/28] test: add tests --- tests/test_qc/__init__.py | 1 + tests/test_qc/test_behavior.py | 85 +++++++++++++++++++++++++ tests/test_qc/test_builder.py | 59 +++++++++++++++++ tests/test_qc/test_contract_qa.py | 101 ++++++++++++++++++++++++++++++ tests/test_qc/test_plots.py | 76 ++++++++++++++++++++++ tests/test_qc/test_result.py | 47 ++++++++++++++ tests/test_qc/test_schema.py | 70 +++++++++++++++++++++ 7 files changed, 439 insertions(+) create mode 100644 tests/test_qc/__init__.py create mode 100644 tests/test_qc/test_behavior.py create mode 100644 tests/test_qc/test_builder.py create mode 100644 tests/test_qc/test_contract_qa.py create mode 100644 tests/test_qc/test_plots.py create mode 100644 tests/test_qc/test_result.py create mode 100644 tests/test_qc/test_schema.py diff --git a/tests/test_qc/__init__.py b/tests/test_qc/__init__.py new file mode 100644 index 0000000..d824779 --- /dev/null +++ b/tests/test_qc/__init__.py @@ -0,0 +1 @@ +"""Tests for the ``qc`` package.""" diff --git a/tests/test_qc/test_behavior.py b/tests/test_qc/test_behavior.py new file mode 100644 index 0000000..dafd701 --- /dev/null +++ b/tests/test_qc/test_behavior.py @@ -0,0 +1,85 @@ +"""Tests for ``dynamic_foraging_processing.qc._behavior``.""" + +import numpy as np +import pytest + +from dynamic_foraging_processing.qc import _behavior + + +def test_calculate_lick_intervals_both_empty(): + """No licks on either side yields zeroed percentages.""" + result = _behavior.calculate_lick_intervals(np.array([]), np.array([])) + assert result["ArtifactPercent"] == 0.0 + assert result["LeftLickIntervalPercent"] == 0.0 + assert result["RightLickIntervalPercent"] == 0.0 + assert result["CrossSideIntervalPercent"] == 0.0 + assert result["SameSideIntervalPercent"] == 0.0 + + +def test_calculate_lick_intervals_single_side_only(): + """Licks on one side only skip the cross-side computation.""" + result = _behavior.calculate_lick_intervals(np.array([1.0]), np.array([])) + # Single left lick: len(left) > 1 is False, right empty. + assert result["LeftLickIntervalPercent"] == 0.0 + assert result["RightLickIntervalPercent"] == 0.0 + assert result["CrossSideIntervalPercent"] == 0.0 + + +def test_calculate_lick_intervals_fast_and_cross_side(): + """Fast same-side and cross-side intervals are counted as percentages.""" + left = np.array([1.0, 1.01, 5.0]) # one fast left interval + right = np.array([1.005, 1.02, 6.0]) # interleaved with left -> cross-side + result = _behavior.calculate_lick_intervals(left, right) + assert result["LeftLickIntervalPercent"] > 0 + assert result["RightLickIntervalPercent"] > 0 + assert result["CrossSideIntervalPercent"] > 0 + # Sub-millisecond artifacts: none here. + assert result["ArtifactPercent"] == 0.0 + + +def test_calculate_lick_intervals_detects_artifacts(): + """Sub-0.5ms gaps between licks count toward ArtifactPercent.""" + result = _behavior.calculate_lick_intervals(np.array([1.0, 1.0001]), np.array([2.0])) + assert result["ArtifactPercent"] > 0 + + +def test_compute_side_bias_balanced_and_all_ignore(): + """Bias is right-minus-left over responses; all-ignore gives 0.""" + assert _behavior.compute_side_bias(np.array([0, 1, 0, 1])) == 0.0 + assert _behavior.compute_side_bias(np.array([1, 1, 1, 0])) == pytest.approx(0.5) + assert _behavior.compute_side_bias(np.array([2, 2, 2])) == 0.0 + + +def test_compute_rolling_bias_shapes_and_empty_window(): + """Rolling bias is nan where a window has no responses, set otherwise.""" + responses = np.array([2, 1, 1, 0]) # first trial is ignore -> nan + bias, ci = _behavior.compute_rolling_bias(responses, window=2) + assert bias.shape == (4,) + assert ci.shape == (4, 2) + assert np.isnan(bias[0]) + assert not np.isnan(bias[1]) + + +def test_side_bias_result_pass_and_fail(): + """Side-bias result passes under 0.5 absolute bias and fails above it.""" + passing = _behavior.side_bias_result(np.array([0, 1, 0, 1])) + assert passing.passed is True + assert passing.reference == _behavior.SIDE_BIAS_PLOT + assert passing.tags == {"behavior": "average side bias"} + + failing = _behavior.side_bias_result(np.array([1, 1, 1, 1])) + assert failing.passed is False + + +def test_lick_interval_results_names_and_count(): + """Four lick-interval results are produced with the expected names/tags.""" + results = _behavior.lick_interval_results(np.array([1.0, 1.01]), np.array([2.0, 2.01])) + names = [r.name for r in results] + assert names == [ + "Left Lick Interval (%)", + "Right Lick Interval (%)", + "Cross Side Lick Interval (%)", + "Artifact Percent (%)", + ] + assert all(r.reference == _behavior.LICK_INTERVALS_PLOT for r in results) + assert all(r.tags == {"behavior": r.name} for r in results) diff --git a/tests/test_qc/test_builder.py b/tests/test_qc/test_builder.py new file mode 100644 index 0000000..863fab9 --- /dev/null +++ b/tests/test_qc/test_builder.py @@ -0,0 +1,59 @@ +"""Tests for ``dynamic_foraging_processing.qc._builder``.""" + +import os + +import numpy as np +from aind_data_schema.core.quality_control import QualityControl + +from dynamic_foraging_processing.qc import _builder +from dynamic_foraging_processing.qc._result import to_metrics + + +def test_behavior_qc_results_without_plots(): + """Five behavior results are produced and no plots are written.""" + results = _builder.behavior_qc_results( + np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]) + ) + assert len(results) == 5 + assert results[0].name == "average side bias" + + +def test_behavior_qc_results_writes_plots(tmp_path): + """Supplying a results folder writes both behavior plots.""" + results = _builder.behavior_qc_results( + np.array([0, 1, 2, 1]), + np.array([1.0, 1.01]), + np.array([2.0, 2.01]), + str(tmp_path), + ) + assert len(results) == 5 + assert os.path.exists(tmp_path / "side_bias.png") + assert os.path.exists(tmp_path / "lick_intervals.png") + + +def test_build_quality_control_defaults(): + """Defaults fill in the standard grouping and an empty failure allowlist.""" + metrics = to_metrics( + _builder.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + ) + qc = _builder.build_quality_control(metrics) + assert isinstance(qc, QualityControl) + assert qc.default_grouping == _builder.DEFAULT_GROUPING + assert qc.allow_tag_failures == [] + + +def test_build_quality_control_overrides(): + """Explicit grouping / allowlist / metadata are passed through.""" + metrics = to_metrics( + _builder.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + ) + qc = _builder.build_quality_control( + metrics, + default_grouping=["behavior"], + allow_tag_failures=["behavior"], + key_experimenters=["Alex"], + notes="hello", + ) + assert qc.default_grouping == ["behavior"] + assert qc.allow_tag_failures == ["behavior"] + assert qc.notes == "hello" diff --git a/tests/test_qc/test_contract_qa.py b/tests/test_qc/test_contract_qa.py new file mode 100644 index 0000000..e224dc7 --- /dev/null +++ b/tests/test_qc/test_contract_qa.py @@ -0,0 +1,101 @@ +"""Tests for ``dynamic_foraging_processing.qc._contract_qa``.""" + +import os + +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +from contraqctor import qc as cqc + +from dynamic_foraging_processing.qc import _contract_qa + + +def _result( + status, *, suite="SuiteA", test="test_x", context=None, value=1, message="m", description="d" +): + """Build a contraqctor ``Result`` for testing.""" + return cqc.Result( + status=status, + result=value, + test_name=test, + suite_name=suite, + message=message, + description=description, + context=context, + ) + + +def test_sanitize_replaces_unsafe_characters(): + """Non-filename-safe characters collapse to underscores.""" + assert _contract_qa._sanitize("Harp Hub::test 1") == "Harp_Hub_test_1" + + +def test_save_asset_non_dict_context_returns_none(tmp_path): + """A result with no dict context saves nothing.""" + assert _contract_qa._save_asset(_result(cqc.Status.PASSED), str(tmp_path)) is None + + +def test_save_asset_non_figure_asset_returns_none(tmp_path): + """A non-figure asset saves nothing.""" + result = _result(cqc.Status.PASSED, context={"asset": "not-a-figure"}) + assert _contract_qa._save_asset(result, str(tmp_path)) is None + + +def test_save_asset_figure_without_folder_returns_none(): + """A figure asset with no results folder saves nothing.""" + fig = plt.figure() + result = _result(cqc.Status.PASSED, context={"asset": fig}) + assert _contract_qa._save_asset(result, None) is None + plt.close(fig) + + +def test_save_asset_figure_is_saved(tmp_path): + """A figure asset is written and its filename returned.""" + fig = plt.figure() + result = _result(cqc.Status.PASSED, suite="S", test="t", context={"asset": fig}) + name = _contract_qa._save_asset(result, str(tmp_path)) + assert name == "S_t.png" + assert os.path.exists(tmp_path / name) + plt.close(fig) + + +def test_results_to_metrics_grouping_and_status(tmp_path): + """Results convert to tagged metrics; missing group becomes ``NoGroup``.""" + fig = plt.figure() + results = { + "Data contract": [ + _result(cqc.Status.WARNING, suite="HubSuite", test="t1", context={"asset": fig}) + ], + None: [_result(cqc.Status.FAILED, suite="CamSuite", test="t2")], + } + metrics = _contract_qa.results_to_metrics(results, str(tmp_path)) + plt.close(fig) + + by_name = {m.name: m for m in metrics} + warn = by_name["HubSuite::t1"] + assert warn.status_history[0].status == "Pending" + assert warn.tags == {"test_suite": "HubSuite", "HubSuite": "Data contract"} + assert warn.reference == "HubSuite_t1.png" + + fail = by_name["CamSuite::t2"] + assert fail.status_history[0].status == "Fail" + assert fail.tags == {"test_suite": "CamSuite", "CamSuite": _contract_qa.NO_GROUP} + assert fail.reference is None + + +def test_contract_qc_metrics_uses_runner(monkeypatch, tmp_path): + """``contract_qc_metrics`` runs the runner and converts its results.""" + + class _FakeRunner: + """Stand-in runner returning a fixed grouped-results dict.""" + + def run_all(self): + """Return one passing result under a single group.""" + return {"grp": [_result(cqc.Status.PASSED, suite="S", test="t")]} + + monkeypatch.setattr(_contract_qa, "make_qc_runner", lambda dataset: _FakeRunner()) + metrics = _contract_qa.contract_qc_metrics(dataset=object(), results_folder=str(tmp_path)) + assert [m.name for m in metrics] == ["S::t"] + assert metrics[0].status_history[0].status == "Pass" diff --git a/tests/test_qc/test_plots.py b/tests/test_qc/test_plots.py new file mode 100644 index 0000000..cce7f6b --- /dev/null +++ b/tests/test_qc/test_plots.py @@ -0,0 +1,76 @@ +"""Tests for ``dynamic_foraging_processing.qc._plots``.""" + +import os + +import numpy as np +import pandas as pd + +from dynamic_foraging_processing.qc import _plots + + +def test_plot_lick_intervals_writes_file(tmp_path): + """The lick-interval histogram is written and its filename returned.""" + name = _plots.plot_lick_intervals( + np.array([1.0, 1.01, 2.0]), np.array([1.5, 1.6]), str(tmp_path) + ) + assert name == _plots.LICK_INTERVALS_PLOT + assert os.path.exists(tmp_path / name) + + +def test_time_to_trial_index_covers_all_branches(): + """Empty go cues and early/late event times map to the right indices.""" + # No go cues -> every event maps to -1. + assert _plots._time_to_trial_index(np.array([]), np.array([1.0])) == [-1] + # Event before first go cue -> -1; later events -> preceding cue index. + result = _plots._time_to_trial_index(np.array([1.0, 2.0, 3.0]), np.array([0.5, 2.5])) + assert result == [-1, 1] + + +def test_plot_side_bias_full_inputs(tmp_path): + """All optional panels render when every input is supplied.""" + animal_response = np.array([0, 1, 2, 1, 0, 1]) + stage_positions = pd.DataFrame( + { + "x": [1.0, 1.1, 1.0, 1.2, 1.1, 1.0], + "y1": [2.0, 2.0, 2.1, 2.0, 2.0, 2.1], + "y2": [3.0, 3.1, 3.0, 3.1, 3.0, 3.1], + "z": [4.0, 4.0, 4.0, 4.1, 4.0, 4.0], + "ignored_column": [0, 0, 0, 0, 0, 0], # not in the color map -> skipped + } + ) + rewarded_history = pd.DataFrame( + { + "left": [True, False, False, False, True, False], + "right": [False, True, False, True, False, True], + } + ) + auto_water = pd.DataFrame({"left": [1, 0, 0, 0, 0, 0], "right": [0, 0, 0, 1, 0, 0]}) + name = _plots.plot_side_bias( + animal_response, + str(tmp_path), + stage_positions=stage_positions, + rewarded_history=rewarded_history, + reward_probability_left=np.array([0.5, 0.6, 0.4, 0.5, 0.5, 0.6]), + reward_probability_right=np.array([0.5, 0.4, 0.6, 0.5, 0.5, 0.4]), + go_cue_times=np.array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5]), + auto_water=auto_water, + manual_left_times=np.array([0.1, 3.6]), # 0.1 -> -1, 3.6 -> trial index + manual_right_times=np.array([5.6]), + bias_window=3, + ) + assert name == _plots.SIDE_BIAS_PLOT + assert os.path.exists(tmp_path / name) + + +def test_plot_side_bias_minimal_inputs(tmp_path): + """With only choices supplied, the optional panels are skipped cleanly.""" + name = _plots.plot_side_bias(np.array([]), str(tmp_path)) + assert os.path.exists(tmp_path / name) + + +def test_plot_side_bias_empty_stage_positions(tmp_path): + """An empty stage-positions frame is handled without plotting positions.""" + name = _plots.plot_side_bias( + np.array([0, 1]), str(tmp_path), stage_positions=pd.DataFrame({"x": []}) + ) + assert os.path.exists(tmp_path / name) diff --git a/tests/test_qc/test_result.py b/tests/test_qc/test_result.py new file mode 100644 index 0000000..b2be468 --- /dev/null +++ b/tests/test_qc/test_result.py @@ -0,0 +1,47 @@ +"""Tests for ``dynamic_foraging_processing.qc._result``.""" + +from dynamic_foraging_processing.qc import _result + + +def _result_obj(passed=True): + """Build a simple QCResult for conversion tests.""" + return _result.QCResult( + name="m", + value=0.25, + passed=passed, + description="d", + reference="r.png", + tags={"behavior": "m"}, + ) + + +def test_to_metric_carries_fields_and_status(): + """``to_metric`` produces a QCMetric with the result's fields and status.""" + metric = _result_obj(passed=True).to_metric() + assert metric.name == "m" + assert metric.value == 0.25 + assert metric.reference == "r.png" + assert metric.tags == {"behavior": "m"} + assert metric.status_history[0].status == "Pass" + + +def test_to_metric_failing_status(): + """A failing result converts to a failing metric.""" + assert _result_obj(passed=False).to_metric().status_history[0].status == "Fail" + + +def test_to_metrics_converts_each_result(): + """``to_metrics`` converts a sequence of results into metrics.""" + metrics = _result.to_metrics([_result_obj(True), _result_obj(False)]) + assert [m.status_history[0].status for m in metrics] == ["Pass", "Fail"] + + +def test_qc_result_is_frozen(): + """``QCResult`` is immutable.""" + result = _result_obj() + try: + result.passed = False + except Exception as exc: # FrozenInstanceError + assert "cannot assign" in str(exc) or "frozen" in str(exc).lower() + else: # pragma: no cover + raise AssertionError("QCResult should be frozen") diff --git a/tests/test_qc/test_schema.py b/tests/test_qc/test_schema.py new file mode 100644 index 0000000..6f5ec10 --- /dev/null +++ b/tests/test_qc/test_schema.py @@ -0,0 +1,70 @@ +"""Tests for ``dynamic_foraging_processing.qc._schema``.""" + +import datetime + +import numpy as np +from aind_data_schema.core.quality_control import Stage, Status +from aind_data_schema_models.modalities import Modality +from contraqctor import qc as cqc + +from dynamic_foraging_processing.qc import _schema + + +def test_status_converter_maps_all_contraqctor_statuses(): + """Every contraqctor status maps to a schema status (warnings -> pending).""" + assert _schema.STATUS_CONVERTER[cqc.Status.PASSED] == Status.PASS + assert _schema.STATUS_CONVERTER[cqc.Status.SKIPPED] == Status.PASS + assert _schema.STATUS_CONVERTER[cqc.Status.WARNING] == Status.PENDING + assert _schema.STATUS_CONVERTER[cqc.Status.FAILED] == Status.FAIL + assert _schema.STATUS_CONVERTER[cqc.Status.ERROR] == Status.FAIL + + +def test_now_helpers_are_timezone_aware(): + """``now_seattle`` and ``now_utc`` return aware datetimes.""" + assert _schema.now_seattle().tzinfo is not None + assert _schema.now_utc().utcoffset() == datetime.timedelta(0) + + +def test_bool_to_status_pass_and_fail_with_default_timestamp(): + """A truthy value yields PASS, falsy yields FAIL; timestamp defaults to now.""" + passed = _schema.bool_to_status(True) + failed = _schema.bool_to_status(False) + assert passed.status == Status.PASS + assert failed.status == Status.FAIL + assert passed.evaluator == "Automated" + assert passed.timestamp.tzinfo is not None + + +def test_bool_to_status_uses_supplied_timestamp(): + """An explicit timestamp is passed through unchanged.""" + ts = datetime.datetime(2026, 6, 11, tzinfo=datetime.timezone.utc) + assert _schema.bool_to_status(True, ts).timestamp == ts + + +def test_to_builtin_converts_numpy_types(): + """Arrays become lists, numpy scalars become builtins, others pass through.""" + assert _schema.to_builtin(np.array([1, 2])) == [1, 2] + assert _schema.to_builtin(np.float64(1.5)) == 1.5 + assert isinstance(_schema.to_builtin(np.int64(3)), int) + assert _schema.to_builtin("text") == "text" + + +def test_make_metric_defaults_and_overrides(): + """``make_metric`` stamps modality/stage and defaults tags to ``{}``.""" + status = _schema.bool_to_status(True) + default = _schema.make_metric(name="m", value=np.float64(2.0), status=status) + assert default.modality == Modality.BEHAVIOR + assert default.stage == Stage.RAW + assert default.tags == {} + assert default.value == 2.0 + + tagged = _schema.make_metric( + name="m", + value=1, + status=status, + description="d", + reference="r.png", + tags={"behavior": "m"}, + ) + assert tagged.tags == {"behavior": "m"} + assert tagged.reference == "r.png" From 8a145c320b4ba656814a5fa9caffe56535d40aeb Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 11 Jun 2026 18:02:11 -0700 Subject: [PATCH 04/28] build: update dependecies and add optional schema dependency --- pyproject.toml | 9 +++ uv.lock | 172 +++++++++++++++++++++++++++++-------------------- 2 files changed, 111 insertions(+), 70 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index b6d6b18..ad914e8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,6 +21,15 @@ dependencies = [ "ipykernel", ] +[project.optional-dependencies] +qc = [ + "aind-data-schema>=2.4.1", + "matplotlib", +] +full = [ + "dynamic-foraging-processing[qc]", +] + [dependency-groups] dev = [ 'ruff', diff --git a/uv.lock b/uv.lock index 0defb37..24ba68c 100644 --- a/uv.lock +++ b/uv.lock @@ -66,6 +66,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/bc/bf/423d28364d564008a33d40d7aad1fbbed5e028b5bda39ed5cafc41651d7e/aind_behavior_services-0.13.7-py3-none-any.whl", hash = "sha256:ab57927ce283cb07a47c4b02eecee8038421f8292c5efbeeaaf907fd6a69eb08", size = 39614, upload-time = "2026-04-18T22:20:02.941Z" }, ] +[[package]] +name = "aind-data-schema" +version = "2.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aind-data-schema-models" }, + { name = "pydantic" }, + { name = "pydantic-extra-types" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1b/4d/6e1a5175da36d65c0467cab77bc508b7a4b9de4f27f9e6385288cdbece08/aind_data_schema-2.8.1.tar.gz", hash = "sha256:5f3dc809765bd25f27b667d1496499b1a5601c75e89e3804ccb2b0609f8ab84a", size = 960610, upload-time = "2026-06-09T16:15:45.62Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/d2/84fe4192caceb64a3f12d02d25aa3f25d7cf019d58890a24c75ab33c8791/aind_data_schema-2.8.1-py3-none-any.whl", hash = "sha256:71ea58072250719858cd8727bae3a8d974bfccd54b7e37aba21161172b54be41", size = 93863, upload-time = "2026-06-09T16:15:44.154Z" }, +] + +[[package]] +name = "aind-data-schema-models" +version = "5.7.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-resources" }, + { name = "pydantic" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/4f/9b3c124c7b43bc0318b247c933ad945d0613f3f6088290db3542bbdf97fa/aind_data_schema_models-5.7.3.tar.gz", hash = "sha256:d68db456c0ce0aafa9b7f4da2f2c0e0925c724d1a4f1a509ca43e3a5f945a92c", size = 342029, upload-time = "2026-06-04T03:59:01.784Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/1a/b4706006fb390d4e64e1df6e9137683aca082e754b79d91e488c756bbf59/aind_data_schema_models-5.7.3-py3-none-any.whl", hash = "sha256:cd7c1a311338aeecfc1463ac069ef34db67f15508be17daa47d6155a00f1cbe0", size = 310756, upload-time = "2026-06-04T03:59:00.492Z" }, +] + [[package]] name = "alabaster" version = "1.0.0" @@ -533,6 +562,16 @@ dependencies = [ { name = "ipykernel" }, ] +[package.optional-dependencies] +full = [ + { name = "aind-data-schema" }, + { name = "matplotlib" }, +] +qc = [ + { name = "aind-data-schema" }, + { name = "matplotlib" }, +] + [package.dev-dependencies] dev = [ { name = "coverage" }, @@ -546,8 +585,12 @@ dev = [ [package.metadata] requires-dist = [ { name = "aind-behavior-dynamic-foraging", extras = ["data"], git = "https://github.com/AllenNeuralDynamics/Aind.Behavior.DynamicForaging.git?rev=v0.0.2rc27" }, + { name = "aind-data-schema", marker = "extra == 'qc'", specifier = ">=2.4.1" }, + { name = "dynamic-foraging-processing", extras = ["qc"], marker = "extra == 'full'" }, { name = "ipykernel" }, + { name = "matplotlib", marker = "extra == 'qc'" }, ] +provides-extras = ["qc", "full"] [package.metadata.requires-dev] dev = [ @@ -680,6 +723,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5f/53/fb7122b71361a0d121b669dcf3d31244ef75badbbb724af388948de543e2/imagesize-2.0.0-py2.py3-none-any.whl", hash = "sha256:5667c5bbb57ab3f1fa4bc366f4fbc971db3d5ed011fd2715fd8001f782718d96", size = 9441, upload-time = "2026-03-03T14:18:27.892Z" }, ] +[[package]] +name = "importlib-resources" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/06/b56dfa750b44e86157093bc8fca0ab81dccbf5260510de4eaf1cb69b5b99/importlib_resources-7.1.0.tar.gz", hash = "sha256:0722d4c6212489c530f2a145a34c0a7a3b4721bc96a15fada5930e2a0b760708", size = 44985, upload-time = "2026-04-12T16:36:09.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/db/55a262f3606bebcae07cc14095338471ad7c0bbcaa37707e6f0ee49725b7/importlib_resources-7.1.0-py3-none-any.whl", hash = "sha256:1bd7b48b4088eddb2cd16382150bb515af0bd2c70128194392725f82ad2c96a1", size = 37232, upload-time = "2026-04-12T16:36:08.219Z" }, +] + [[package]] name = "iniconfig" version = "2.3.0" @@ -1387,7 +1439,7 @@ wheels = [ [[package]] name = "pydantic" -version = "2.13.4" +version = "2.11.10" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-types" }, @@ -1395,84 +1447,64 @@ dependencies = [ { name = "typing-extensions" }, { name = "typing-inspection" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/54/ecab642b3bed45f7d5f59b38443dcb36ef50f85af192e6ece103dbfe9587/pydantic-2.11.10.tar.gz", hash = "sha256:dc280f0982fbda6c38fada4e476dc0a4f3aeaf9c6ad4c28df68a666ec3c61423", size = 788494, upload-time = "2025-10-04T10:40:41.338Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" }, + { url = "https://files.pythonhosted.org/packages/bd/1f/73c53fcbfb0b5a78f91176df41945ca466e71e9d9d836e5c522abda39ee7/pydantic-2.11.10-py3-none-any.whl", hash = "sha256:802a655709d49bd004c31e865ef37da30b540786a46bfce02333e0e24b5fe29a", size = 444823, upload-time = "2025-10-04T10:40:39.055Z" }, ] [[package]] name = "pydantic-core" -version = "2.46.4" +version = "2.33.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" }, + { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" }, + { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" }, + { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" }, + { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" }, + { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" }, + { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" }, + { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" }, + { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" }, + { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" }, + { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" }, + { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" }, + { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" }, + { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" }, + { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" }, +] + +[[package]] +name = "pydantic-extra-types" +version = "2.11.1" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "pydantic" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" }, - { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" }, - { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" }, - { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" }, - { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" }, - { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" }, - { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" }, - { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" }, - { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" }, - { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" }, - { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" }, - { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" }, - { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" }, - { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" }, - { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" }, - { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" }, - { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" }, - { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" }, - { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" }, - { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" }, - { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" }, - { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" }, - { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" }, - { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" }, - { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" }, - { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" }, - { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" }, - { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" }, - { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" }, - { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" }, - { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" }, - { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" }, - { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" }, - { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" }, - { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" }, - { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" }, - { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" }, - { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" }, - { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" }, - { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" }, - { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" }, - { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" }, - { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" }, - { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" }, - { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" }, - { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" }, - { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" }, - { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" }, - { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" }, - { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" }, - { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" }, - { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" }, - { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" }, - { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" }, - { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" }, - { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" }, - { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" }, - { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" }, - { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" }, - { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" }, - { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" }, - { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" }, - { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" }, - { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" }, ] [[package]] From 845f11fea375c1c306b1682d6cb904b24e74f526 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 11 Jun 2026 18:02:23 -0700 Subject: [PATCH 05/28] ci: update workflows to install full dependecies --- .github/workflows/tag_and_publish.yml | 2 +- .github/workflows/test_and_lint.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tag_and_publish.yml b/.github/workflows/tag_and_publish.yml index 7c6ba1c..dd822ab 100644 --- a/.github/workflows/tag_and_publish.yml +++ b/.github/workflows/tag_and_publish.yml @@ -24,7 +24,7 @@ jobs: with: python-version: '3.10' - name: Install dependencies - run: uv sync + run: uv sync --extra full - name: Get Python version and Update README.md run: | python_version=$(grep "requires-python" pyproject.toml | grep -o ">=[^\"]*") diff --git a/.github/workflows/test_and_lint.yml b/.github/workflows/test_and_lint.yml index 7593130..ed0e022 100644 --- a/.github/workflows/test_and_lint.yml +++ b/.github/workflows/test_and_lint.yml @@ -21,7 +21,7 @@ jobs: with: python-version: ${{ matrix.python-version }} - name: Install dependencies - run: uv sync + run: uv sync --extra full - name: Run linter checks run: uv run ruff check . && uv run ruff format --check . && uv run interrogate --verbose . - name: Run tests and coverage From 92b290490d17fd137b60c64e44347800a8b12bfc Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 16:19:01 -0700 Subject: [PATCH 06/28] refactor: major overhaul to match architecture --- .../qc/__init__.py | 48 ++++--- .../qc/_builder.py | 119 ------------------ .../qc/_contract_qa.py | 119 ------------------ .../qc/_core/__init__.py | 34 +++++ .../qc/_core/base.py | 33 +++++ .../qc/_core/builder.py | 50 ++++++++ .../qc/{_result.py => _core/result.py} | 2 +- .../qc/{_schema.py => _core/schema.py} | 0 .../qc/processed/__init__.py | 27 ++++ .../{_behavior.py => processed/behavior.py} | 2 +- .../qc/{_plots.py => processed/plots.py} | 98 +++++++++------ .../qc/processed/results.py | 93 ++++++++++++++ .../qc/processed/stage.py | 87 +++++++++++++ .../qc/raw/__init__.py | 9 ++ 14 files changed, 427 insertions(+), 294 deletions(-) delete mode 100644 src/dynamic_foraging_processing/qc/_builder.py delete mode 100644 src/dynamic_foraging_processing/qc/_contract_qa.py create mode 100644 src/dynamic_foraging_processing/qc/_core/__init__.py create mode 100644 src/dynamic_foraging_processing/qc/_core/base.py create mode 100644 src/dynamic_foraging_processing/qc/_core/builder.py rename src/dynamic_foraging_processing/qc/{_result.py => _core/result.py} (95%) rename src/dynamic_foraging_processing/qc/{_schema.py => _core/schema.py} (100%) create mode 100644 src/dynamic_foraging_processing/qc/processed/__init__.py rename src/dynamic_foraging_processing/qc/{_behavior.py => processed/behavior.py} (99%) rename src/dynamic_foraging_processing/qc/{_plots.py => processed/plots.py} (75%) create mode 100644 src/dynamic_foraging_processing/qc/processed/results.py create mode 100644 src/dynamic_foraging_processing/qc/processed/stage.py create mode 100644 src/dynamic_foraging_processing/qc/raw/__init__.py diff --git a/src/dynamic_foraging_processing/qc/__init__.py b/src/dynamic_foraging_processing/qc/__init__.py index 00f0d45..6f10b7b 100644 --- a/src/dynamic_foraging_processing/qc/__init__.py +++ b/src/dynamic_foraging_processing/qc/__init__.py @@ -2,39 +2,53 @@ Builds an ``aind_data_schema`` ``QualityControl`` object from primitive behavior data (lick times, per-trial choices) plus the contraqctor-based contract QA. + +The module is organized by QC stage: + +- :mod:`~dynamic_foraging_processing.qc._core` -- the shared stage interface, + schema helpers, per-check result type, and ``QualityControl`` assembler. +- :mod:`~dynamic_foraging_processing.qc.raw` -- the raw-data (contract QA) stage. +- :mod:`~dynamic_foraging_processing.qc.processed` -- the processed-data + (behavior metrics) stage. """ -from dynamic_foraging_processing.qc._behavior import ( +from dynamic_foraging_processing.qc._core import ( + DEFAULT_GROUPING, + STATUS_CONVERTER, + BaseQC, + QCResult, + bool_to_status, + build_quality_control, + make_metric, + now_seattle, + now_utc, + to_builtin, + to_metrics, +) +from dynamic_foraging_processing.qc.processed import ( + ProcessedQC, + behavior_qc_results, calculate_lick_intervals, compute_rolling_bias, compute_side_bias, lick_interval_results, + plot_lick_intervals, + plot_side_bias, side_bias_result, ) -from dynamic_foraging_processing.qc._builder import ( - DEFAULT_GROUPING, - behavior_qc_results, - build_quality_control, -) -from dynamic_foraging_processing.qc._contract_qa import ( +from dynamic_foraging_processing.qc.raw import ( + RawQC, contract_qc_metrics, results_to_metrics, ) -from dynamic_foraging_processing.qc._plots import plot_lick_intervals, plot_side_bias -from dynamic_foraging_processing.qc._result import QCResult, to_metrics -from dynamic_foraging_processing.qc._schema import ( - STATUS_CONVERTER, - bool_to_status, - make_metric, - now_seattle, - now_utc, - to_builtin, -) __all__ = [ "DEFAULT_GROUPING", "STATUS_CONVERTER", + "BaseQC", + "ProcessedQC", "QCResult", + "RawQC", "behavior_qc_results", "bool_to_status", "build_quality_control", diff --git a/src/dynamic_foraging_processing/qc/_builder.py b/src/dynamic_foraging_processing/qc/_builder.py deleted file mode 100644 index 75defea..0000000 --- a/src/dynamic_foraging_processing/qc/_builder.py +++ /dev/null @@ -1,119 +0,0 @@ -"""Assemble the dynamic foraging ``QualityControl`` object. - -Combines the behavior metrics (computed from primitive arrays) with the -contraqctor-based contract QA metrics into a single ``QualityControl``, wiring -up ``default_grouping`` so the QC portal lays out ``behavior`` and -``test_suite`` as sibling top-level groups. -""" - -import typing as t - -import numpy as np -import pandas as pd -from aind_data_schema.core.quality_control import QCMetric, QualityControl - -from dynamic_foraging_processing.qc._behavior import lick_interval_results, side_bias_result -from dynamic_foraging_processing.qc._plots import plot_lick_intervals, plot_side_bias -from dynamic_foraging_processing.qc._result import QCResult - -#: Tag keys laid out as siblings at the top level of the QC portal. -DEFAULT_GROUPING = ["behavior", "test_suite"] - - -def behavior_qc_results( - animal_response: np.ndarray, - left_lick_times: np.ndarray, - right_lick_times: np.ndarray, - results_folder: t.Optional[str] = None, - *, - stage_positions: t.Optional[pd.DataFrame] = None, - rewarded_history: t.Optional[pd.DataFrame] = None, - reward_probability_left: t.Optional[np.ndarray] = None, - reward_probability_right: t.Optional[np.ndarray] = None, - go_cue_times: t.Optional[np.ndarray] = None, - auto_water: t.Optional[pd.DataFrame] = None, - manual_left_times: t.Optional[np.ndarray] = None, - manual_right_times: t.Optional[np.ndarray] = None, -) -> t.List[QCResult]: - """Build the behavior QC results (side bias + lick intervals). - - When ``results_folder`` is provided, the supporting ``side_bias.png`` and - ``lick_intervals.png`` plots are written there so the result references - resolve. Convert the returned results to schema metrics with - ``to_metrics`` / ``QCResult.to_metric`` when assembling a ``QualityControl``. - - Parameters - ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). - left_lick_times, right_lick_times : numpy.ndarray - Timestamps (s) of left/right-port licks. - results_folder : str, optional - Directory to write the plots into. If ``None``, plots are skipped. - stage_positions, rewarded_history, auto_water : pandas.DataFrame, optional - Optional per-trial data passed through to the side-bias figure. - reward_probability_left, reward_probability_right, go_cue_times, \ -manual_left_times, manual_right_times : numpy.ndarray, optional - Optional per-trial / event data passed through to the side-bias figure. - - Returns - ------- - list of QCResult - The average-side-bias result followed by the four lick-interval results. - """ - results = [ - side_bias_result(animal_response), - *lick_interval_results(left_lick_times, right_lick_times), - ] - if results_folder is not None: - plot_side_bias( - animal_response, - results_folder, - stage_positions=stage_positions, - rewarded_history=rewarded_history, - reward_probability_left=reward_probability_left, - reward_probability_right=reward_probability_right, - go_cue_times=go_cue_times, - auto_water=auto_water, - manual_left_times=manual_left_times, - manual_right_times=manual_right_times, - ) - plot_lick_intervals(left_lick_times, right_lick_times, results_folder) - return results - - -def build_quality_control( - metrics: t.List[QCMetric], - *, - default_grouping: t.Optional[t.List[str]] = None, - allow_tag_failures: t.Optional[t.List[str]] = None, - key_experimenters: t.Optional[t.List[str]] = None, - notes: t.Optional[str] = None, -) -> QualityControl: - """Wrap a flat list of metrics into a ``QualityControl`` object. - - Parameters - ---------- - metrics : list of QCMetric - All metrics (behavior + contract QA). - default_grouping : list of str, optional - Tag keys the portal groups by. Defaults to ``["behavior", "test_suite"]``. - allow_tag_failures : list of str, optional - Tag values whose metric failures should not fail the overall QC. - key_experimenters : list of str, optional - Experimenters associated with the session. - notes : str, optional - Free-text notes. - - Returns - ------- - QualityControl - The assembled quality-control object. - """ - return QualityControl( - metrics=metrics, - default_grouping=default_grouping if default_grouping is not None else DEFAULT_GROUPING, - allow_tag_failures=allow_tag_failures if allow_tag_failures is not None else [], - key_experimenters=key_experimenters, - notes=notes, - ) diff --git a/src/dynamic_foraging_processing/qc/_contract_qa.py b/src/dynamic_foraging_processing/qc/_contract_qa.py deleted file mode 100644 index af27bf8..0000000 --- a/src/dynamic_foraging_processing/qc/_contract_qa.py +++ /dev/null @@ -1,119 +0,0 @@ -"""Convert ``contraqctor`` QA runner results into ``QCMetric`` objects. - -The dynamic foraging contract QA (Harp devices, cameras, CSV streams, the data -contract, and task-specific checks) is provided by -``aind_behavior_dynamic_foraging.data_qc.make_qc_runner``. This module runs that -runner over a dataset and maps each ``contraqctor`` ``Result`` onto a schema -``QCMetric``, tagged so the QC portal groups them under ``test_suite``. -""" - -import os -import re -import typing as t - -import matplotlib.figure -from aind_behavior_dynamic_foraging.data_qc.suite import make_qc_runner -from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage -from aind_data_schema_models.modalities import Modality -from contraqctor import contract, qc - -from dynamic_foraging_processing.qc._schema import STATUS_CONVERTER, now_utc, to_builtin - -#: Group value used when a runner result has no group. -NO_GROUP = "NoGroup" - - -def _sanitize(name: str) -> str: - """Make ``name`` safe to use as a filename component.""" - return re.sub(r"[^0-9A-Za-z._-]+", "_", name) - - -def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optional[str]: - """Save a result's figure asset (if any) and return its relative path. - - Parameters - ---------- - result : contraqctor.qc.Result - A single QA result; its ``context["asset"]`` may be a matplotlib figure. - results_folder : str or None - Directory to save figures into. If ``None``, nothing is saved. - - Returns - ------- - str or None - The saved figure's filename, or ``None`` when there is no figure asset - (or no ``results_folder``). - """ - context = result.context - if not isinstance(context, dict): - return None - asset = context.get("asset") - if not isinstance(asset, matplotlib.figure.Figure) or results_folder is None: - return None - filename = f"{_sanitize(result.suite_name)}_{_sanitize(result.test_name)}.png" - asset.savefig(os.path.join(results_folder, filename), dpi=300, bbox_inches="tight") - return filename - - -def results_to_metrics( - results: t.Dict[t.Optional[str], t.List[qc.Result]], - results_folder: t.Optional[str] = None, -) -> t.List[QCMetric]: - """Convert grouped ``contraqctor`` results into ``QCMetric`` objects. - - Parameters - ---------- - results : dict - Mapping of group name to list of ``contraqctor`` ``Result`` objects, as - returned by ``contraqctor.qc.Runner.run_all``. - results_folder : str, optional - Directory to save figure assets into. If ``None``, assets are skipped. - - Returns - ------- - list of QCMetric - One metric per result, tagged ``{"test_suite": suite, suite: group}``. - """ - metrics: t.List[QCMetric] = [] - for group, group_results in results.items(): - group_name = group if group is not None else NO_GROUP - for result in group_results: - status = QCStatus( - evaluator="Automated", - status=STATUS_CONVERTER[result.status], - timestamp=now_utc(), - ) - metrics.append( - QCMetric( - name=f"{result.suite_name}::{result.test_name}", - modality=Modality.BEHAVIOR, - stage=Stage.RAW, - value=to_builtin(result.result), - status_history=[status], - description=f"Test: {result.description} // Message: {result.message}", - reference=_save_asset(result, results_folder), - tags={"test_suite": result.suite_name, result.suite_name: group_name}, - ) - ) - return metrics - - -def contract_qc_metrics( - dataset: contract.Dataset, results_folder: t.Optional[str] = None -) -> t.List[QCMetric]: - """Run the dynamic foraging contract QA over a dataset and convert results. - - Parameters - ---------- - dataset : contraqctor.contract.Dataset - A dynamic foraging dataset (e.g. ``RawDataLoader.dataset``). - results_folder : str, optional - Directory to save figure assets into. If ``None``, assets are skipped. - - Returns - ------- - list of QCMetric - Converted QA metrics for every suite the runner wires up. - """ - runner = make_qc_runner(dataset) - return results_to_metrics(runner.run_all(), results_folder) diff --git a/src/dynamic_foraging_processing/qc/_core/__init__.py b/src/dynamic_foraging_processing/qc/_core/__init__.py new file mode 100644 index 0000000..c609aac --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_core/__init__.py @@ -0,0 +1,34 @@ +"""Shared QC infrastructure: the stage interface, schema helpers, the per-check +result type, and the ``QualityControl`` assembler. + +These pieces are stage-agnostic; the raw and processed stages build on them. +""" + +from dynamic_foraging_processing.qc._core.base import BaseQC +from dynamic_foraging_processing.qc._core.builder import ( + DEFAULT_GROUPING, + build_quality_control, +) +from dynamic_foraging_processing.qc._core.result import QCResult, to_metrics +from dynamic_foraging_processing.qc._core.schema import ( + STATUS_CONVERTER, + bool_to_status, + make_metric, + now_seattle, + now_utc, + to_builtin, +) + +__all__ = [ + "DEFAULT_GROUPING", + "STATUS_CONVERTER", + "BaseQC", + "QCResult", + "bool_to_status", + "build_quality_control", + "make_metric", + "now_seattle", + "now_utc", + "to_builtin", + "to_metrics", +] diff --git a/src/dynamic_foraging_processing/qc/_core/base.py b/src/dynamic_foraging_processing/qc/_core/base.py new file mode 100644 index 0000000..60d3bc0 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_core/base.py @@ -0,0 +1,33 @@ +"""Shared interface for the dynamic foraging QC stages. + +``BaseQC`` is an optional base class so the QC stages (raw, processed) share a +single ``run`` interface. Each concrete stage computes its checks and returns +them as schema ``QCMetric`` objects, which a caller assembles into one +``QualityControl`` (see :func:`build_quality_control`). +""" + +import abc +import typing as t + +from aind_data_schema.core.quality_control import QCMetric + + +class BaseQC(abc.ABC): + """Common interface for a QC stage. + + A QC stage takes some slice of a session's data and produces a flat list of + ``QCMetric`` objects. Subclasses define what slice ``run`` consumes (raw + acquisition data, processed tables, ...); the return type is shared so the + metrics can be collected uniformly. + """ + + @abc.abstractmethod + def run(self, *args: t.Any, **kwargs: t.Any) -> t.List[QCMetric]: + """Run this stage's checks and return them as metrics. + + Returns + ------- + list of QCMetric + One metric per check, ready to assemble into a ``QualityControl``. + """ + raise NotImplementedError diff --git a/src/dynamic_foraging_processing/qc/_core/builder.py b/src/dynamic_foraging_processing/qc/_core/builder.py new file mode 100644 index 0000000..d9b590f --- /dev/null +++ b/src/dynamic_foraging_processing/qc/_core/builder.py @@ -0,0 +1,50 @@ +"""Assemble the dynamic foraging ``QualityControl`` object. + +Collects a flat list of metrics (behavior + contract QA) into a single +``QualityControl``, wiring up ``default_grouping`` so the QC portal lays out +``behavior`` and ``test_suite`` as sibling top-level groups. +""" + +import typing as t + +from aind_data_schema.core.quality_control import QCMetric, QualityControl + +#: Tag keys laid out as siblings at the top level of the QC portal. +DEFAULT_GROUPING = ["behavior", "test_suite"] + + +def build_quality_control( + metrics: t.List[QCMetric], + *, + default_grouping: t.Optional[t.List[str]] = None, + allow_tag_failures: t.Optional[t.List[str]] = None, + key_experimenters: t.Optional[t.List[str]] = None, + notes: t.Optional[str] = None, +) -> QualityControl: + """Wrap a flat list of metrics into a ``QualityControl`` object. + + Parameters + ---------- + metrics : list of QCMetric + All metrics (behavior + contract QA). + default_grouping : list of str, optional + Tag keys the portal groups by. Defaults to ``["behavior", "test_suite"]``. + allow_tag_failures : list of str, optional + Tag values whose metric failures should not fail the overall QC. + key_experimenters : list of str, optional + Experimenters associated with the session. + notes : str, optional + Free-text notes. + + Returns + ------- + QualityControl + The assembled quality-control object. + """ + return QualityControl( + metrics=metrics, + default_grouping=default_grouping if default_grouping is not None else DEFAULT_GROUPING, + allow_tag_failures=allow_tag_failures if allow_tag_failures is not None else [], + key_experimenters=key_experimenters, + notes=notes, + ) diff --git a/src/dynamic_foraging_processing/qc/_result.py b/src/dynamic_foraging_processing/qc/_core/result.py similarity index 95% rename from src/dynamic_foraging_processing/qc/_result.py rename to src/dynamic_foraging_processing/qc/_core/result.py index 53e6d52..ae71125 100644 --- a/src/dynamic_foraging_processing/qc/_result.py +++ b/src/dynamic_foraging_processing/qc/_core/result.py @@ -11,7 +11,7 @@ from aind_data_schema.core.quality_control import QCMetric -from dynamic_foraging_processing.qc._schema import bool_to_status, make_metric +from dynamic_foraging_processing.qc._core.schema import bool_to_status, make_metric @dataclasses.dataclass(frozen=True) diff --git a/src/dynamic_foraging_processing/qc/_schema.py b/src/dynamic_foraging_processing/qc/_core/schema.py similarity index 100% rename from src/dynamic_foraging_processing/qc/_schema.py rename to src/dynamic_foraging_processing/qc/_core/schema.py diff --git a/src/dynamic_foraging_processing/qc/processed/__init__.py b/src/dynamic_foraging_processing/qc/processed/__init__.py new file mode 100644 index 0000000..3aa7252 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/processed/__init__.py @@ -0,0 +1,27 @@ +"""Processed-data QC stage: behavior metrics computed from per-trial arrays.""" + +from dynamic_foraging_processing.qc.processed.behavior import ( + calculate_lick_intervals, + compute_rolling_bias, + compute_side_bias, + lick_interval_results, + side_bias_result, +) +from dynamic_foraging_processing.qc.processed.plots import ( + plot_lick_intervals, + plot_side_bias, +) +from dynamic_foraging_processing.qc.processed.results import behavior_qc_results +from dynamic_foraging_processing.qc.processed.stage import ProcessedQC + +__all__ = [ + "ProcessedQC", + "behavior_qc_results", + "calculate_lick_intervals", + "compute_rolling_bias", + "compute_side_bias", + "lick_interval_results", + "plot_lick_intervals", + "plot_side_bias", + "side_bias_result", +] diff --git a/src/dynamic_foraging_processing/qc/_behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py similarity index 99% rename from src/dynamic_foraging_processing/qc/_behavior.py rename to src/dynamic_foraging_processing/qc/processed/behavior.py index c1f7709..73518f2 100644 --- a/src/dynamic_foraging_processing/qc/_behavior.py +++ b/src/dynamic_foraging_processing/qc/processed/behavior.py @@ -11,7 +11,7 @@ import numpy as np -from dynamic_foraging_processing.qc._result import QCResult +from dynamic_foraging_processing.qc._core.result import QCResult #: Reference plot assets shared by the behavior metrics. SIDE_BIAS_PLOT = "side_bias.png" diff --git a/src/dynamic_foraging_processing/qc/_plots.py b/src/dynamic_foraging_processing/qc/processed/plots.py similarity index 75% rename from src/dynamic_foraging_processing/qc/_plots.py rename to src/dynamic_foraging_processing/qc/processed/plots.py index 6b5e4da..56cd416 100644 --- a/src/dynamic_foraging_processing/qc/_plots.py +++ b/src/dynamic_foraging_processing/qc/processed/plots.py @@ -1,8 +1,8 @@ """QC plots for the dynamic foraging behavior metrics. Ported from the old ``aind-dynamic-foraging-qc`` capsule, adapted to take -primitive arrays / DataFrames instead of a ``behavior.json`` dict. The Agg -backend is forced so the plots render headlessly (no display required). +primitive per-trial and event-time arrays instead of a ``behavior.json`` dict. +The Agg backend is forced so the plots render headlessly (no display required). """ import os @@ -14,17 +14,13 @@ import matplotlib.pyplot as plt import numpy as np -import pandas as pd -from dynamic_foraging_processing.qc._behavior import ( +from dynamic_foraging_processing.qc.processed.behavior import ( LICK_INTERVALS_PLOT, SIDE_BIAS_PLOT, compute_rolling_bias, ) -#: Column -> color mapping for the lickspout-position panel. -_LICKSPOUT_COLORS = {"x": "r", "y1": "b", "y2": "lightblue", "y": "b", "z": "m"} - def plot_lick_intervals( left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: str @@ -107,18 +103,31 @@ def _add_bias_plot(ax: plt.Axes, animal_response: np.ndarray, window: int) -> No ax.set_xlim([0, len(bias)]) -def _add_lickspout_position_plot(ax: plt.Axes, stage_positions: t.Optional[pd.DataFrame]) -> None: +def _add_lickspout_position_plot( + ax: plt.Axes, + lickspout_x: t.Optional[np.ndarray], + lickspout_y1: t.Optional[np.ndarray], + lickspout_y2: t.Optional[np.ndarray], + lickspout_z: t.Optional[np.ndarray], +) -> None: """Draw lickspout x/y/z positions relative to session start (mm).""" ax.set_xlabel("Trial #") ax.set_ylabel("Lickspout Position \n relative to session start (mm)") - if stage_positions is None or len(stage_positions) == 0: - return - for col in stage_positions.columns: - if col not in _LICKSPOUT_COLORS: + positions = [ + ("X", lickspout_x, "r"), + ("Y1", lickspout_y1, "b"), + ("Y2", lickspout_y2, "lightblue"), + ("Z", lickspout_z, "m"), + ] + plotted = False + for label, position, color in positions: + if position is None or len(position) == 0: continue - series = stage_positions[col].to_numpy(dtype=float) - ax.plot(series - series[0], _LICKSPOUT_COLORS[col], label=col.upper()) - ax.legend() + values = np.asarray(position, dtype=float) + ax.plot(values - values[0], color, label=label) + plotted = True + if plotted: + ax.legend() def _time_to_trial_index(go_cue_times: np.ndarray, times: np.ndarray) -> t.List[int]: @@ -136,8 +145,10 @@ def _time_to_trial_index(go_cue_times: np.ndarray, times: np.ndarray) -> t.List[ def _add_behavior_plot( ax: plt.Axes, animal_response: np.ndarray, - rewarded_history: t.Optional[pd.DataFrame], - auto_water: t.Optional[pd.DataFrame], + rewarded_left: t.Optional[np.ndarray], + rewarded_right: t.Optional[np.ndarray], + autowater_left: t.Optional[np.ndarray], + autowater_right: t.Optional[np.ndarray], manual_left_times: t.Optional[np.ndarray], manual_right_times: t.Optional[np.ndarray], go_cue_times: t.Optional[np.ndarray], @@ -148,10 +159,11 @@ def _add_behavior_plot( ax.vlines(np.where(choices == 0)[0], 0, 0.2, linewidth=1, color="gray") ax.vlines(np.where(choices == 2)[0], 0.4, 0.6, linewidth=1, color="darkviolet", label="ignore") - if rewarded_history is not None: - left_rewards = np.where(rewarded_history["left"].to_numpy())[0] - right_rewards = np.where(rewarded_history["right"].to_numpy())[0] + if rewarded_left is not None: + left_rewards = np.where(np.asarray(rewarded_left))[0] ax.vlines(left_rewards, -0.2, 0, linewidth=1, color="black", label="Earned Water") + if rewarded_right is not None: + right_rewards = np.where(np.asarray(rewarded_right))[0] ax.vlines(right_rewards, 1, 1.2, linewidth=1, color="black") if manual_right_times is not None and go_cue_times is not None: @@ -172,17 +184,22 @@ def _add_behavior_plot( color="blue", ) - if auto_water is not None: + if autowater_right is not None: ax.vlines( - np.where(auto_water["right"].to_numpy() == 1)[0], + np.where(np.asarray(autowater_right) == 1)[0], 1.2, 1.4, linewidth=1, color="cyan", label="Auto Water", ) + if autowater_left is not None: ax.vlines( - np.where(auto_water["left"].to_numpy() == 1)[0], -0.4, -0.2, linewidth=1, color="cyan" + np.where(np.asarray(autowater_left) == 1)[0], + -0.4, + -0.2, + linewidth=1, + color="cyan", ) ax.set_ylim([-0.4, 1.4]) @@ -211,9 +228,9 @@ def _add_reward_probabilities( ax.set_xlabel("Trial #") ax.set_ylim([0, 1]) if reward_probability_left is not None: - ax.plot(reward_probability_left, "b", label="Prob. L") + ax.plot(np.asarray(reward_probability_left, dtype=float), "b", label="Prob. L") if reward_probability_right is not None: - ax.plot(reward_probability_right, "r", label="Prob. R") + ax.plot(np.asarray(reward_probability_right, dtype=float), "r", label="Prob. R") ax.legend() @@ -221,12 +238,17 @@ def plot_side_bias( animal_response: np.ndarray, results_folder: str, *, - stage_positions: t.Optional[pd.DataFrame] = None, - rewarded_history: t.Optional[pd.DataFrame] = None, + lickspout_x: t.Optional[np.ndarray] = None, + lickspout_y1: t.Optional[np.ndarray] = None, + lickspout_y2: t.Optional[np.ndarray] = None, + lickspout_z: t.Optional[np.ndarray] = None, + rewarded_left: t.Optional[np.ndarray] = None, + rewarded_right: t.Optional[np.ndarray] = None, reward_probability_left: t.Optional[np.ndarray] = None, reward_probability_right: t.Optional[np.ndarray] = None, go_cue_times: t.Optional[np.ndarray] = None, - auto_water: t.Optional[pd.DataFrame] = None, + autowater_left: t.Optional[np.ndarray] = None, + autowater_right: t.Optional[np.ndarray] = None, manual_left_times: t.Optional[np.ndarray] = None, manual_right_times: t.Optional[np.ndarray] = None, bias_window: int = 20, @@ -242,16 +264,16 @@ def plot_side_bias( Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). results_folder : str Directory to write ``side_bias.png`` into. - stage_positions : pandas.DataFrame, optional - Per-trial lickspout positions (columns among ``x``/``y1``/``y2``/``z``). - rewarded_history : pandas.DataFrame, optional - Boolean ``left``/``right`` reward columns per trial. + lickspout_x, lickspout_y1, lickspout_y2, lickspout_z : numpy.ndarray, optional + Per-trial lickspout positions (one array each). + rewarded_left, rewarded_right : numpy.ndarray, optional + Boolean per-trial earned-reward arrays. reward_probability_left, reward_probability_right : numpy.ndarray, optional Per-trial reward probabilities. go_cue_times : numpy.ndarray, optional Go-cue timestamps (s), used to map manual-water times to trials. - auto_water : pandas.DataFrame, optional - ``left``/``right`` autowater indicators per trial. + autowater_left, autowater_right : numpy.ndarray, optional + Per-trial autowater indicator arrays. manual_left_times, manual_right_times : numpy.ndarray, optional Manual-water delivery timestamps (s). bias_window : int, optional @@ -269,12 +291,14 @@ def plot_side_bias( axis.spines["right"].set_visible(False) _add_bias_plot(ax[0], animal_response, bias_window) - _add_lickspout_position_plot(ax[1], stage_positions) + _add_lickspout_position_plot(ax[1], lickspout_x, lickspout_y1, lickspout_y2, lickspout_z) _add_behavior_plot( ax[2], animal_response, - rewarded_history, - auto_water, + rewarded_left, + rewarded_right, + autowater_left, + autowater_right, manual_left_times, manual_right_times, go_cue_times, diff --git a/src/dynamic_foraging_processing/qc/processed/results.py b/src/dynamic_foraging_processing/qc/processed/results.py new file mode 100644 index 0000000..c3857e8 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/processed/results.py @@ -0,0 +1,93 @@ +"""Build the behavior QC results from per-trial and event-time arrays. + +Combines the side-bias and lick-interval checks into the ordered list of +``QCResult`` objects the processed stage returns, optionally writing the +supporting plots so the result references resolve. Convert the results to +schema metrics with ``to_metrics`` / ``QCResult.to_metric`` when assembling a +``QualityControl``. +""" + +import typing as t + +import numpy as np + +from dynamic_foraging_processing.qc._core.result import QCResult +from dynamic_foraging_processing.qc.processed.behavior import ( + lick_interval_results, + side_bias_result, +) +from dynamic_foraging_processing.qc.processed.plots import plot_lick_intervals, plot_side_bias + + +def behavior_qc_results( + animal_response: np.ndarray, + left_lick_times: np.ndarray, + right_lick_times: np.ndarray, + results_folder: t.Optional[str] = None, + *, + lickspout_x: t.Optional[np.ndarray] = None, + lickspout_y1: t.Optional[np.ndarray] = None, + lickspout_y2: t.Optional[np.ndarray] = None, + lickspout_z: t.Optional[np.ndarray] = None, + rewarded_left: t.Optional[np.ndarray] = None, + rewarded_right: t.Optional[np.ndarray] = None, + reward_probability_left: t.Optional[np.ndarray] = None, + reward_probability_right: t.Optional[np.ndarray] = None, + go_cue_times: t.Optional[np.ndarray] = None, + autowater_left: t.Optional[np.ndarray] = None, + autowater_right: t.Optional[np.ndarray] = None, + manual_left_times: t.Optional[np.ndarray] = None, + manual_right_times: t.Optional[np.ndarray] = None, +) -> t.List[QCResult]: + """Build the behavior QC results (side bias + lick intervals). + + When ``results_folder`` is provided, the supporting ``side_bias.png`` and + ``lick_intervals.png`` plots are written there so the result references + resolve. Convert the returned results to schema metrics with + ``to_metrics`` / ``QCResult.to_metric`` when assembling a ``QualityControl``. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + left_lick_times, right_lick_times : numpy.ndarray + Timestamps (s) of left/right-port licks. + results_folder : str, optional + Directory to write the plots into. If ``None``, plots are skipped. + lickspout_x, lickspout_y1, lickspout_y2, lickspout_z : numpy.ndarray, optional + Per-trial lickspout position arrays passed through to the side-bias figure. + rewarded_left, rewarded_right, autowater_left, autowater_right, \ +reward_probability_left, reward_probability_right : numpy.ndarray, optional + Per-trial arrays passed through to the side-bias figure. + go_cue_times, manual_left_times, manual_right_times : numpy.ndarray, optional + Event timestamps (s) passed through to the side-bias figure. + + Returns + ------- + list of QCResult + The average-side-bias result followed by the four lick-interval results. + """ + results = [ + side_bias_result(animal_response), + *lick_interval_results(left_lick_times, right_lick_times), + ] + if results_folder is not None: + plot_side_bias( + animal_response, + results_folder, + lickspout_x=lickspout_x, + lickspout_y1=lickspout_y1, + lickspout_y2=lickspout_y2, + lickspout_z=lickspout_z, + rewarded_left=rewarded_left, + rewarded_right=rewarded_right, + reward_probability_left=reward_probability_left, + reward_probability_right=reward_probability_right, + go_cue_times=go_cue_times, + autowater_left=autowater_left, + autowater_right=autowater_right, + manual_left_times=manual_left_times, + manual_right_times=manual_right_times, + ) + plot_lick_intervals(left_lick_times, right_lick_times, results_folder) + return results diff --git a/src/dynamic_foraging_processing/qc/processed/stage.py b/src/dynamic_foraging_processing/qc/processed/stage.py new file mode 100644 index 0000000..5847543 --- /dev/null +++ b/src/dynamic_foraging_processing/qc/processed/stage.py @@ -0,0 +1,87 @@ +"""Processed-data QC stage. + +``ProcessedQC`` wraps the behavior metrics computed from per-trial arrays +(side bias, lick intervals) into the ``BaseQC`` interface. It is a thin wrapper +over :func:`behavior_qc_results`; the metric computation lives there. +""" + +import typing as t + +import numpy as np +from aind_data_schema.core.quality_control import QCMetric + +from dynamic_foraging_processing.qc._core.base import BaseQC +from dynamic_foraging_processing.qc._core.result import to_metrics +from dynamic_foraging_processing.qc.processed.results import behavior_qc_results + + +class ProcessedQC(BaseQC): + """Behavior QC over the processed per-trial / event arrays.""" + + def run( + self, + animal_response: np.ndarray, + left_lick_times: np.ndarray, + right_lick_times: np.ndarray, + results_folder: t.Optional[str] = None, + *, + lickspout_x: t.Optional[np.ndarray] = None, + lickspout_y1: t.Optional[np.ndarray] = None, + lickspout_y2: t.Optional[np.ndarray] = None, + lickspout_z: t.Optional[np.ndarray] = None, + rewarded_left: t.Optional[np.ndarray] = None, + rewarded_right: t.Optional[np.ndarray] = None, + reward_probability_left: t.Optional[np.ndarray] = None, + reward_probability_right: t.Optional[np.ndarray] = None, + go_cue_times: t.Optional[np.ndarray] = None, + autowater_left: t.Optional[np.ndarray] = None, + autowater_right: t.Optional[np.ndarray] = None, + manual_left_times: t.Optional[np.ndarray] = None, + manual_right_times: t.Optional[np.ndarray] = None, + ) -> t.List[QCMetric]: + """Compute the behavior QC checks and return them as metrics. + + Parameters mirror :func:`behavior_qc_results`. When ``results_folder`` + is provided, the supporting plots are written there so the metric + references resolve. + + Parameters + ---------- + animal_response : numpy.ndarray + Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + left_lick_times, right_lick_times : numpy.ndarray + Timestamps (s) of left/right-port licks. + results_folder : str, optional + Directory to write the plots into. If ``None``, plots are skipped. + lickspout_x, lickspout_y1, lickspout_y2, lickspout_z, rewarded_left, \ +rewarded_right, autowater_left, autowater_right, reward_probability_left, \ +reward_probability_right : numpy.ndarray, optional + Optional per-trial arrays passed through to the side-bias figure. + go_cue_times, manual_left_times, manual_right_times : numpy.ndarray, optional + Optional event timestamps passed through to the side-bias figure. + + Returns + ------- + list of QCMetric + The side-bias metric followed by the four lick-interval metrics. + """ + results = behavior_qc_results( + animal_response, + left_lick_times, + right_lick_times, + results_folder, + lickspout_x=lickspout_x, + lickspout_y1=lickspout_y1, + lickspout_y2=lickspout_y2, + lickspout_z=lickspout_z, + rewarded_left=rewarded_left, + rewarded_right=rewarded_right, + reward_probability_left=reward_probability_left, + reward_probability_right=reward_probability_right, + go_cue_times=go_cue_times, + autowater_left=autowater_left, + autowater_right=autowater_right, + manual_left_times=manual_left_times, + manual_right_times=manual_right_times, + ) + return to_metrics(results) diff --git a/src/dynamic_foraging_processing/qc/raw/__init__.py b/src/dynamic_foraging_processing/qc/raw/__init__.py new file mode 100644 index 0000000..c3ba16d --- /dev/null +++ b/src/dynamic_foraging_processing/qc/raw/__init__.py @@ -0,0 +1,9 @@ +"""Raw-data QC stage: contract QA over a loaded raw dynamic foraging dataset.""" + +from dynamic_foraging_processing.qc.raw.contract_qa import ( + contract_qc_metrics, + results_to_metrics, +) +from dynamic_foraging_processing.qc.raw.stage import RawQC + +__all__ = ["RawQC", "contract_qc_metrics", "results_to_metrics"] From 40652fe8c374b23798d25d71f9476c2cd7d6bfe0 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 16:19:21 -0700 Subject: [PATCH 07/28] refactor: forgot these in previous commit --- .../qc/raw/contract_qa.py | 119 ++++++++++++++++++ .../qc/raw/stage.py | 41 ++++++ 2 files changed, 160 insertions(+) create mode 100644 src/dynamic_foraging_processing/qc/raw/contract_qa.py create mode 100644 src/dynamic_foraging_processing/qc/raw/stage.py diff --git a/src/dynamic_foraging_processing/qc/raw/contract_qa.py b/src/dynamic_foraging_processing/qc/raw/contract_qa.py new file mode 100644 index 0000000..c36647e --- /dev/null +++ b/src/dynamic_foraging_processing/qc/raw/contract_qa.py @@ -0,0 +1,119 @@ +"""Convert ``contraqctor`` QA runner results into ``QCMetric`` objects. + +The dynamic foraging contract QA (Harp devices, cameras, CSV streams, the data +contract, and task-specific checks) is provided by +``aind_behavior_dynamic_foraging.data_qc.make_qc_runner``. This module runs that +runner over a dataset and maps each ``contraqctor`` ``Result`` onto a schema +``QCMetric``, tagged so the QC portal groups them under ``test_suite``. +""" + +import os +import re +import typing as t + +import matplotlib.figure +from aind_behavior_dynamic_foraging.data_qc.suite import make_qc_runner +from aind_data_schema.core.quality_control import QCMetric, QCStatus, Stage +from aind_data_schema_models.modalities import Modality +from contraqctor import contract, qc + +from dynamic_foraging_processing.qc._core.schema import STATUS_CONVERTER, now_utc, to_builtin + +#: Group value used when a runner result has no group. +NO_GROUP = "NoGroup" + + +def _sanitize(name: str) -> str: + """Make ``name`` safe to use as a filename component.""" + return re.sub(r"[^0-9A-Za-z._-]+", "_", name) + + +def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optional[str]: + """Save a result's figure asset (if any) and return its relative path. + + Parameters + ---------- + result : contraqctor.qc.Result + A single QA result; its ``context["asset"]`` may be a matplotlib figure. + results_folder : str or None + Directory to save figures into. If ``None``, nothing is saved. + + Returns + ------- + str or None + The saved figure's filename, or ``None`` when there is no figure asset + (or no ``results_folder``). + """ + context = result.context + if not isinstance(context, dict): + return None + asset = context.get("asset") + if not isinstance(asset, matplotlib.figure.Figure) or results_folder is None: + return None + filename = f"{_sanitize(result.suite_name)}_{_sanitize(result.test_name)}.png" + asset.savefig(os.path.join(results_folder, filename), dpi=300, bbox_inches="tight") + return filename + + +def results_to_metrics( + results: t.Dict[t.Optional[str], t.List[qc.Result]], + results_folder: t.Optional[str] = None, +) -> t.List[QCMetric]: + """Convert grouped ``contraqctor`` results into ``QCMetric`` objects. + + Parameters + ---------- + results : dict + Mapping of group name to list of ``contraqctor`` ``Result`` objects, as + returned by ``contraqctor.qc.Runner.run_all``. + results_folder : str, optional + Directory to save figure assets into. If ``None``, assets are skipped. + + Returns + ------- + list of QCMetric + One metric per result, tagged ``{"test_suite": suite, suite: group}``. + """ + metrics: t.List[QCMetric] = [] + for group, group_results in results.items(): + group_name = group if group is not None else NO_GROUP + for result in group_results: + status = QCStatus( + evaluator="Automated", + status=STATUS_CONVERTER[result.status], + timestamp=now_utc(), + ) + metrics.append( + QCMetric( + name=f"{result.suite_name}::{result.test_name}", + modality=Modality.BEHAVIOR, + stage=Stage.RAW, + value=to_builtin(result.result), + status_history=[status], + description=f"Test: {result.description} // Message: {result.message}", + reference=_save_asset(result, results_folder), + tags={"test_suite": result.suite_name, result.suite_name: group_name}, + ) + ) + return metrics + + +def contract_qc_metrics( + dataset: contract.Dataset, results_folder: t.Optional[str] = None +) -> t.List[QCMetric]: + """Run the dynamic foraging contract QA over a dataset and convert results. + + Parameters + ---------- + dataset : contraqctor.contract.Dataset + A dynamic foraging dataset (e.g. ``RawDataLoader.dataset``). + results_folder : str, optional + Directory to save figure assets into. If ``None``, assets are skipped. + + Returns + ------- + list of QCMetric + Converted QA metrics for every suite the runner wires up. + """ + runner = make_qc_runner(dataset) + return results_to_metrics(runner.run_all(), results_folder) diff --git a/src/dynamic_foraging_processing/qc/raw/stage.py b/src/dynamic_foraging_processing/qc/raw/stage.py new file mode 100644 index 0000000..0bbf73f --- /dev/null +++ b/src/dynamic_foraging_processing/qc/raw/stage.py @@ -0,0 +1,41 @@ +"""Raw-data QC stage. + +``RawQC`` wraps the ``contraqctor``-based contract QA (Harp devices, cameras, +CSV streams, the data contract, task-specific checks) into the ``BaseQC`` +interface. It is a thin wrapper over :func:`contract_qc_metrics`; the metric +computation lives there. +""" + +import typing as t + +from aind_data_schema.core.quality_control import QCMetric +from contraqctor import contract + +from dynamic_foraging_processing.qc._core.base import BaseQC +from dynamic_foraging_processing.qc.raw.contract_qa import contract_qc_metrics + + +class RawQC(BaseQC): + """Contract QA over a loaded raw dynamic foraging dataset.""" + + def run( + self, + acquisition: contract.Dataset, + results_folder: t.Optional[str] = None, + ) -> t.List[QCMetric]: + """Run the contract QA over ``acquisition`` and return its metrics. + + Parameters + ---------- + acquisition : contraqctor.contract.Dataset + A loaded dynamic foraging dataset (e.g. ``RawDataLoader.dataset``). + results_folder : str, optional + Directory to save figure assets into. If ``None``, assets are + skipped. + + Returns + ------- + list of QCMetric + Converted QA metrics for every suite the runner wires up. + """ + return contract_qc_metrics(acquisition, results_folder) From d06260ff35ea806b8aeeb401edc4ba664a7ed73b Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 16:19:36 -0700 Subject: [PATCH 08/28] test: update tests --- tests/test_qc/test_behavior.py | 4 +- tests/test_qc/test_builder.py | 16 ++++---- tests/test_qc/test_contract_qa.py | 4 +- tests/test_qc/test_plots.py | 42 +++++++------------- tests/test_qc/test_result.py | 4 +- tests/test_qc/test_schema.py | 4 +- tests/test_qc/test_stages.py | 66 +++++++++++++++++++++++++++++++ 7 files changed, 97 insertions(+), 43 deletions(-) create mode 100644 tests/test_qc/test_stages.py diff --git a/tests/test_qc/test_behavior.py b/tests/test_qc/test_behavior.py index dafd701..54a0ca0 100644 --- a/tests/test_qc/test_behavior.py +++ b/tests/test_qc/test_behavior.py @@ -1,9 +1,9 @@ -"""Tests for ``dynamic_foraging_processing.qc._behavior``.""" +"""Tests for ``dynamic_foraging_processing.qc.processed.behavior``.""" import numpy as np import pytest -from dynamic_foraging_processing.qc import _behavior +from dynamic_foraging_processing.qc.processed import behavior as _behavior def test_calculate_lick_intervals_both_empty(): diff --git a/tests/test_qc/test_builder.py b/tests/test_qc/test_builder.py index 863fab9..3b86b98 100644 --- a/tests/test_qc/test_builder.py +++ b/tests/test_qc/test_builder.py @@ -1,17 +1,19 @@ -"""Tests for ``dynamic_foraging_processing.qc._builder``.""" +"""Tests for ``dynamic_foraging_processing.qc._core.builder`` and +``dynamic_foraging_processing.qc.processed.results``.""" import os import numpy as np from aind_data_schema.core.quality_control import QualityControl -from dynamic_foraging_processing.qc import _builder -from dynamic_foraging_processing.qc._result import to_metrics +from dynamic_foraging_processing.qc._core import builder as _builder +from dynamic_foraging_processing.qc._core.result import to_metrics +from dynamic_foraging_processing.qc.processed import results as _results def test_behavior_qc_results_without_plots(): """Five behavior results are produced and no plots are written.""" - results = _builder.behavior_qc_results( + results = _results.behavior_qc_results( np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]) ) assert len(results) == 5 @@ -20,7 +22,7 @@ def test_behavior_qc_results_without_plots(): def test_behavior_qc_results_writes_plots(tmp_path): """Supplying a results folder writes both behavior plots.""" - results = _builder.behavior_qc_results( + results = _results.behavior_qc_results( np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]), @@ -34,7 +36,7 @@ def test_behavior_qc_results_writes_plots(tmp_path): def test_build_quality_control_defaults(): """Defaults fill in the standard grouping and an empty failure allowlist.""" metrics = to_metrics( - _builder.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + _results.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) ) qc = _builder.build_quality_control(metrics) assert isinstance(qc, QualityControl) @@ -45,7 +47,7 @@ def test_build_quality_control_defaults(): def test_build_quality_control_overrides(): """Explicit grouping / allowlist / metadata are passed through.""" metrics = to_metrics( - _builder.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + _results.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) ) qc = _builder.build_quality_control( metrics, diff --git a/tests/test_qc/test_contract_qa.py b/tests/test_qc/test_contract_qa.py index e224dc7..199e427 100644 --- a/tests/test_qc/test_contract_qa.py +++ b/tests/test_qc/test_contract_qa.py @@ -1,4 +1,4 @@ -"""Tests for ``dynamic_foraging_processing.qc._contract_qa``.""" +"""Tests for ``dynamic_foraging_processing.qc.raw.contract_qa``.""" import os @@ -9,7 +9,7 @@ import matplotlib.pyplot as plt from contraqctor import qc as cqc -from dynamic_foraging_processing.qc import _contract_qa +from dynamic_foraging_processing.qc.raw import contract_qa as _contract_qa def _result( diff --git a/tests/test_qc/test_plots.py b/tests/test_qc/test_plots.py index cce7f6b..983a396 100644 --- a/tests/test_qc/test_plots.py +++ b/tests/test_qc/test_plots.py @@ -1,11 +1,10 @@ -"""Tests for ``dynamic_foraging_processing.qc._plots``.""" +"""Tests for ``dynamic_foraging_processing.qc.processed.plots``.""" import os import numpy as np -import pandas as pd -from dynamic_foraging_processing.qc import _plots +from dynamic_foraging_processing.qc.processed import plots as _plots def test_plot_lick_intervals_writes_file(tmp_path): @@ -27,33 +26,22 @@ def test_time_to_trial_index_covers_all_branches(): def test_plot_side_bias_full_inputs(tmp_path): - """All optional panels render when every input is supplied.""" + """All optional panels render when every per-trial array is supplied.""" animal_response = np.array([0, 1, 2, 1, 0, 1]) - stage_positions = pd.DataFrame( - { - "x": [1.0, 1.1, 1.0, 1.2, 1.1, 1.0], - "y1": [2.0, 2.0, 2.1, 2.0, 2.0, 2.1], - "y2": [3.0, 3.1, 3.0, 3.1, 3.0, 3.1], - "z": [4.0, 4.0, 4.0, 4.1, 4.0, 4.0], - "ignored_column": [0, 0, 0, 0, 0, 0], # not in the color map -> skipped - } - ) - rewarded_history = pd.DataFrame( - { - "left": [True, False, False, False, True, False], - "right": [False, True, False, True, False, True], - } - ) - auto_water = pd.DataFrame({"left": [1, 0, 0, 0, 0, 0], "right": [0, 0, 0, 1, 0, 0]}) name = _plots.plot_side_bias( animal_response, str(tmp_path), - stage_positions=stage_positions, - rewarded_history=rewarded_history, + lickspout_x=np.array([1.0, 1.1, 1.0, 1.2, 1.1, 1.0]), + lickspout_y1=np.array([2.0, 2.0, 2.1, 2.0, 2.0, 2.1]), + lickspout_y2=np.array([3.0, 3.1, 3.0, 3.1, 3.0, 3.1]), + lickspout_z=np.array([4.0, 4.0, 4.0, 4.1, 4.0, 4.0]), + rewarded_left=np.array([True, False, False, False, True, False]), + rewarded_right=np.array([False, True, False, True, False, True]), reward_probability_left=np.array([0.5, 0.6, 0.4, 0.5, 0.5, 0.6]), reward_probability_right=np.array([0.5, 0.4, 0.6, 0.5, 0.5, 0.4]), go_cue_times=np.array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5]), - auto_water=auto_water, + autowater_left=np.array([1, 0, 0, 0, 0, 0]), + autowater_right=np.array([0, 0, 0, 1, 0, 0]), manual_left_times=np.array([0.1, 3.6]), # 0.1 -> -1, 3.6 -> trial index manual_right_times=np.array([5.6]), bias_window=3, @@ -68,9 +56,7 @@ def test_plot_side_bias_minimal_inputs(tmp_path): assert os.path.exists(tmp_path / name) -def test_plot_side_bias_empty_stage_positions(tmp_path): - """An empty stage-positions frame is handled without plotting positions.""" - name = _plots.plot_side_bias( - np.array([0, 1]), str(tmp_path), stage_positions=pd.DataFrame({"x": []}) - ) +def test_plot_side_bias_empty_position_array(tmp_path): + """An empty lickspout-position array is skipped without plotting.""" + name = _plots.plot_side_bias(np.array([0, 1]), str(tmp_path), lickspout_x=np.array([])) assert os.path.exists(tmp_path / name) diff --git a/tests/test_qc/test_result.py b/tests/test_qc/test_result.py index b2be468..23f4753 100644 --- a/tests/test_qc/test_result.py +++ b/tests/test_qc/test_result.py @@ -1,6 +1,6 @@ -"""Tests for ``dynamic_foraging_processing.qc._result``.""" +"""Tests for ``dynamic_foraging_processing.qc._core.result``.""" -from dynamic_foraging_processing.qc import _result +from dynamic_foraging_processing.qc._core import result as _result def _result_obj(passed=True): diff --git a/tests/test_qc/test_schema.py b/tests/test_qc/test_schema.py index 6f5ec10..ab017ed 100644 --- a/tests/test_qc/test_schema.py +++ b/tests/test_qc/test_schema.py @@ -1,4 +1,4 @@ -"""Tests for ``dynamic_foraging_processing.qc._schema``.""" +"""Tests for ``dynamic_foraging_processing.qc._core.schema``.""" import datetime @@ -7,7 +7,7 @@ from aind_data_schema_models.modalities import Modality from contraqctor import qc as cqc -from dynamic_foraging_processing.qc import _schema +from dynamic_foraging_processing.qc._core import schema as _schema def test_status_converter_maps_all_contraqctor_statuses(): diff --git a/tests/test_qc/test_stages.py b/tests/test_qc/test_stages.py new file mode 100644 index 0000000..71caf4a --- /dev/null +++ b/tests/test_qc/test_stages.py @@ -0,0 +1,66 @@ +"""Tests for the QC stage wrappers (``BaseQC``, ``RawQC``, ``ProcessedQC``).""" + +import os + +import numpy as np +import pytest +from aind_data_schema.core.quality_control import QCMetric + +from dynamic_foraging_processing.qc._core.base import BaseQC +from dynamic_foraging_processing.qc.processed.stage import ProcessedQC +from dynamic_foraging_processing.qc.raw import stage as raw_stage +from dynamic_foraging_processing.qc.raw.stage import RawQC + + +def test_base_qc_run_raises_not_implemented(): + """The base ``run`` body raises ``NotImplementedError`` when delegated to.""" + + class _Stage(BaseQC): + """Concrete stage that defers to the base implementation.""" + + def run(self, *args, **kwargs): + """Delegate to ``BaseQC.run`` so its body executes.""" + return super().run(*args, **kwargs) + + with pytest.raises(NotImplementedError): + _Stage().run() + + +def test_raw_qc_run_delegates_to_contract_metrics(monkeypatch): + """``RawQC.run`` forwards the dataset and folder to ``contract_qc_metrics``.""" + captured = {} + + def _fake_contract_qc_metrics(dataset, results_folder): + """Record arguments and return a sentinel metric list.""" + captured["dataset"] = dataset + captured["results_folder"] = results_folder + return ["sentinel"] + + monkeypatch.setattr(raw_stage, "contract_qc_metrics", _fake_contract_qc_metrics) + dataset = object() + result = RawQC().run(dataset, "out") + assert result == ["sentinel"] + assert captured == {"dataset": dataset, "results_folder": "out"} + + +def test_processed_qc_run_returns_metrics(): + """``ProcessedQC.run`` produces the five behavior metrics.""" + metrics = ProcessedQC().run( + np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]) + ) + assert len(metrics) == 5 + assert all(isinstance(m, QCMetric) for m in metrics) + assert metrics[0].name == "average side bias" + + +def test_processed_qc_run_writes_plots(tmp_path): + """Supplying a results folder writes the supporting plots.""" + metrics = ProcessedQC().run( + np.array([0, 1, 2, 1]), + np.array([1.0, 1.01]), + np.array([2.0, 2.01]), + str(tmp_path), + ) + assert len(metrics) == 5 + assert os.path.exists(tmp_path / "side_bias.png") + assert os.path.exists(tmp_path / "lick_intervals.png") From eec629d0fa5546be3c87ce5cf27674e5e9351b1c Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 16:19:47 -0700 Subject: [PATCH 09/28] feat: add example notebook --- examples/qc_example.ipynb | 415 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 415 insertions(+) create mode 100644 examples/qc_example.ipynb diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb new file mode 100644 index 0000000..9bed57c --- /dev/null +++ b/examples/qc_example.ipynb @@ -0,0 +1,415 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "205e6429", + "metadata": {}, + "source": [ + "# Quality Control Example\n", + "\n", + "This notebook demonstrates the `dynamic_foraging_processing.qc` module: the\n", + "**metrics** that can be gathered and the **plots** that can be produced from the\n", + "per-trial `animal_response` (`0` left, `1` right, `2` ignore).\n", + "\n", + "It uses **synthetic data** (no dataset loading) so it runs anywhere, mirroring\n", + "the arrays used in the unit tests. Swap in a real session's `animal_response`\n", + "(e.g. the `animal_response` column from `TrialTableBuilder.build()`) to use it\n", + "for real." + ] + }, + { + "cell_type": "markdown", + "id": "75bdf3a3", + "metadata": {}, + "source": [ + "## Create synthetic data\n", + "\n", + "A random per-trial choice sequence, plus the optional per-trial context the\n", + "side-bias figure can display (reward history, reward probabilities, autowater,\n", + "go-cue times). None of this needs a dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "72ca85eb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n trials: 200\n", + "left (0): 70\n", + "right (1): 100\n", + "ignore(2): 30\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "rng = np.random.default_rng(0)\n", + "n_trials = 200\n", + "\n", + "# Choice per trial: 0 left, 1 right, 2 ignore (slightly right-biased here).\n", + "animal_response = rng.choice([0, 1, 2], size=n_trials, p=[0.4, 0.5, 0.1])\n", + "\n", + "# Optional per-trial context (synthetic), one array per column.\n", + "rewarded_left = (animal_response == 0) & (rng.random(n_trials) < 0.5)\n", + "rewarded_right = (animal_response == 1) & (rng.random(n_trials) < 0.5)\n", + "autowater_left = np.zeros(n_trials, int)\n", + "autowater_right = np.zeros(n_trials, int)\n", + "reward_probability_left = np.full(n_trials, 0.4)\n", + "reward_probability_right = np.full(n_trials, 0.6)\n", + "go_cue_times = np.arange(n_trials, dtype=float)\n", + "\n", + "print(\"n trials:\", n_trials)\n", + "print(\"left (0):\", int(np.sum(animal_response == 0)))\n", + "print(\"right (1):\", int(np.sum(animal_response == 1)))\n", + "print(\"ignore(2):\", int(np.sum(animal_response == 2)))" + ] + }, + { + "cell_type": "markdown", + "id": "f4981f30", + "metadata": {}, + "source": [ + "## Metrics from `animal_response`\n", + "\n", + "### Average side bias\n", + "`compute_side_bias` returns `mean(is_right) - mean(is_left)` over responded\n", + "trials, in `[-1, +1]` (positive = rightward bias)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "abb13a1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "average side bias: 0.176\n" + ] + } + ], + "source": [ + "from dynamic_foraging_processing.qc import compute_side_bias\n", + "\n", + "mean_bias = compute_side_bias(animal_response)\n", + "print(f\"average side bias: {mean_bias:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ffd21348", + "metadata": {}, + "source": [ + "### Rolling side bias (with confidence band)\n", + "`compute_rolling_bias` returns a trailing-window bias trace and a 95% normal-\n", + "approximation confidence interval, one row per trial." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5d4f0143", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bias shape: (200,) | ci shape: (200, 2)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
biasci_lowci_high
01.0000001.0000001.000000
10.000000-1.3859291.385929
2-0.333333-1.4002220.733556
3-0.500000-1.3487050.348705
4-0.200000-1.0588290.658829
\n", + "
" + ], + "text/plain": [ + " bias ci_low ci_high\n", + "0 1.000000 1.000000 1.000000\n", + "1 0.000000 -1.385929 1.385929\n", + "2 -0.333333 -1.400222 0.733556\n", + "3 -0.500000 -1.348705 0.348705\n", + "4 -0.200000 -1.058829 0.658829" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dynamic_foraging_processing.qc import compute_rolling_bias\n", + "\n", + "bias, ci = compute_rolling_bias(animal_response, window=20)\n", + "print(\"bias shape:\", bias.shape, \"| ci shape:\", ci.shape)\n", + "pd.DataFrame({\"bias\": bias, \"ci_low\": ci[:, 0], \"ci_high\": ci[:, 1]}).head()" + ] + }, + { + "cell_type": "markdown", + "id": "45cf1958", + "metadata": {}, + "source": [ + "### As a QC result / metric\n", + "`side_bias_result` wraps the scalar into a `QCResult` (pass when\n", + "`abs(bias) < 0.5`), which converts to an `aind_data_schema` `QCMetric`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "58755f21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "name: average side bias\n", + "value: 0.17647058823529416\n", + "passed: True\n", + "tags: {'behavior': 'average side bias'}\n" + ] + }, + { + "data": { + "text/plain": [ + "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.17647058823529416, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 17, 16, 17, 0, 236255, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias over responded trials (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dynamic_foraging_processing.qc import side_bias_result\n", + "\n", + "result = side_bias_result(animal_response)\n", + "print(\"name: \", result.name)\n", + "print(\"value: \", result.value)\n", + "print(\"passed: \", result.passed)\n", + "print(\"tags: \", result.tags)\n", + "\n", + "metric = result.to_metric()\n", + "metric" + ] + }, + { + "cell_type": "markdown", + "id": "bb6846a3", + "metadata": {}, + "source": [ + "## Plot: side-bias figure\n", + "\n", + "`plot_side_bias` writes a four-panel `side_bias.png` into a results folder:\n", + "rolling side bias, lickspout position, per-trial behavior raster, and reward\n", + "probabilities. It is driven by `animal_response`; the remaining panels are\n", + "populated from the optional per-trial context created above." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "72a51175", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'side_bias.png'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "from dynamic_foraging_processing.qc import plot_side_bias\n", + "\n", + "results_folder = Path(\"qc_results\")\n", + "results_folder.mkdir(exist_ok=True)\n", + "\n", + "plot_side_bias(\n", + " animal_response,\n", + " str(results_folder),\n", + " rewarded_left=rewarded_left,\n", + " rewarded_right=rewarded_right,\n", + " reward_probability_left=reward_probability_left,\n", + " reward_probability_right=reward_probability_right,\n", + " go_cue_times=go_cue_times,\n", + " autowater_left=autowater_left,\n", + " autowater_right=autowater_right,\n", + " bias_window=20,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0a361145", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(filename=str(results_folder / \"side_bias.png\"))" + ] + }, + { + "cell_type": "markdown", + "id": "4d34d523", + "metadata": {}, + "source": [ + "## Assemble a `QualityControl` object\n", + "\n", + "Collect the behavior metric(s) into a single `QualityControl`. In a real\n", + "pipeline you would also append the automated contract-QA metrics\n", + "(`contract_qc_metrics(dataset, ...)`), which require a loaded dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bf1b9b08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total metrics: 1\n", + "default grouping: ['behavior', 'test_suite']\n" + ] + }, + { + "data": { + "text/plain": [ + "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.17647058823529416, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 17, 16, 17, 0, 236255, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias over responded trials (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:average side bias': , 'behavior': , 'Raw data': })" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dynamic_foraging_processing.qc import build_quality_control\n", + "\n", + "quality_control = build_quality_control([metric])\n", + "print(\"total metrics:\", len(quality_control.metrics))\n", + "print(\"default grouping:\", quality_control.default_grouping)\n", + "quality_control" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56793aff", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dynamic-foraging-processing", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a32318b92de28202f63fd7356231d29bc71101c7 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 18:08:35 -0700 Subject: [PATCH 10/28] fix: don't return 0 if no trials responded to --- src/dynamic_foraging_processing/qc/processed/behavior.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/processed/behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py index 73518f2..7634c9c 100644 --- a/src/dynamic_foraging_processing/qc/processed/behavior.py +++ b/src/dynamic_foraging_processing/qc/processed/behavior.py @@ -120,12 +120,12 @@ def compute_side_bias(animal_response: np.ndarray) -> float: Returns ------- float - The average side bias, or ``0.0`` if no trial was responded to. + The average side bias, or ``nan`` if no trial was responded to. """ responses = np.asarray(animal_response) responded = responses != _IGNORE if not responded.any(): - return 0.0 + return float("nan") chosen = responses[responded] return float(np.mean(chosen == _RIGHT) - np.mean(chosen == _LEFT)) @@ -180,7 +180,8 @@ def side_bias_result(animal_response: np.ndarray) -> QCResult: Returns ------- QCResult - Passes when ``abs(mean_bias) < 0.5``; tagged ``{"behavior": ...}`` and + Passes when ``abs(mean_bias) < 0.5``. Fails when no trial was responded + to (``mean_bias`` is ``nan``). Tagged ``{"behavior": ...}`` and referencing ``side_bias.png``. """ mean_bias = compute_side_bias(animal_response) @@ -188,7 +189,7 @@ def side_bias_result(animal_response: np.ndarray) -> QCResult: return QCResult( name=name, value=mean_bias, - passed=abs(mean_bias) < 0.5, + passed=bool(abs(mean_bias) < 0.5), # nan comparisons are False -> fails description="Average side bias over responded trials (right minus left).", reference=SIDE_BIAS_PLOT, tags={"behavior": name}, From 39e8a52e54f0066dd44241447be5d3773212f2cd Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Wed, 17 Jun 2026 18:08:42 -0700 Subject: [PATCH 11/28] test: update tests --- tests/test_qc/test_behavior.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/test_qc/test_behavior.py b/tests/test_qc/test_behavior.py index 54a0ca0..9a8ff5b 100644 --- a/tests/test_qc/test_behavior.py +++ b/tests/test_qc/test_behavior.py @@ -44,10 +44,10 @@ def test_calculate_lick_intervals_detects_artifacts(): def test_compute_side_bias_balanced_and_all_ignore(): - """Bias is right-minus-left over responses; all-ignore gives 0.""" + """Bias is right-minus-left over responses; all-ignore gives nan.""" assert _behavior.compute_side_bias(np.array([0, 1, 0, 1])) == 0.0 assert _behavior.compute_side_bias(np.array([1, 1, 1, 0])) == pytest.approx(0.5) - assert _behavior.compute_side_bias(np.array([2, 2, 2])) == 0.0 + assert np.isnan(_behavior.compute_side_bias(np.array([2, 2, 2]))) def test_compute_rolling_bias_shapes_and_empty_window(): @@ -70,6 +70,10 @@ def test_side_bias_result_pass_and_fail(): failing = _behavior.side_bias_result(np.array([1, 1, 1, 1])) assert failing.passed is False + no_response = _behavior.side_bias_result(np.array([2, 2, 2])) + assert no_response.passed is False + assert np.isnan(no_response.value) + def test_lick_interval_results_names_and_count(): """Four lick-interval results are produced with the expected names/tags.""" From 66e3ef5faac116bfabfc3e16eae362e8e28ff314 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 18 Jun 2026 16:47:25 -0700 Subject: [PATCH 12/28] refactor: don't re-calculate side bias --- .../qc/__init__.py | 4 - .../qc/processed/__init__.py | 4 - .../qc/processed/behavior.py | 89 ++++--------------- .../qc/processed/plots.py | 20 ++--- .../qc/processed/results.py | 6 +- .../qc/processed/stage.py | 4 + 6 files changed, 33 insertions(+), 94 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/__init__.py b/src/dynamic_foraging_processing/qc/__init__.py index 6f10b7b..44c2907 100644 --- a/src/dynamic_foraging_processing/qc/__init__.py +++ b/src/dynamic_foraging_processing/qc/__init__.py @@ -29,8 +29,6 @@ ProcessedQC, behavior_qc_results, calculate_lick_intervals, - compute_rolling_bias, - compute_side_bias, lick_interval_results, plot_lick_intervals, plot_side_bias, @@ -53,8 +51,6 @@ "bool_to_status", "build_quality_control", "calculate_lick_intervals", - "compute_rolling_bias", - "compute_side_bias", "contract_qc_metrics", "lick_interval_results", "make_metric", diff --git a/src/dynamic_foraging_processing/qc/processed/__init__.py b/src/dynamic_foraging_processing/qc/processed/__init__.py index 3aa7252..8a67d12 100644 --- a/src/dynamic_foraging_processing/qc/processed/__init__.py +++ b/src/dynamic_foraging_processing/qc/processed/__init__.py @@ -2,8 +2,6 @@ from dynamic_foraging_processing.qc.processed.behavior import ( calculate_lick_intervals, - compute_rolling_bias, - compute_side_bias, lick_interval_results, side_bias_result, ) @@ -18,8 +16,6 @@ "ProcessedQC", "behavior_qc_results", "calculate_lick_intervals", - "compute_rolling_bias", - "compute_side_bias", "lick_interval_results", "plot_lick_intervals", "plot_side_bias", diff --git a/src/dynamic_foraging_processing/qc/processed/behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py index 7634c9c..cca1941 100644 --- a/src/dynamic_foraging_processing/qc/processed/behavior.py +++ b/src/dynamic_foraging_processing/qc/processed/behavior.py @@ -17,9 +17,6 @@ SIDE_BIAS_PLOT = "side_bias.png" LICK_INTERVALS_PLOT = "lick_intervals.png" -#: ``animal_response`` choice codes. -_LEFT, _RIGHT, _IGNORE = 0, 1, 2 - def calculate_lick_intervals( left_lick_times: np.ndarray, right_lick_times: np.ndarray @@ -105,92 +102,36 @@ def calculate_lick_intervals( } -def compute_side_bias(animal_response: np.ndarray) -> float: - """Compute the average side bias over responded trials. +def side_bias_result(side_bias: np.ndarray) -> QCResult: + """Build the average-side-bias ``QCResult`` from the trial-table column. - Bias is ``mean(is_right) - mean(is_left)`` across trials where the animal - responded (``ignore`` trials excluded). The result lies in ``[-1, +1]``; - positive means a rightward bias. + The per-trial side bias is read directly from the trial table rather than + recomputed; this check averages it over the session. Parameters ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). - - Returns - ------- - float - The average side bias, or ``nan`` if no trial was responded to. - """ - responses = np.asarray(animal_response) - responded = responses != _IGNORE - if not responded.any(): - return float("nan") - chosen = responses[responded] - return float(np.mean(chosen == _RIGHT) - np.mean(chosen == _LEFT)) - - -def compute_rolling_bias( - animal_response: np.ndarray, window: int = 20 -) -> t.Tuple[np.ndarray, np.ndarray]: - """Compute a trailing-window side-bias trace with a normal-approx CI. - - For each trial, the bias is ``p_right - p_left`` over responded trials in - the trailing ``window``; the confidence band is a 95% normal approximation - for that difference. Replaces the GUI-precomputed ``B_Bias`` / ``B_Bias_CI``. - - Parameters - ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). - window : int, optional - Number of trailing trials in the rolling window. Defaults to ``20``. - - Returns - ------- - tuple of numpy.ndarray - ``(bias, ci)`` where ``bias`` has shape ``(n_trials,)`` and ``ci`` has - shape ``(n_trials, 2)``. Trials with no responses are ``nan``. - """ - responses = np.asarray(animal_response) - n = len(responses) - bias = np.full(n, np.nan) - ci = np.full((n, 2), np.nan) - for i in range(n): - window_slice = responses[max(0, i - window + 1) : i + 1] - chosen = window_slice[window_slice != _IGNORE] - if len(chosen) == 0: - continue - p_right = float(np.mean(chosen == _RIGHT)) - b = 2.0 * p_right - 1.0 # p_right - p_left, since p_left + p_right == 1 - se = 2.0 * np.sqrt(p_right * (1.0 - p_right) / len(chosen)) - bias[i] = b - ci[i] = (b - 1.96 * se, b + 1.96 * se) - return bias, ci - - -def side_bias_result(animal_response: np.ndarray) -> QCResult: - """Build the average-side-bias ``QCResult``. - - Parameters - ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + side_bias : numpy.ndarray + Per-trial side bias from the trial table (right minus left); positive + means a rightward bias. Trials with no response are ``nan``. Returns ------- QCResult - Passes when ``abs(mean_bias) < 0.5``. Fails when no trial was responded - to (``mean_bias`` is ``nan``). Tagged ``{"behavior": ...}`` and + Passes when ``abs(mean_bias) < 0.5``. Fails when the column is empty or + all ``nan`` (``mean_bias`` is ``nan``). Tagged ``{"behavior": ...}`` and referencing ``side_bias.png``. """ - mean_bias = compute_side_bias(animal_response) + values = np.asarray(side_bias, dtype=float) + if values.size == 0 or np.all(np.isnan(values)): + mean_bias = float("nan") + else: + mean_bias = float(np.nanmean(values)) name = "average side bias" return QCResult( name=name, value=mean_bias, passed=bool(abs(mean_bias) < 0.5), # nan comparisons are False -> fails - description="Average side bias over responded trials (right minus left).", + description="Average of the per-trial side bias (right minus left).", reference=SIDE_BIAS_PLOT, tags={"behavior": name}, ) diff --git a/src/dynamic_foraging_processing/qc/processed/plots.py b/src/dynamic_foraging_processing/qc/processed/plots.py index 56cd416..f2c2168 100644 --- a/src/dynamic_foraging_processing/qc/processed/plots.py +++ b/src/dynamic_foraging_processing/qc/processed/plots.py @@ -18,7 +18,6 @@ from dynamic_foraging_processing.qc.processed.behavior import ( LICK_INTERVALS_PLOT, SIDE_BIAS_PLOT, - compute_rolling_bias, ) @@ -86,8 +85,8 @@ def plot_lick_intervals( return LICK_INTERVALS_PLOT -def _add_bias_plot(ax: plt.Axes, animal_response: np.ndarray, window: int) -> None: - """Draw the rolling side-bias trace with its confidence band.""" +def _add_bias_plot(ax: plt.Axes, side_bias: np.ndarray) -> None: + """Draw the per-trial side-bias trace from the trial-table column.""" ax.set_xlabel("Trial #") ax.set_ylabel("Side Bias") ax.axhline(+0.7, color="r", linestyle="--") @@ -95,9 +94,8 @@ def _add_bias_plot(ax: plt.Axes, animal_response: np.ndarray, window: int) -> No ax.axhline(0, color="k", linestyle="--") ax.set_ylim([-1, +1]) - bias, ci = compute_rolling_bias(animal_response, window=window) + bias = np.asarray(side_bias, dtype=float) trials = np.arange(len(bias)) - ax.fill_between(trials, ci[:, 0], ci[:, 1], color="gray", alpha=0.5) ax.plot(trials, bias, "k", linewidth=2) if len(bias): ax.set_xlim([0, len(bias)]) @@ -236,6 +234,7 @@ def _add_reward_probabilities( def plot_side_bias( animal_response: np.ndarray, + side_bias: np.ndarray, results_folder: str, *, lickspout_x: t.Optional[np.ndarray] = None, @@ -251,17 +250,18 @@ def plot_side_bias( autowater_right: t.Optional[np.ndarray] = None, manual_left_times: t.Optional[np.ndarray] = None, manual_right_times: t.Optional[np.ndarray] = None, - bias_window: int = 20, ) -> str: """Save the four-panel side-bias figure. - Panels: rolling side bias (with CI), lickspout position, behavior raster, - and reward probabilities. + Panels: per-trial side bias, lickspout position, behavior raster, and + reward probabilities. Parameters ---------- animal_response : numpy.ndarray Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + side_bias : numpy.ndarray + Per-trial side bias from the trial table (right minus left). results_folder : str Directory to write ``side_bias.png`` into. lickspout_x, lickspout_y1, lickspout_y2, lickspout_z : numpy.ndarray, optional @@ -276,8 +276,6 @@ def plot_side_bias( Per-trial autowater indicator arrays. manual_left_times, manual_right_times : numpy.ndarray, optional Manual-water delivery timestamps (s). - bias_window : int, optional - Trailing window for the rolling bias. Defaults to ``20``. Returns ------- @@ -290,7 +288,7 @@ def plot_side_bias( axis.spines["top"].set_visible(False) axis.spines["right"].set_visible(False) - _add_bias_plot(ax[0], animal_response, bias_window) + _add_bias_plot(ax[0], side_bias) _add_lickspout_position_plot(ax[1], lickspout_x, lickspout_y1, lickspout_y2, lickspout_z) _add_behavior_plot( ax[2], diff --git a/src/dynamic_foraging_processing/qc/processed/results.py b/src/dynamic_foraging_processing/qc/processed/results.py index c3857e8..e7b58fc 100644 --- a/src/dynamic_foraging_processing/qc/processed/results.py +++ b/src/dynamic_foraging_processing/qc/processed/results.py @@ -21,6 +21,7 @@ def behavior_qc_results( animal_response: np.ndarray, + side_bias: np.ndarray, left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: t.Optional[str] = None, @@ -50,6 +51,8 @@ def behavior_qc_results( ---------- animal_response : numpy.ndarray Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + side_bias : numpy.ndarray + Per-trial side bias from the trial table (right minus left). left_lick_times, right_lick_times : numpy.ndarray Timestamps (s) of left/right-port licks. results_folder : str, optional @@ -68,12 +71,13 @@ def behavior_qc_results( The average-side-bias result followed by the four lick-interval results. """ results = [ - side_bias_result(animal_response), + side_bias_result(side_bias), *lick_interval_results(left_lick_times, right_lick_times), ] if results_folder is not None: plot_side_bias( animal_response, + side_bias, results_folder, lickspout_x=lickspout_x, lickspout_y1=lickspout_y1, diff --git a/src/dynamic_foraging_processing/qc/processed/stage.py b/src/dynamic_foraging_processing/qc/processed/stage.py index 5847543..69d3689 100644 --- a/src/dynamic_foraging_processing/qc/processed/stage.py +++ b/src/dynamic_foraging_processing/qc/processed/stage.py @@ -21,6 +21,7 @@ class ProcessedQC(BaseQC): def run( self, animal_response: np.ndarray, + side_bias: np.ndarray, left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: t.Optional[str] = None, @@ -49,6 +50,8 @@ def run( ---------- animal_response : numpy.ndarray Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). + side_bias : numpy.ndarray + Per-trial side bias from the trial table (right minus left). left_lick_times, right_lick_times : numpy.ndarray Timestamps (s) of left/right-port licks. results_folder : str, optional @@ -67,6 +70,7 @@ def run( """ results = behavior_qc_results( animal_response, + side_bias, left_lick_times, right_lick_times, results_folder, From 82f97b2ed61c18f83707719d3acd6e5bea234b72 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 18 Jun 2026 16:47:37 -0700 Subject: [PATCH 13/28] test: update tests --- tests/test_qc/test_behavior.py | 31 ++++++++++--------------------- tests/test_qc/test_builder.py | 14 +++++++++++--- tests/test_qc/test_plots.py | 9 ++++++--- tests/test_qc/test_stages.py | 6 +++++- 4 files changed, 32 insertions(+), 28 deletions(-) diff --git a/tests/test_qc/test_behavior.py b/tests/test_qc/test_behavior.py index 9a8ff5b..75733c9 100644 --- a/tests/test_qc/test_behavior.py +++ b/tests/test_qc/test_behavior.py @@ -43,37 +43,26 @@ def test_calculate_lick_intervals_detects_artifacts(): assert result["ArtifactPercent"] > 0 -def test_compute_side_bias_balanced_and_all_ignore(): - """Bias is right-minus-left over responses; all-ignore gives nan.""" - assert _behavior.compute_side_bias(np.array([0, 1, 0, 1])) == 0.0 - assert _behavior.compute_side_bias(np.array([1, 1, 1, 0])) == pytest.approx(0.5) - assert np.isnan(_behavior.compute_side_bias(np.array([2, 2, 2]))) - - -def test_compute_rolling_bias_shapes_and_empty_window(): - """Rolling bias is nan where a window has no responses, set otherwise.""" - responses = np.array([2, 1, 1, 0]) # first trial is ignore -> nan - bias, ci = _behavior.compute_rolling_bias(responses, window=2) - assert bias.shape == (4,) - assert ci.shape == (4, 2) - assert np.isnan(bias[0]) - assert not np.isnan(bias[1]) - - def test_side_bias_result_pass_and_fail(): - """Side-bias result passes under 0.5 absolute bias and fails above it.""" - passing = _behavior.side_bias_result(np.array([0, 1, 0, 1])) + """Side-bias result averages the column; passes under 0.5 absolute bias.""" + passing = _behavior.side_bias_result(np.array([-0.2, 0.1, np.nan, 0.1])) assert passing.passed is True + assert passing.value == pytest.approx(0.0) assert passing.reference == _behavior.SIDE_BIAS_PLOT assert passing.tags == {"behavior": "average side bias"} - failing = _behavior.side_bias_result(np.array([1, 1, 1, 1])) + failing = _behavior.side_bias_result(np.array([0.8, 0.9, 1.0])) assert failing.passed is False + assert failing.value == pytest.approx(0.9) - no_response = _behavior.side_bias_result(np.array([2, 2, 2])) + no_response = _behavior.side_bias_result(np.array([np.nan, np.nan])) assert no_response.passed is False assert np.isnan(no_response.value) + empty = _behavior.side_bias_result(np.array([])) + assert empty.passed is False + assert np.isnan(empty.value) + def test_lick_interval_results_names_and_count(): """Four lick-interval results are produced with the expected names/tags.""" diff --git a/tests/test_qc/test_builder.py b/tests/test_qc/test_builder.py index 3b86b98..a052fcb 100644 --- a/tests/test_qc/test_builder.py +++ b/tests/test_qc/test_builder.py @@ -14,7 +14,10 @@ def test_behavior_qc_results_without_plots(): """Five behavior results are produced and no plots are written.""" results = _results.behavior_qc_results( - np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]) + np.array([0, 1, 2, 1]), + np.array([-0.1, 0.0, np.nan, 0.1]), + np.array([1.0, 1.01]), + np.array([2.0, 2.01]), ) assert len(results) == 5 assert results[0].name == "average side bias" @@ -24,6 +27,7 @@ def test_behavior_qc_results_writes_plots(tmp_path): """Supplying a results folder writes both behavior plots.""" results = _results.behavior_qc_results( np.array([0, 1, 2, 1]), + np.array([-0.1, 0.0, np.nan, 0.1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]), str(tmp_path), @@ -36,7 +40,9 @@ def test_behavior_qc_results_writes_plots(tmp_path): def test_build_quality_control_defaults(): """Defaults fill in the standard grouping and an empty failure allowlist.""" metrics = to_metrics( - _results.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + _results.behavior_qc_results( + np.array([0, 1]), np.array([0.1, -0.1]), np.array([1.0]), np.array([2.0]) + ) ) qc = _builder.build_quality_control(metrics) assert isinstance(qc, QualityControl) @@ -47,7 +53,9 @@ def test_build_quality_control_defaults(): def test_build_quality_control_overrides(): """Explicit grouping / allowlist / metadata are passed through.""" metrics = to_metrics( - _results.behavior_qc_results(np.array([0, 1]), np.array([1.0]), np.array([2.0])) + _results.behavior_qc_results( + np.array([0, 1]), np.array([0.1, -0.1]), np.array([1.0]), np.array([2.0]) + ) ) qc = _builder.build_quality_control( metrics, diff --git a/tests/test_qc/test_plots.py b/tests/test_qc/test_plots.py index 983a396..5109f59 100644 --- a/tests/test_qc/test_plots.py +++ b/tests/test_qc/test_plots.py @@ -28,8 +28,10 @@ def test_time_to_trial_index_covers_all_branches(): def test_plot_side_bias_full_inputs(tmp_path): """All optional panels render when every per-trial array is supplied.""" animal_response = np.array([0, 1, 2, 1, 0, 1]) + side_bias = np.array([-0.2, 0.0, np.nan, 0.3, 0.1, 0.2]) name = _plots.plot_side_bias( animal_response, + side_bias, str(tmp_path), lickspout_x=np.array([1.0, 1.1, 1.0, 1.2, 1.1, 1.0]), lickspout_y1=np.array([2.0, 2.0, 2.1, 2.0, 2.0, 2.1]), @@ -44,7 +46,6 @@ def test_plot_side_bias_full_inputs(tmp_path): autowater_right=np.array([0, 0, 0, 1, 0, 0]), manual_left_times=np.array([0.1, 3.6]), # 0.1 -> -1, 3.6 -> trial index manual_right_times=np.array([5.6]), - bias_window=3, ) assert name == _plots.SIDE_BIAS_PLOT assert os.path.exists(tmp_path / name) @@ -52,11 +53,13 @@ def test_plot_side_bias_full_inputs(tmp_path): def test_plot_side_bias_minimal_inputs(tmp_path): """With only choices supplied, the optional panels are skipped cleanly.""" - name = _plots.plot_side_bias(np.array([]), str(tmp_path)) + name = _plots.plot_side_bias(np.array([]), np.array([]), str(tmp_path)) assert os.path.exists(tmp_path / name) def test_plot_side_bias_empty_position_array(tmp_path): """An empty lickspout-position array is skipped without plotting.""" - name = _plots.plot_side_bias(np.array([0, 1]), str(tmp_path), lickspout_x=np.array([])) + name = _plots.plot_side_bias( + np.array([0, 1]), np.array([0.1, -0.1]), str(tmp_path), lickspout_x=np.array([]) + ) assert os.path.exists(tmp_path / name) diff --git a/tests/test_qc/test_stages.py b/tests/test_qc/test_stages.py index 71caf4a..5863edc 100644 --- a/tests/test_qc/test_stages.py +++ b/tests/test_qc/test_stages.py @@ -46,7 +46,10 @@ def _fake_contract_qc_metrics(dataset, results_folder): def test_processed_qc_run_returns_metrics(): """``ProcessedQC.run`` produces the five behavior metrics.""" metrics = ProcessedQC().run( - np.array([0, 1, 2, 1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]) + np.array([0, 1, 2, 1]), + np.array([-0.1, 0.0, np.nan, 0.1]), + np.array([1.0, 1.01]), + np.array([2.0, 2.01]), ) assert len(metrics) == 5 assert all(isinstance(m, QCMetric) for m in metrics) @@ -57,6 +60,7 @@ def test_processed_qc_run_writes_plots(tmp_path): """Supplying a results folder writes the supporting plots.""" metrics = ProcessedQC().run( np.array([0, 1, 2, 1]), + np.array([-0.1, 0.0, np.nan, 0.1]), np.array([1.0, 1.01]), np.array([2.0, 2.01]), str(tmp_path), From 102248efeb1f38857d21f637aea318d021ce5ea8 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 18 Jun 2026 16:47:52 -0700 Subject: [PATCH 14/28] feat: add initial example notebook --- examples/qc_example.ipynb | 167 ++++++++------------------------------ 1 file changed, 33 insertions(+), 134 deletions(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index 9bed57c..e616cf6 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -9,12 +9,13 @@ "\n", "This notebook demonstrates the `dynamic_foraging_processing.qc` module: the\n", "**metrics** that can be gathered and the **plots** that can be produced from the\n", - "per-trial `animal_response` (`0` left, `1` right, `2` ignore).\n", + "trial table (per-trial `animal_response` — `0` left, `1` right, `2` ignore — and\n", + "the precomputed `side_bias` column).\n", "\n", "It uses **synthetic data** (no dataset loading) so it runs anywhere, mirroring\n", - "the arrays used in the unit tests. Swap in a real session's `animal_response`\n", - "(e.g. the `animal_response` column from `TrialTableBuilder.build()`) to use it\n", - "for real." + "the arrays used in the unit tests. Swap in a real session's `animal_response` /\n", + "`side_bias` (e.g. the columns from `TrialTableBuilder.build()`) to use it for\n", + "real." ] }, { @@ -56,6 +57,10 @@ "# Choice per trial: 0 left, 1 right, 2 ignore (slightly right-biased here).\n", "animal_response = rng.choice([0, 1, 2], size=n_trials, p=[0.4, 0.5, 0.1])\n", "\n", + "# Per-trial side bias from the trial table (right minus left); nan on ignore\n", + "# trials. Synthetic here: a mild rightward bias.\n", + "side_bias = np.where(animal_response == 2, np.nan, np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0))\n", + "\n", "# Optional per-trial context (synthetic), one array per column.\n", "rewarded_left = (animal_response == 0) & (rng.random(n_trials) < 0.5)\n", "rewarded_right = (animal_response == 1) & (rng.random(n_trials) < 0.5)\n", @@ -76,11 +81,12 @@ "id": "f4981f30", "metadata": {}, "source": [ - "## Metrics from `animal_response`\n", + "## Metrics from the trial table\n", "\n", "### Average side bias\n", - "`compute_side_bias` returns `mean(is_right) - mean(is_left)` over responded\n", - "trials, in `[-1, +1]` (positive = rightward bias)." + "The `side_bias` column is precomputed per trial in the trial table (right minus\n", + "left, `nan` where the animal did not respond). The QC check averages it over the\n", + "session; `abs(mean) < 0.5` passes." ] }, { @@ -93,136 +99,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "average side bias: 0.176\n" + "average side bias: 0.143\n" ] } ], "source": [ - "from dynamic_foraging_processing.qc import compute_side_bias\n", - "\n", - "mean_bias = compute_side_bias(animal_response)\n", + "mean_bias = np.nanmean(side_bias)\n", "print(f\"average side bias: {mean_bias:.3f}\")" ] }, - { - "cell_type": "markdown", - "id": "ffd21348", - "metadata": {}, - "source": [ - "### Rolling side bias (with confidence band)\n", - "`compute_rolling_bias` returns a trailing-window bias trace and a 95% normal-\n", - "approximation confidence interval, one row per trial." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5d4f0143", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bias shape: (200,) | ci shape: (200, 2)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
biasci_lowci_high
01.0000001.0000001.000000
10.000000-1.3859291.385929
2-0.333333-1.4002220.733556
3-0.500000-1.3487050.348705
4-0.200000-1.0588290.658829
\n", - "
" - ], - "text/plain": [ - " bias ci_low ci_high\n", - "0 1.000000 1.000000 1.000000\n", - "1 0.000000 -1.385929 1.385929\n", - "2 -0.333333 -1.400222 0.733556\n", - "3 -0.500000 -1.348705 0.348705\n", - "4 -0.200000 -1.058829 0.658829" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from dynamic_foraging_processing.qc import compute_rolling_bias\n", - "\n", - "bias, ci = compute_rolling_bias(animal_response, window=20)\n", - "print(\"bias shape:\", bias.shape, \"| ci shape:\", ci.shape)\n", - "pd.DataFrame({\"bias\": bias, \"ci_low\": ci[:, 0], \"ci_high\": ci[:, 1]}).head()" - ] - }, { "cell_type": "markdown", "id": "45cf1958", "metadata": {}, "source": [ "### As a QC result / metric\n", - "`side_bias_result` wraps the scalar into a `QCResult` (pass when\n", - "`abs(bias) < 0.5`), which converts to an `aind_data_schema` `QCMetric`." + "`side_bias_result` averages the `side_bias` column into a `QCResult` (pass when\n", + "`abs(mean) < 0.5`), which converts to an `aind_data_schema` `QCMetric`." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "58755f21", "metadata": {}, "outputs": [ @@ -231,7 +129,7 @@ "output_type": "stream", "text": [ "name: average side bias\n", - "value: 0.17647058823529416\n", + "value: 0.1433020947617509\n", "passed: True\n", "tags: {'behavior': 'average side bias'}\n" ] @@ -239,10 +137,10 @@ { "data": { "text/plain": [ - "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.17647058823529416, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 17, 16, 17, 0, 236255, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias over responded trials (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" + "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 18, 16, 46, 2, 398529, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -250,7 +148,7 @@ "source": [ "from dynamic_foraging_processing.qc import side_bias_result\n", "\n", - "result = side_bias_result(animal_response)\n", + "result = side_bias_result(side_bias)\n", "print(\"name: \", result.name)\n", "print(\"value: \", result.value)\n", "print(\"passed: \", result.passed)\n", @@ -267,15 +165,16 @@ "source": [ "## Plot: side-bias figure\n", "\n", - "`plot_side_bias` writes a four-panel `side_bias.png` into a results folder:\n", - "rolling side bias, lickspout position, per-trial behavior raster, and reward\n", - "probabilities. It is driven by `animal_response`; the remaining panels are\n", - "populated from the optional per-trial context created above." + "`plot_side_bias` writes a four-panel `side_bias.png` into a results folder: the\n", + "per-trial `side_bias` trace, lickspout position, per-trial behavior raster, and\n", + "reward probabilities. The bias panel is driven by the `side_bias` column and the\n", + "raster by `animal_response`; the remaining panels are populated from the\n", + "optional per-trial context created above." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "72a51175", "metadata": {}, "outputs": [ @@ -285,7 +184,7 @@ "'side_bias.png'" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -300,6 +199,7 @@ "\n", "plot_side_bias(\n", " animal_response,\n", + " side_bias,\n", " str(results_folder),\n", " rewarded_left=rewarded_left,\n", " rewarded_right=rewarded_right,\n", @@ -308,24 +208,23 @@ " go_cue_times=go_cue_times,\n", " autowater_left=autowater_left,\n", " autowater_right=autowater_right,\n", - " bias_window=20,\n", ")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "0a361145", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } From f41e2bfa05f0ca0c4628bc0f4637ce62e92ee4dc Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 18 Jun 2026 16:51:49 -0700 Subject: [PATCH 15/28] fix: remove unused import --- examples/qc_example.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index e616cf6..8d9e06a 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -49,7 +49,6 @@ ], "source": [ "import numpy as np\n", - "import pandas as pd\n", "\n", "rng = np.random.default_rng(0)\n", "n_trials = 200\n", From 862d9609ab2608cd0ade038b9abca097e66da3d2 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Thu, 18 Jun 2026 16:53:16 -0700 Subject: [PATCH 16/28] chore: linting --- examples/qc_example.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index 8d9e06a..6e19db9 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -58,7 +58,9 @@ "\n", "# Per-trial side bias from the trial table (right minus left); nan on ignore\n", "# trials. Synthetic here: a mild rightward bias.\n", - "side_bias = np.where(animal_response == 2, np.nan, np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0))\n", + "side_bias = np.where(\n", + " animal_response == 2, np.nan, np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0)\n", + ")\n", "\n", "# Optional per-trial context (synthetic), one array per column.\n", "rewarded_left = (animal_response == 0) & (rng.random(n_trials) < 0.5)\n", From 847ae3109e34ea20ce66a834fd1bf42c962e4901 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Sat, 20 Jun 2026 18:25:28 -0700 Subject: [PATCH 17/28] feat: add lick interval plot to example notebook --- examples/qc_example.ipynb | 125 +++++++++++++++++++++++++++++++++++++- 1 file changed, 124 insertions(+), 1 deletion(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index 6e19db9..eda2650 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -138,7 +138,7 @@ { "data": { "text/plain": [ - "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 18, 16, 46, 2, 398529, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" + "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 20, 16, 32, 32, 885559, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" ] }, "execution_count": 3, @@ -236,6 +236,129 @@ "Image(filename=str(results_folder / \"side_bias.png\"))" ] }, + { + "cell_type": "markdown", + "id": "86cc9da8", + "metadata": {}, + "source": [ + "## Metrics: inter-lick intervals\n", + "\n", + "The lick metrics come from the per-port lick timestamps rather than the trial\n", + "table. `lick_interval_results` runs `calculate_lick_intervals` and returns four\n", + "`QCResult` objects — the percentage of left, right, and cross-side intervals\n", + "below the physiological threshold, plus an artifact percentage. Left/right/cross\n", + "pass when `< 10`; the artifact percent passes when `< 1`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "31cf3d8f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "left licks: 400\n", + "right licks: 500\n" + ] + } + ], + "source": [ + "# Synthetic per-port lick timestamps (s). Real sessions would use the lick\n", + "# times pulled from the NWB file; here we just scatter licks across the session.\n", + "rng_licks = np.random.default_rng(1)\n", + "left_lick_times = np.sort(rng_licks.uniform(0, n_trials, size=400))\n", + "right_lick_times = np.sort(rng_licks.uniform(0, n_trials, size=500))\n", + "\n", + "print(\"left licks: \", len(left_lick_times))\n", + "print(\"right licks:\", len(right_lick_times))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "445aa290", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Left Lick Interval (%) value= 9.270 passed=True\n", + "Right Lick Interval (%) value= 12.420 passed=False\n", + "Cross Side Lick Interval (%) value= 9.890 passed=True\n", + "Artifact Percent (%) value= 0.445 passed=True\n" + ] + } + ], + "source": [ + "from dynamic_foraging_processing.qc import lick_interval_results\n", + "\n", + "lick_results = lick_interval_results(left_lick_times, right_lick_times)\n", + "for r in lick_results:\n", + " print(f\"{r.name:30s} value={r.value:7.3f} passed={r.passed}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1513220c", + "metadata": {}, + "source": [ + "## Plot: inter-lick-interval histogram\n", + "\n", + "`plot_lick_intervals` writes a five-panel `lick_intervals.png` into the results\n", + "folder: histograms of the inter-lick intervals for left licks, right licks,\n", + "left-to-right transitions, right-to-left transitions, and all licks combined.\n", + "Like the metrics above, it is driven purely by the left/right lick timestamps." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "09aa51c9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'lick_intervals.png'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dynamic_foraging_processing.qc import plot_lick_intervals\n", + "\n", + "plot_lick_intervals(left_lick_times, right_lick_times, str(results_folder))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fc39babb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image(filename=str(results_folder / \"lick_intervals.png\"))" + ] + }, { "cell_type": "markdown", "id": "4d34d523", From 5e43f979265d56374ca726165c2d997b1620738c Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Mon, 22 Jun 2026 09:33:14 -0700 Subject: [PATCH 18/28] refactor: use pathlib instead of os --- src/dynamic_foraging_processing/qc/processed/plots.py | 6 +++--- src/dynamic_foraging_processing/qc/raw/contract_qa.py | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/processed/plots.py b/src/dynamic_foraging_processing/qc/processed/plots.py index f2c2168..d04c941 100644 --- a/src/dynamic_foraging_processing/qc/processed/plots.py +++ b/src/dynamic_foraging_processing/qc/processed/plots.py @@ -5,8 +5,8 @@ The Agg backend is forced so the plots render headlessly (no display required). """ -import os import typing as t +from pathlib import Path import matplotlib @@ -80,7 +80,7 @@ def plot_lick_intervals( ax[4].hist(all_licks_sorted_diff, bins=bins, color="black", alpha=0.7) fig.tight_layout() - fig.savefig(os.path.join(results_folder, LICK_INTERVALS_PLOT), dpi=300, bbox_inches="tight") + fig.savefig(Path(results_folder) / LICK_INTERVALS_PLOT, dpi=300, bbox_inches="tight") plt.close(fig) return LICK_INTERVALS_PLOT @@ -303,6 +303,6 @@ def plot_side_bias( ) _add_reward_probabilities(ax[3], reward_probability_left, reward_probability_right) - fig.savefig(os.path.join(results_folder, SIDE_BIAS_PLOT), dpi=300, bbox_inches="tight") + fig.savefig(Path(results_folder) / SIDE_BIAS_PLOT, dpi=300, bbox_inches="tight") plt.close(fig) return SIDE_BIAS_PLOT diff --git a/src/dynamic_foraging_processing/qc/raw/contract_qa.py b/src/dynamic_foraging_processing/qc/raw/contract_qa.py index c36647e..d4d52a4 100644 --- a/src/dynamic_foraging_processing/qc/raw/contract_qa.py +++ b/src/dynamic_foraging_processing/qc/raw/contract_qa.py @@ -7,9 +7,9 @@ ``QCMetric``, tagged so the QC portal groups them under ``test_suite``. """ -import os import re import typing as t +from pathlib import Path import matplotlib.figure from aind_behavior_dynamic_foraging.data_qc.suite import make_qc_runner @@ -51,7 +51,7 @@ def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optiona if not isinstance(asset, matplotlib.figure.Figure) or results_folder is None: return None filename = f"{_sanitize(result.suite_name)}_{_sanitize(result.test_name)}.png" - asset.savefig(os.path.join(results_folder, filename), dpi=300, bbox_inches="tight") + asset.savefig(Path(results_folder) / filename, dpi=300, bbox_inches="tight") return filename From ea5f76745d86e156577e4aa48147dd3d7eaca7e6 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Mon, 22 Jun 2026 10:28:22 -0700 Subject: [PATCH 19/28] feat: add more complete example --- examples/qc_example.ipynb | 137 +++++++++++++++++++++++++++++--------- 1 file changed, 106 insertions(+), 31 deletions(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index eda2650..2aefbf7 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -9,13 +9,11 @@ "\n", "This notebook demonstrates the `dynamic_foraging_processing.qc` module: the\n", "**metrics** that can be gathered and the **plots** that can be produced from the\n", - "trial table (per-trial `animal_response` — `0` left, `1` right, `2` ignore — and\n", - "the precomputed `side_bias` column).\n", + "trial table (the precomputed `side_bias` column).\n", "\n", "It uses **synthetic data** (no dataset loading) so it runs anywhere, mirroring\n", - "the arrays used in the unit tests. Swap in a real session's `animal_response` /\n", - "`side_bias` (e.g. the columns from `TrialTableBuilder.build()`) to use it for\n", - "real." + "the arrays used in the unit tests. Swap in a real session's `side_bias` (e.g. the\n", + "column from `TrialTableBuilder.build()`) to use it for real." ] }, { @@ -34,7 +32,14 @@ "cell_type": "code", "execution_count": 1, "id": "72ca85eb", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:14.933186Z", + "iopub.status.busy": "2026-06-22T17:15:14.933186Z", + "iopub.status.idle": "2026-06-22T17:15:15.066462Z", + "shell.execute_reply": "2026-06-22T17:15:15.066462Z" + } + }, "outputs": [ { "name": "stdout", @@ -85,16 +90,21 @@ "## Metrics from the trial table\n", "\n", "### Average side bias\n", - "The `side_bias` column is precomputed per trial in the trial table (right minus\n", - "left, `nan` where the animal did not respond). The QC check averages it over the\n", - "session; `abs(mean) < 0.5` passes." + "The `side_bias` column is precomputed per trial in the trial table. The QC check averages it over the session; `abs(mean) < 0.5` passes." ] }, { "cell_type": "code", "execution_count": 2, "id": "abb13a1f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:15.069820Z", + "iopub.status.busy": "2026-06-22T17:15:15.066462Z", + "iopub.status.idle": "2026-06-22T17:15:15.073147Z", + "shell.execute_reply": "2026-06-22T17:15:15.073147Z" + } + }, "outputs": [ { "name": "stdout", @@ -123,7 +133,14 @@ "cell_type": "code", "execution_count": 3, "id": "58755f21", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:15.075017Z", + "iopub.status.busy": "2026-06-22T17:15:15.075017Z", + "iopub.status.idle": "2026-06-22T17:15:18.122180Z", + "shell.execute_reply": "2026-06-22T17:15:18.122180Z" + } + }, "outputs": [ { "name": "stdout", @@ -138,7 +155,7 @@ { "data": { "text/plain": [ - "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 20, 16, 32, 32, 885559, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" + "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 27, 54, 559581, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" ] }, "execution_count": 3, @@ -168,16 +185,22 @@ "\n", "`plot_side_bias` writes a four-panel `side_bias.png` into a results folder: the\n", "per-trial `side_bias` trace, lickspout position, per-trial behavior raster, and\n", - "reward probabilities. The bias panel is driven by the `side_bias` column and the\n", - "raster by `animal_response`; the remaining panels are populated from the\n", - "optional per-trial context created above." + "reward probabilities. The bias panel is driven by the `side_bias` column; the\n", + "remaining panels are populated from the optional per-trial context created above." ] }, { "cell_type": "code", "execution_count": 4, "id": "72a51175", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:18.125824Z", + "iopub.status.busy": "2026-06-22T17:15:18.123685Z", + "iopub.status.idle": "2026-06-22T17:15:18.552676Z", + "shell.execute_reply": "2026-06-22T17:15:18.552171Z" + } + }, "outputs": [ { "data": { @@ -216,7 +239,14 @@ "cell_type": "code", "execution_count": 5, "id": "0a361145", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:18.555189Z", + "iopub.status.busy": "2026-06-22T17:15:18.555189Z", + "iopub.status.idle": "2026-06-22T17:15:18.584054Z", + "shell.execute_reply": "2026-06-22T17:15:18.584054Z" + } + }, "outputs": [ { "data": { @@ -254,7 +284,14 @@ "cell_type": "code", "execution_count": 6, "id": "31cf3d8f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:18.586013Z", + "iopub.status.busy": "2026-06-22T17:15:18.586013Z", + "iopub.status.idle": "2026-06-22T17:15:18.591081Z", + "shell.execute_reply": "2026-06-22T17:15:18.591081Z" + } + }, "outputs": [ { "name": "stdout", @@ -280,7 +317,14 @@ "cell_type": "code", "execution_count": 7, "id": "445aa290", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:18.594151Z", + "iopub.status.busy": "2026-06-22T17:15:18.592092Z", + "iopub.status.idle": "2026-06-22T17:15:18.599276Z", + "shell.execute_reply": "2026-06-22T17:15:18.599276Z" + } + }, "outputs": [ { "name": "stdout", @@ -318,7 +362,14 @@ "cell_type": "code", "execution_count": 8, "id": "09aa51c9", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:18.600551Z", + "iopub.status.busy": "2026-06-22T17:15:18.600551Z", + "iopub.status.idle": "2026-06-22T17:15:19.294860Z", + "shell.execute_reply": "2026-06-22T17:15:19.294860Z" + } + }, "outputs": [ { "data": { @@ -341,7 +392,14 @@ "cell_type": "code", "execution_count": 9, "id": "fc39babb", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:19.296188Z", + "iopub.status.busy": "2026-06-22T17:15:19.296188Z", + "iopub.status.idle": "2026-06-22T17:15:19.315424Z", + "shell.execute_reply": "2026-06-22T17:15:19.314918Z" + } + }, "outputs": [ { "data": { @@ -366,41 +424,58 @@ "source": [ "## Assemble a `QualityControl` object\n", "\n", - "Collect the behavior metric(s) into a single `QualityControl`. In a real\n", - "pipeline you would also append the automated contract-QA metrics\n", - "(`contract_qc_metrics(dataset, ...)`), which require a loaded dataset." + "Collect the behavior metrics — the average side bias plus the four\n", + "inter-lick-interval checks — into a single `QualityControl`. `to_metrics`\n", + "converts the list of `QCResult` objects into schema `QCMetric`s in one step." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "bf1b9b08", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-22T17:15:19.316159Z", + "iopub.status.busy": "2026-06-22T17:15:19.316159Z", + "iopub.status.idle": "2026-06-22T17:15:19.324151Z", + "shell.execute_reply": "2026-06-22T17:15:19.324151Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "total metrics: 1\n", + "total metrics: 5\n", + " - average side bias: Pass\n", + " - Left Lick Interval (%): Pass\n", + " - Right Lick Interval (%): Fail\n", + " - Cross Side Lick Interval (%): Pass\n", + " - Artifact Percent (%): Pass\n", "default grouping: ['behavior', 'test_suite']\n" ] }, { "data": { "text/plain": [ - "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.17647058823529416, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 17, 16, 17, 0, 236255, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias over responded trials (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:average side bias': , 'behavior': , 'Raw data': })" + "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Left Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.27, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Left Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Left Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Right Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=12.42, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Fail', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Right Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Right Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Cross Side Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.89, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Cross Side Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Cross Side Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Artifact Percent (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.44493882091212456, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Artifact Percent (%) of inter-lick intervals; passes when < 1.0.', reference='lick_intervals.png', tags={'behavior': 'Artifact Percent (%)'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:Right Lick Interval (%)': , 'behavior:Artifact Percent (%)': , 'behavior:average side bias': , 'behavior:Cross Side Lick Interval (%)': , 'behavior:Left Lick Interval (%)': , 'behavior': , 'Raw data': })" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from dynamic_foraging_processing.qc import build_quality_control\n", + "from dynamic_foraging_processing.qc import build_quality_control, to_metrics\n", + "\n", + "# All behavior metrics: the average side bias plus the four lick-interval checks.\n", + "behavior_metrics = to_metrics([result, *lick_results])\n", "\n", - "quality_control = build_quality_control([metric])\n", + "quality_control = build_quality_control(behavior_metrics)\n", "print(\"total metrics:\", len(quality_control.metrics))\n", + "for m in quality_control.metrics:\n", + " print(f\" - {m.name}: {m.status_history[-1].status}\")\n", "print(\"default grouping:\", quality_control.default_grouping)\n", "quality_control" ] From e023a32ef4ca3148e6997db01e667272678ee5f2 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Mon, 22 Jun 2026 10:42:56 -0700 Subject: [PATCH 20/28] docs: minor update to readme --- README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/README.md b/README.md index fe5431d..ed6c0c0 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,16 @@ To use the software, in the root directory, run pip install -e . ``` +> [!IMPORTANT] +> The base install includes **only** the raw data loader and does **not** pull in +> `aind-data-schema` or `matplotlib`. The quality-control (`qc`) module requires +> both, so importing `dynamic_foraging_processing.qc` will fail on a base install. +> To use the QC module, install the `qc` (or equivalent `full`) extra: +> ```bash +> pip install -e ".[qc]" +> ``` +> The `full` extra is currently an alias for `qc`. + To develop the code, run ```bash pip install -e . --group dev @@ -46,3 +56,7 @@ Alternatively, if using [uv](https://docs.astral.sh/uv/), run ```bash uv sync ``` +To include the QC dependencies with uv, run +```bash +uv sync --extra qc +``` From 89b5d06f08258e27da110a039312e95f467d9ea7 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Mon, 22 Jun 2026 10:59:57 -0700 Subject: [PATCH 21/28] refactor: add more details on qa docstrings --- .../qc/raw/contract_qa.py | 29 +++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/raw/contract_qa.py b/src/dynamic_foraging_processing/qc/raw/contract_qa.py index d4d52a4..7c0ea33 100644 --- a/src/dynamic_foraging_processing/qc/raw/contract_qa.py +++ b/src/dynamic_foraging_processing/qc/raw/contract_qa.py @@ -42,7 +42,9 @@ def _save_asset(result: qc.Result, results_folder: t.Optional[str]) -> t.Optiona ------- str or None The saved figure's filename, or ``None`` when there is no figure asset - (or no ``results_folder``). + (or no ``results_folder``). The name combines the (sanitized) suite and + test names, e.g. a ``CameraTestSuite`` result for ``test_frame_rate`` + becomes ``"CameraTestSuite_test_frame_rate.png"``. """ context = result.context if not isinstance(context, dict): @@ -65,7 +67,12 @@ def results_to_metrics( ---------- results : dict Mapping of group name to list of ``contraqctor`` ``Result`` objects, as - returned by ``contraqctor.qc.Runner.run_all``. + returned by ``contraqctor.qc.Runner.run_all``. The keys are the group + names passed to ``runner.add_suite`` (e.g. ``"Data contract"``, + ``"HarpHub"``, ``"HarpLickometerRight"``, ``"DynamicForaging"``), and + each ``Result`` carries its suite's class name as ``suite_name`` (e.g. + ``"ContractTestSuite"``, ``"HarpDeviceTestSuite"``, ``"CameraTestSuite"``, + ``"DynamicForagingQcSuite"``). A ``None`` key becomes :data:`NO_GROUP`. results_folder : str, optional Directory to save figure assets into. If ``None``, assets are skipped. @@ -73,6 +80,24 @@ def results_to_metrics( ------- list of QCMetric One metric per result, tagged ``{"test_suite": suite, suite: group}``. + + Examples + -------- + The dynamic foraging runner produces results grouped roughly like:: + + { + "Data contract": [], + "HarpHub": [], + "HarpLickometerRight": [], + "DynamicForaging": [], + } + + Each result becomes a metric named ``"::"`` tagged + with both its suite and group, e.g. a ``ContractTestSuite`` result in the + ``"Data contract"`` group yields:: + + name = "ContractTestSuite::test_no_load_errors" + tags = {"test_suite": "ContractTestSuite", "ContractTestSuite": "Data contract"} """ metrics: t.List[QCMetric] = [] for group, group_results in results.items(): From ec50eec3e646676e058bb88ea2133c5b6941b8b9 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Mon, 22 Jun 2026 11:10:22 -0700 Subject: [PATCH 22/28] docs: update qc documentation --- docs/qc_upgrade_plan.md | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/docs/qc_upgrade_plan.md b/docs/qc_upgrade_plan.md index 3eb4413..47d43dc 100644 --- a/docs/qc_upgrade_plan.md +++ b/docs/qc_upgrade_plan.md @@ -70,6 +70,7 @@ any dataset on disk. | `left_lick_times` | `np.ndarray` of seconds | `B_LeftLickTime` | | `right_lick_times` | `np.ndarray` of seconds | `B_RightLickTime` | | `animal_response` | `np.ndarray` of `{0,1,2}` per trial | `B_AnimalResponseHistory` | +| `side_bias` | `np.ndarray` per trial (right minus left, `nan` on no-response) | `B_Bias` | | `go_cue_times` | `np.ndarray` of seconds | `B_GoCueTimeSoundCard` | | `rewarded_history` | `pd.DataFrame` with `left`/`right` boolean columns | `B_RewardedHistory` | | `stage_positions` | `pd.DataFrame` with `x`/`y`/`z` columns per trial | `B_StagePositions` | @@ -78,8 +79,8 @@ any dataset on disk. - `drop_frames_tag`, `frame_num`, `trigger_length` — dropped-frames check. - `Experimenter`, `dirty_files`, `repo_dirty_flag` — basic-configuration check. -- `B_Bias`, `B_Bias_CI` — pre-computed side bias; recompute from - `animal_response` instead (rolling fraction of right vs. left choices). +- `B_Bias_CI` — side-bias confidence interval; dropped (the bias trace plots + the per-trial `side_bias` column directly, with no CI band). ## 3. Metrics in the new capsule @@ -88,10 +89,12 @@ Keep only what maps cleanly. All metrics get `stage=Stage.RAW` and ### Side bias (`tags={"behavior": "average side bias"}`) -- Input: `animal_response: np.ndarray` (`0=left`, `1=right`, `2=ignore`). -- Average bias = `mean(is_right) - mean(is_left)` over responded trials (or - the rolling form, matching the old `B_Bias`). -- Metric: `"average side bias"`, pass when `abs(mean_bias) < 0.5`. +- Input: `side_bias: np.ndarray` — the per-trial side bias read directly from + the trial table (right minus left; `nan` on no-response trials). It is *not* + recomputed from `animal_response`. +- Average bias = `nanmean(side_bias)` over the session. +- Metric: `"average side bias"`, pass when `abs(mean_bias) < 0.5`. An empty or + all-`nan` column yields `nan`, which fails. - `reference="side_bias.png"`. ### Lick intervals @@ -118,8 +121,8 @@ All carry `reference="lick_intervals.png"`. (`left licks`, `right licks`, `left to right licks`, `right to left licks`, `all licks`); inputs are `left_lick_times` and `right_lick_times`. - `side_bias.png` — four-panel figure: - - Side bias trace (with confidence interval band) — rolling `B_Bias` / - `B_Bias_CI` recomputed from `animal_response`. + - Side bias trace — the per-trial `side_bias` column read from the trial + table (no confidence-interval band). - Lickspout position over trials — `stage_positions` (x / y1 / y2 / z, relative to session start, in mm). - Behavior event raster — `animal_response` (L/R choice, ignore), @@ -210,3 +213,4 @@ test_suite | --- | --- | --- | --- | | 2026-06-03 | metrics | Confirmed kept QC metrics: side bias, lick intervals, and Harp/contract QA via `make_qc_runner`. Dropped checks tied to old `behavior.json` (dropped frames, basic configuration). | Meeting with Alex. | | 2026-06-03 | qa | Adopt contraqctor `qc.Runner` output (`make_qc_runner(dataset)`) as the source for Harp / camera / contract / DynamicForaging QA, converted into `QCMetric`s. | Meeting with Alex. | +| 2026-06-22 | metrics, data inputs, plots | Side bias is read from the precomputed per-trial `side_bias` column (averaged via `nanmean`) instead of being recomputed from `animal_response`; dropped the `B_Bias_CI` confidence-interval band. | Reflect implemented `side_bias_result` / `plot_side_bias`. | From 91217835abc11d6be6d2d4f9666184fbffd1cf0c Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 10:16:14 -0700 Subject: [PATCH 23/28] fix: PR feedback --- src/dynamic_foraging_processing/qc/processed/behavior.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/processed/behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py index cca1941..0cdbc91 100644 --- a/src/dynamic_foraging_processing/qc/processed/behavior.py +++ b/src/dynamic_foraging_processing/qc/processed/behavior.py @@ -112,7 +112,9 @@ def side_bias_result(side_bias: np.ndarray) -> QCResult: ---------- side_bias : numpy.ndarray Per-trial side bias from the trial table (right minus left); positive - means a rightward bias. Trials with no response are ``nan``. + means a rightward bias. Computed over a sliding window, so a single + no-response trial still has a value; entries are ``nan`` only when the + mouse has not responded for many consecutive trials. Returns ------- @@ -131,7 +133,7 @@ def side_bias_result(side_bias: np.ndarray) -> QCResult: name=name, value=mean_bias, passed=bool(abs(mean_bias) < 0.5), # nan comparisons are False -> fails - description="Average of the per-trial side bias (right minus left).", + description="Average side bias across the session (right is positive).", reference=SIDE_BIAS_PLOT, tags={"behavior": name}, ) From 1667cf132a1ba789f4e05e63ff3fbe370e36bbc2 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 14:43:57 -0700 Subject: [PATCH 24/28] refactor: pass in trials dataframe instead of a billion parameters --- .../qc/processed/results.py | 104 +++++++++++------- .../qc/processed/stage.py | 49 ++------- 2 files changed, 74 insertions(+), 79 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/processed/results.py b/src/dynamic_foraging_processing/qc/processed/results.py index e7b58fc..1047c52 100644 --- a/src/dynamic_foraging_processing/qc/processed/results.py +++ b/src/dynamic_foraging_processing/qc/processed/results.py @@ -1,15 +1,18 @@ -"""Build the behavior QC results from per-trial and event-time arrays. +"""Build the behavior QC results from the trials table and lick-time arrays. Combines the side-bias and lick-interval checks into the ordered list of ``QCResult`` objects the processed stage returns, optionally writing the -supporting plots so the result references resolve. Convert the results to -schema metrics with ``to_metrics`` / ``QCResult.to_metric`` when assembling a -``QualityControl``. +supporting plots so the result references resolve. The per-trial inputs are +pulled from the trials table by column; the lick and manual-water timestamps +are event-time arrays (variable length, not per-trial) and stay explicit. +Convert the results to schema metrics with ``to_metrics`` / +``QCResult.to_metric`` when assembling a ``QualityControl``. """ import typing as t import numpy as np +import pandas as pd from dynamic_foraging_processing.qc._core.result import QCResult from dynamic_foraging_processing.qc.processed.behavior import ( @@ -18,25 +21,44 @@ ) from dynamic_foraging_processing.qc.processed.plots import plot_lick_intervals, plot_side_bias +# Logical input -> trials-table column name. Centralized so the mapping is easy +# to correct against the trial-table builder; ``side_bias`` and the +# ``lickspout_*`` arrays are not yet pinned down in trials_table_mapping.md. +_COLUMNS = { + "animal_response": "animal_response", + "side_bias": "side_bias", + "lickspout_x": "lickspout_x", + "lickspout_y1": "lickspout_y1", + "lickspout_y2": "lickspout_y2", + "lickspout_z": "lickspout_z", + "rewarded_left": "rewarded_historyL", + "rewarded_right": "rewarded_historyR", + "reward_probability_left": "reward_probabilityL", + "reward_probability_right": "reward_probabilityR", + "autowater_left": "auto_waterL", + "autowater_right": "auto_waterR", + "go_cue_times": "goCue_start_time", +} + + +def _column(trials: pd.DataFrame, key: str) -> t.Optional[np.ndarray]: + """Return the trials-table column for ``key`` as an array, or ``None``. + + Missing columns return ``None`` so optional plot inputs degrade gracefully, + matching the previous per-array signature. + """ + column = _COLUMNS[key] + if column in trials.columns: + return trials[column].to_numpy() + return None + def behavior_qc_results( - animal_response: np.ndarray, - side_bias: np.ndarray, + trials: pd.DataFrame, left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: t.Optional[str] = None, *, - lickspout_x: t.Optional[np.ndarray] = None, - lickspout_y1: t.Optional[np.ndarray] = None, - lickspout_y2: t.Optional[np.ndarray] = None, - lickspout_z: t.Optional[np.ndarray] = None, - rewarded_left: t.Optional[np.ndarray] = None, - rewarded_right: t.Optional[np.ndarray] = None, - reward_probability_left: t.Optional[np.ndarray] = None, - reward_probability_right: t.Optional[np.ndarray] = None, - go_cue_times: t.Optional[np.ndarray] = None, - autowater_left: t.Optional[np.ndarray] = None, - autowater_right: t.Optional[np.ndarray] = None, manual_left_times: t.Optional[np.ndarray] = None, manual_right_times: t.Optional[np.ndarray] = None, ) -> t.List[QCResult]: @@ -49,47 +71,47 @@ def behavior_qc_results( Parameters ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). - side_bias : numpy.ndarray - Per-trial side bias from the trial table (right minus left). + trials : pandas.DataFrame + Trials table. The per-trial inputs are read by column (see + ``_COLUMNS``): ``animal_response``, ``side_bias``, the ``lickspout_*`` + positions, the earned-reward / autowater / reward-probability left/right + columns, and the go-cue start times. Columns that are absent are treated + as unavailable and skipped in the side-bias figure. left_lick_times, right_lick_times : numpy.ndarray - Timestamps (s) of left/right-port licks. + Timestamps (s) of left/right-port licks. Event-time arrays, not + per-trial, so they are passed explicitly rather than read from ``trials``. results_folder : str, optional Directory to write the plots into. If ``None``, plots are skipped. - lickspout_x, lickspout_y1, lickspout_y2, lickspout_z : numpy.ndarray, optional - Per-trial lickspout position arrays passed through to the side-bias figure. - rewarded_left, rewarded_right, autowater_left, autowater_right, \ -reward_probability_left, reward_probability_right : numpy.ndarray, optional - Per-trial arrays passed through to the side-bias figure. - go_cue_times, manual_left_times, manual_right_times : numpy.ndarray, optional - Event timestamps (s) passed through to the side-bias figure. + manual_left_times, manual_right_times : numpy.ndarray, optional + Manual-water delivery timestamps (s); event-time arrays passed through + to the side-bias figure. Returns ------- list of QCResult The average-side-bias result followed by the four lick-interval results. """ + side_bias = _column(trials, "side_bias") results = [ side_bias_result(side_bias), *lick_interval_results(left_lick_times, right_lick_times), ] if results_folder is not None: plot_side_bias( - animal_response, + _column(trials, "animal_response"), side_bias, results_folder, - lickspout_x=lickspout_x, - lickspout_y1=lickspout_y1, - lickspout_y2=lickspout_y2, - lickspout_z=lickspout_z, - rewarded_left=rewarded_left, - rewarded_right=rewarded_right, - reward_probability_left=reward_probability_left, - reward_probability_right=reward_probability_right, - go_cue_times=go_cue_times, - autowater_left=autowater_left, - autowater_right=autowater_right, + lickspout_x=_column(trials, "lickspout_x"), + lickspout_y1=_column(trials, "lickspout_y1"), + lickspout_y2=_column(trials, "lickspout_y2"), + lickspout_z=_column(trials, "lickspout_z"), + rewarded_left=_column(trials, "rewarded_left"), + rewarded_right=_column(trials, "rewarded_right"), + reward_probability_left=_column(trials, "reward_probability_left"), + reward_probability_right=_column(trials, "reward_probability_right"), + go_cue_times=_column(trials, "go_cue_times"), + autowater_left=_column(trials, "autowater_left"), + autowater_right=_column(trials, "autowater_right"), manual_left_times=manual_left_times, manual_right_times=manual_right_times, ) diff --git a/src/dynamic_foraging_processing/qc/processed/stage.py b/src/dynamic_foraging_processing/qc/processed/stage.py index 69d3689..113412b 100644 --- a/src/dynamic_foraging_processing/qc/processed/stage.py +++ b/src/dynamic_foraging_processing/qc/processed/stage.py @@ -1,6 +1,6 @@ """Processed-data QC stage. -``ProcessedQC`` wraps the behavior metrics computed from per-trial arrays +``ProcessedQC`` wraps the behavior metrics computed from the trials table (side bias, lick intervals) into the ``BaseQC`` interface. It is a thin wrapper over :func:`behavior_qc_results`; the metric computation lives there. """ @@ -8,6 +8,7 @@ import typing as t import numpy as np +import pandas as pd from aind_data_schema.core.quality_control import QCMetric from dynamic_foraging_processing.qc._core.base import BaseQC @@ -16,27 +17,15 @@ class ProcessedQC(BaseQC): - """Behavior QC over the processed per-trial / event arrays.""" + """Behavior QC over the trials table and lick-time arrays.""" def run( self, - animal_response: np.ndarray, - side_bias: np.ndarray, + trials: pd.DataFrame, left_lick_times: np.ndarray, right_lick_times: np.ndarray, results_folder: t.Optional[str] = None, *, - lickspout_x: t.Optional[np.ndarray] = None, - lickspout_y1: t.Optional[np.ndarray] = None, - lickspout_y2: t.Optional[np.ndarray] = None, - lickspout_z: t.Optional[np.ndarray] = None, - rewarded_left: t.Optional[np.ndarray] = None, - rewarded_right: t.Optional[np.ndarray] = None, - reward_probability_left: t.Optional[np.ndarray] = None, - reward_probability_right: t.Optional[np.ndarray] = None, - go_cue_times: t.Optional[np.ndarray] = None, - autowater_left: t.Optional[np.ndarray] = None, - autowater_right: t.Optional[np.ndarray] = None, manual_left_times: t.Optional[np.ndarray] = None, manual_right_times: t.Optional[np.ndarray] = None, ) -> t.List[QCMetric]: @@ -48,20 +37,16 @@ def run( Parameters ---------- - animal_response : numpy.ndarray - Per-trial choice codes (``0`` left, ``1`` right, ``2`` ignore). - side_bias : numpy.ndarray - Per-trial side bias from the trial table (right minus left). + trials : pandas.DataFrame + Trials table; the per-trial inputs (side bias, animal response, + lickspout positions, reward / autowater columns, go-cue times) are + read from it by column. left_lick_times, right_lick_times : numpy.ndarray Timestamps (s) of left/right-port licks. results_folder : str, optional Directory to write the plots into. If ``None``, plots are skipped. - lickspout_x, lickspout_y1, lickspout_y2, lickspout_z, rewarded_left, \ -rewarded_right, autowater_left, autowater_right, reward_probability_left, \ -reward_probability_right : numpy.ndarray, optional - Optional per-trial arrays passed through to the side-bias figure. - go_cue_times, manual_left_times, manual_right_times : numpy.ndarray, optional - Optional event timestamps passed through to the side-bias figure. + manual_left_times, manual_right_times : numpy.ndarray, optional + Manual-water delivery timestamps passed through to the side-bias figure. Returns ------- @@ -69,22 +54,10 @@ def run( The side-bias metric followed by the four lick-interval metrics. """ results = behavior_qc_results( - animal_response, - side_bias, + trials, left_lick_times, right_lick_times, results_folder, - lickspout_x=lickspout_x, - lickspout_y1=lickspout_y1, - lickspout_y2=lickspout_y2, - lickspout_z=lickspout_z, - rewarded_left=rewarded_left, - rewarded_right=rewarded_right, - reward_probability_left=reward_probability_left, - reward_probability_right=reward_probability_right, - go_cue_times=go_cue_times, - autowater_left=autowater_left, - autowater_right=autowater_right, manual_left_times=manual_left_times, manual_right_times=manual_right_times, ) From 07edbe3c9700388ff4417378b110f08f8028c8aa Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 14:44:09 -0700 Subject: [PATCH 25/28] test: update tests --- tests/test_qc/test_builder.py | 27 +++++++++++++++++++++------ tests/test_qc/test_stages.py | 13 +++++++++---- 2 files changed, 30 insertions(+), 10 deletions(-) diff --git a/tests/test_qc/test_builder.py b/tests/test_qc/test_builder.py index a052fcb..69507e8 100644 --- a/tests/test_qc/test_builder.py +++ b/tests/test_qc/test_builder.py @@ -4,6 +4,7 @@ import os import numpy as np +import pandas as pd from aind_data_schema.core.quality_control import QualityControl from dynamic_foraging_processing.qc._core import builder as _builder @@ -13,9 +14,14 @@ def test_behavior_qc_results_without_plots(): """Five behavior results are produced and no plots are written.""" + trials = pd.DataFrame( + { + "animal_response": [0, 1, 2, 1], + "side_bias": [-0.1, 0.0, np.nan, 0.1], + } + ) results = _results.behavior_qc_results( - np.array([0, 1, 2, 1]), - np.array([-0.1, 0.0, np.nan, 0.1]), + trials, np.array([1.0, 1.01]), np.array([2.0, 2.01]), ) @@ -25,9 +31,14 @@ def test_behavior_qc_results_without_plots(): def test_behavior_qc_results_writes_plots(tmp_path): """Supplying a results folder writes both behavior plots.""" + trials = pd.DataFrame( + { + "animal_response": [0, 1, 2, 1], + "side_bias": [-0.1, 0.0, np.nan, 0.1], + } + ) results = _results.behavior_qc_results( - np.array([0, 1, 2, 1]), - np.array([-0.1, 0.0, np.nan, 0.1]), + trials, np.array([1.0, 1.01]), np.array([2.0, 2.01]), str(tmp_path), @@ -41,7 +52,9 @@ def test_build_quality_control_defaults(): """Defaults fill in the standard grouping and an empty failure allowlist.""" metrics = to_metrics( _results.behavior_qc_results( - np.array([0, 1]), np.array([0.1, -0.1]), np.array([1.0]), np.array([2.0]) + pd.DataFrame({"animal_response": [0, 1], "side_bias": [0.1, -0.1]}), + np.array([1.0]), + np.array([2.0]), ) ) qc = _builder.build_quality_control(metrics) @@ -54,7 +67,9 @@ def test_build_quality_control_overrides(): """Explicit grouping / allowlist / metadata are passed through.""" metrics = to_metrics( _results.behavior_qc_results( - np.array([0, 1]), np.array([0.1, -0.1]), np.array([1.0]), np.array([2.0]) + pd.DataFrame({"animal_response": [0, 1], "side_bias": [0.1, -0.1]}), + np.array([1.0]), + np.array([2.0]), ) ) qc = _builder.build_quality_control( diff --git a/tests/test_qc/test_stages.py b/tests/test_qc/test_stages.py index 5863edc..48db160 100644 --- a/tests/test_qc/test_stages.py +++ b/tests/test_qc/test_stages.py @@ -3,6 +3,7 @@ import os import numpy as np +import pandas as pd import pytest from aind_data_schema.core.quality_control import QCMetric @@ -45,9 +46,11 @@ def _fake_contract_qc_metrics(dataset, results_folder): def test_processed_qc_run_returns_metrics(): """``ProcessedQC.run`` produces the five behavior metrics.""" + trials = pd.DataFrame( + {"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]} + ) metrics = ProcessedQC().run( - np.array([0, 1, 2, 1]), - np.array([-0.1, 0.0, np.nan, 0.1]), + trials, np.array([1.0, 1.01]), np.array([2.0, 2.01]), ) @@ -58,9 +61,11 @@ def test_processed_qc_run_returns_metrics(): def test_processed_qc_run_writes_plots(tmp_path): """Supplying a results folder writes the supporting plots.""" + trials = pd.DataFrame( + {"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]} + ) metrics = ProcessedQC().run( - np.array([0, 1, 2, 1]), - np.array([-0.1, 0.0, np.nan, 0.1]), + trials, np.array([1.0, 1.01]), np.array([2.0, 2.01]), str(tmp_path), From a5e2822e630a4460e497d567c5d56daf0c7eec9d Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 16:25:10 -0700 Subject: [PATCH 26/28] refactor: round to 3 decimal places --- .../qc/processed/behavior.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/dynamic_foraging_processing/qc/processed/behavior.py b/src/dynamic_foraging_processing/qc/processed/behavior.py index 0cdbc91..73e6ebe 100644 --- a/src/dynamic_foraging_processing/qc/processed/behavior.py +++ b/src/dynamic_foraging_processing/qc/processed/behavior.py @@ -127,7 +127,7 @@ def side_bias_result(side_bias: np.ndarray) -> QCResult: if values.size == 0 or np.all(np.isnan(values)): mean_bias = float("nan") else: - mean_bias = float(np.nanmean(values)) + mean_bias = round(float(np.nanmean(values)), 3) name = "average side bias" return QCResult( name=name, @@ -160,10 +160,10 @@ def lick_interval_results( """ results = calculate_lick_intervals(left_lick_times, right_lick_times) specs = [ - ("Left Lick Interval (%)", results["LeftLickIntervalPercent"], 10.0), - ("Right Lick Interval (%)", results["RightLickIntervalPercent"], 10.0), - ("Cross Side Lick Interval (%)", results["CrossSideIntervalPercent"], 10.0), - ("Artifact Percent (%)", results["ArtifactPercent"], 1.0), + ("Left Lick Interval (%)", round(results["LeftLickIntervalPercent"], 3), 10.0), + ("Right Lick Interval (%)", round(results["RightLickIntervalPercent"], 3), 10.0), + ("Cross Side Lick Interval (%)", round(results["CrossSideIntervalPercent"], 3), 10.0), + ("Artifact Percent (%)", round(results["ArtifactPercent"], 3), 1.0), ] return [ QCResult( From 6a3feb861b7b0953a6b2e028021b568c1bdff4de Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 16:25:30 -0700 Subject: [PATCH 27/28] refactor: update qc notebook --- examples/qc_example.ipynb | 108 ++++++++++++++++++++++++-------------- 1 file changed, 69 insertions(+), 39 deletions(-) diff --git a/examples/qc_example.ipynb b/examples/qc_example.ipynb index 2aefbf7..2710f3d 100644 --- a/examples/qc_example.ipynb +++ b/examples/qc_example.ipynb @@ -23,14 +23,15 @@ "source": [ "## Create synthetic data\n", "\n", - "A random per-trial choice sequence, plus the optional per-trial context the\n", + "A random per-trial choice sequence plus the optional per-trial context the\n", "side-bias figure can display (reward history, reward probabilities, autowater,\n", - "go-cue times). None of this needs a dataset." + "go-cue times), assembled into a `trials` DataFrame using the same column names\n", + "the QC entry points expect. None of this needs a dataset." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "72ca85eb", "metadata": { "execution": { @@ -48,12 +49,14 @@ "n trials: 200\n", "left (0): 70\n", "right (1): 100\n", - "ignore(2): 30\n" + "ignore(2): 30\n", + "columns: ['animal_response', 'side_bias', 'rewarded_historyL', 'rewarded_historyR', 'auto_waterL', 'auto_waterR', 'reward_probabilityL', 'reward_probabilityR', 'goCue_start_time']\n" ] } ], "source": [ "import numpy as np\n", + "import pandas as pd\n", "\n", "rng = np.random.default_rng(0)\n", "n_trials = 200\n", @@ -61,13 +64,12 @@ "# Choice per trial: 0 left, 1 right, 2 ignore (slightly right-biased here).\n", "animal_response = rng.choice([0, 1, 2], size=n_trials, p=[0.4, 0.5, 0.1])\n", "\n", - "# Per-trial side bias from the trial table (right minus left); nan on ignore\n", - "# trials. Synthetic here: a mild rightward bias.\n", - "side_bias = np.where(\n", - " animal_response == 2, np.nan, np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0)\n", - ")\n", + "# Per-trial side bias from the trial table (right minus left). Computed over a\n", + "# sliding window, so it is nan only after many consecutive non-responses;\n", + "# synthetic here as a mild rightward bias.\n", + "side_bias = np.clip(rng.normal(0.15, 0.2, n_trials), -1.0, 1.0)\n", "\n", - "# Optional per-trial context (synthetic), one array per column.\n", + "# Per-trial context (synthetic), one column each.\n", "rewarded_left = (animal_response == 0) & (rng.random(n_trials) < 0.5)\n", "rewarded_right = (animal_response == 1) & (rng.random(n_trials) < 0.5)\n", "autowater_left = np.zeros(n_trials, int)\n", @@ -76,10 +78,28 @@ "reward_probability_right = np.full(n_trials, 0.6)\n", "go_cue_times = np.arange(n_trials, dtype=float)\n", "\n", + "# Assemble the trials table. Column names match what the QC entry points expect\n", + "# (see `_COLUMNS` in qc.processed.results); a real session uses the table from\n", + "# `TrialTableBuilder.build()`.\n", + "trials = pd.DataFrame(\n", + " {\n", + " \"animal_response\": animal_response,\n", + " \"side_bias\": side_bias,\n", + " \"rewarded_historyL\": rewarded_left,\n", + " \"rewarded_historyR\": rewarded_right,\n", + " \"auto_waterL\": autowater_left,\n", + " \"auto_waterR\": autowater_right,\n", + " \"reward_probabilityL\": reward_probability_left,\n", + " \"reward_probabilityR\": reward_probability_right,\n", + " \"goCue_start_time\": go_cue_times,\n", + " }\n", + ")\n", + "\n", "print(\"n trials:\", n_trials)\n", "print(\"left (0):\", int(np.sum(animal_response == 0)))\n", "print(\"right (1):\", int(np.sum(animal_response == 1)))\n", - "print(\"ignore(2):\", int(np.sum(animal_response == 2)))" + "print(\"ignore(2):\", int(np.sum(animal_response == 2)))\n", + "print(\"columns:\", list(trials.columns))" ] }, { @@ -95,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "abb13a1f", "metadata": { "execution": { @@ -110,13 +130,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "average side bias: 0.143\n" + "average side bias: 0.132\n" ] } ], "source": [ - "mean_bias = np.nanmean(side_bias)\n", - "print(f\"average side bias: {mean_bias:.3f}\")" + "mean_bias = round(float(np.nanmean(side_bias)), 3)\n", + "print(f\"average side bias: {mean_bias}\")" ] }, { @@ -131,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "58755f21", "metadata": { "execution": { @@ -147,7 +167,7 @@ "output_type": "stream", "text": [ "name: average side bias\n", - "value: 0.1433020947617509\n", + "value: 0.132\n", "passed: True\n", "tags: {'behavior': 'average side bias'}\n" ] @@ -155,10 +175,10 @@ { "data": { "text/plain": [ - "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 27, 54, 559581, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" + "QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.132, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 27, 352495, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias across the session (right is positive).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None)" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -191,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "72a51175", "metadata": { "execution": { @@ -208,7 +228,7 @@ "'side_bias.png'" ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -237,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "0a361145", "metadata": { "execution": { @@ -250,12 +270,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -282,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "31cf3d8f", "metadata": { "execution": { @@ -315,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "445aa290", "metadata": { "execution": { @@ -360,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "09aa51c9", "metadata": { "execution": { @@ -377,7 +397,7 @@ "'lick_intervals.png'" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -390,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "fc39babb", "metadata": { "execution": { @@ -408,7 +428,7 @@ "" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -424,14 +444,18 @@ "source": [ "## Assemble a `QualityControl` object\n", "\n", - "Collect the behavior metrics — the average side bias plus the four\n", - "inter-lick-interval checks — into a single `QualityControl`. `to_metrics`\n", - "converts the list of `QCResult` objects into schema `QCMetric`s in one step." + "The individual checks above can be collected in one call: `behavior_qc_results`\n", + "takes the `trials` table plus the left/right lick-time arrays and returns the\n", + "ordered list of `QCResult`s — the average side bias followed by the four\n", + "inter-lick-interval checks. `to_metrics` converts them to schema `QCMetric`s, and\n", + "`build_quality_control` assembles the final `QualityControl`. (Passing a\n", + "`results_folder` would also write the supporting plots; omitted here since the\n", + "cells above already produced them.)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "bf1b9b08", "metadata": { "execution": { @@ -458,19 +482,25 @@ { "data": { "text/plain": [ - "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.1433020947617509, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average of the per-trial side bias (right minus left).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Left Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.27, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Left Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Left Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Right Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=12.42, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Fail', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Right Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Right Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Cross Side Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.89, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Cross Side Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Cross Side Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Artifact Percent (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.44493882091212456, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 22, 10, 28, 9, 985668, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Artifact Percent (%) of inter-lick intervals; passes when < 1.0.', reference='lick_intervals.png', tags={'behavior': 'Artifact Percent (%)'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:Right Lick Interval (%)': , 'behavior:Artifact Percent (%)': , 'behavior:average side bias': , 'behavior:Cross Side Lick Interval (%)': , 'behavior:Left Lick Interval (%)': , 'behavior': , 'Raw data': })" + "QualityControl(object_type='Quality control', describedBy='https://raw.githubusercontent.com/AllenNeuralDynamics/aind-data-schema/main/src/aind_data_schema/core/quality_control.py', schema_version='2.4.2', metrics=[QCMetric(object_type='QC metric', name='average side bias', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.132, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Average side bias across the session (right is positive).', reference='side_bias.png', tags={'behavior': 'average side bias'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Left Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.27, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Left Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Left Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Right Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=12.42, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Fail', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Right Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Right Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Cross Side Lick Interval (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=9.89, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Cross Side Lick Interval (%) of inter-lick intervals; passes when < 10.0.', reference='lick_intervals.png', tags={'behavior': 'Cross Side Lick Interval (%)'}, evaluated_assets=None), QCMetric(object_type='QC metric', name='Artifact Percent (%)', modality=_Behavior(name='Behavior', abbreviation='behavior'), stage='Raw data', value=0.445, status_history=[QCStatus(object_type='QC status', evaluator='Automated', status='Pass', timestamp=datetime.datetime(2026, 6, 23, 16, 24, 45, 236104, tzinfo=zoneinfo.ZoneInfo(key='America/Los_Angeles')))], description='Artifact Percent (%) of inter-lick intervals; passes when < 1.0.', reference='lick_intervals.png', tags={'behavior': 'Artifact Percent (%)'}, evaluated_assets=None)], key_experimenters=None, notes=None, default_grouping=['behavior', 'test_suite'], allow_tag_failures=[], status={'behavior:Right Lick Interval (%)': , 'behavior:Cross Side Lick Interval (%)': , 'behavior:Left Lick Interval (%)': , 'behavior:average side bias': , 'behavior:Artifact Percent (%)': , 'behavior': , 'Raw data': })" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from dynamic_foraging_processing.qc import build_quality_control, to_metrics\n", + "from dynamic_foraging_processing.qc import (\n", + " behavior_qc_results,\n", + " build_quality_control,\n", + " to_metrics,\n", + ")\n", "\n", - "# All behavior metrics: the average side bias plus the four lick-interval checks.\n", - "behavior_metrics = to_metrics([result, *lick_results])\n", + "# One call collects all five behavior results from the trials table plus the\n", + "# lick-time arrays: the average side bias and the four lick-interval checks.\n", + "behavior_results = behavior_qc_results(trials, left_lick_times, right_lick_times)\n", + "behavior_metrics = to_metrics(behavior_results)\n", "\n", "quality_control = build_quality_control(behavior_metrics)\n", "print(\"total metrics:\", len(quality_control.metrics))\n", From 9601087fd24f8e8a847341a3bc4680b73cd21d06 Mon Sep 17 00:00:00 2001 From: arjunsridhar12345 Date: Tue, 23 Jun 2026 16:35:12 -0700 Subject: [PATCH 28/28] chore: linting --- tests/test_qc/test_stages.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/tests/test_qc/test_stages.py b/tests/test_qc/test_stages.py index 48db160..11d23bd 100644 --- a/tests/test_qc/test_stages.py +++ b/tests/test_qc/test_stages.py @@ -46,9 +46,7 @@ def _fake_contract_qc_metrics(dataset, results_folder): def test_processed_qc_run_returns_metrics(): """``ProcessedQC.run`` produces the five behavior metrics.""" - trials = pd.DataFrame( - {"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]} - ) + trials = pd.DataFrame({"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]}) metrics = ProcessedQC().run( trials, np.array([1.0, 1.01]), @@ -61,9 +59,7 @@ def test_processed_qc_run_returns_metrics(): def test_processed_qc_run_writes_plots(tmp_path): """Supplying a results folder writes the supporting plots.""" - trials = pd.DataFrame( - {"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]} - ) + trials = pd.DataFrame({"animal_response": [0, 1, 2, 1], "side_bias": [-0.1, 0.0, np.nan, 0.1]}) metrics = ProcessedQC().run( trials, np.array([1.0, 1.01]),