ictrp-mcp-server 0.1.0

package/sidecar/vendor/ictrp_mcp/data/normalize.py

@@ -0,0 +1,348 @@
+"""CSV rows -> canonical trial dicts.
+
+Every accessor here is total: a row of any length yields a dict with every
+canonical key present. Missing values are `None`, never `""`, so that callers can
+distinguish "we did not get this" from "the source said blank".
+
+Type modelling reflects measured reality (docs/MEASUREMENTS.md section 4):
+
+* `Target size` is polymorphic -- a bare integer, or per-arm breakdowns like
+  `'Drug A:49;Drug B:49;'`. A naive `int()` raises or loses rows.
+* `Study design` is polymorphic -- a controlled term like `'Parallel'`, or a full
+  CT.gov sentence. It is NOT a closed enum.
+* `Recruitment Status` casing is inconsistent upstream, so comparisons normalize.
+* `Phase` uses a ChiCTR-specific vocabulary that shares no tokens with CT.gov.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from .columns import CSV_COLUMNS
+
+_NULLISH = {"", "n/a", "na", "not applicable", "none", "unknown", "null", "-"}
+
+#: Date shapes measured in the export.
+_DATE_DDMMYYYY = re.compile(r"^(\d{1,2})/(\d{1,2})/(\d{4})$")
+_DATE_YYYYMMDD = re.compile(r"^(\d{4})(\d{2})(\d{2})$")
+_DATE_DMONTHYYYY = re.compile(r"^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$")
+_DATETIME_DDMMYYYY = re.compile(
+    r"^(\d{1,2})/(\d{1,2})/(\d{4})\s+(\d{1,2}):(\d{2}):(\d{2})$"
+)
+
+_MONTHS = {
+    "january": 1, "february": 2, "march": 3, "april": 4, "may": 5, "june": 6,
+    "july": 7, "august": 8, "september": 9, "october": 10, "november": 11,
+    "december": 12,
+}
+
+#: Ordering for combined phases such as 'Phase 1/Phase 2'.
+_ROMAN_ORDER = ["I", "II", "III", "IV"]
+
+#: Roman numeral -> registry phase digit.
+_ROMAN_NUMERAL = {"I": "1", "II": "2", "III": "3", "IV": "4"}
+
+#: Registry phase digit -> roman numeral.
+_NUMERAL_ROMAN = {"1": "I", "2": "II", "3": "III", "4": "IV"}
+
+
+def _to_roman(token: str) -> str:
+    """Normalize a captured phase token to a roman numeral (upper case)."""
+    token = token.upper()
+    return _NUMERAL_ROMAN.get(token, token)
+
+
+def clean(value: str | None) -> str | None:
+    """Strip and null-normalize a raw cell."""
+    if value is None:
+        return None
+    text = value.strip()
+    if text.lower() in _NULLISH:
+        return None
+    return text
+
+
+def parse_iso_date(value: str | None, *, day_first: bool = True) -> str | None:
+    """Parse a measured export date shape into `YYYY-MM-DD`.
+
+    Day-first is verified, not assumed: cross-checked against the unambiguous
+    `Date registration3` twin across 6,262 rows with zero contradictions. Prefer
+    `parse_registration_date` which uses that unambiguous field directly.
+    """
+    text = clean(value)
+    if text is None:
+        return None
+
+    if m := _DATE_YYYYMMDD.match(text):
+        return f"{m.group(1)}-{m.group(2)}-{m.group(3)}"
+
+    if m := _DATE_DDMMYYYY.match(text):
+        a, b, y = int(m.group(1)), int(m.group(2)), m.group(3)
+        day, month = (a, b) if day_first else (b, a)
+        return _safe_iso(y, month, day)
+
+    if m := _DATETIME_DDMMYYYY.match(text):
+        a, b, y = int(m.group(1)), int(m.group(2)), m.group(3)
+        day, month = (a, b) if day_first else (b, a)
+        return _safe_iso(y, month, day)
+
+    if m := _DATE_DMONTHYYYY.match(text):
+        month = _MONTHS.get(m.group(2).lower())
+        if month is None:
+            return None
+        return _safe_iso(m.group(3), month, int(m.group(1)))
+
+    return None
+
+
+def _safe_iso(year: str, month: int, day: int) -> str | None:
+    if not (1 <= month <= 12 and 1 <= day <= 31):
+        return None
+    return f"{int(year):04d}-{month:02d}-{day:02d}"
+
+
+def split_semicolon_list(value: str | None) -> list[str]:
+    """Split a `;`-delimited field, dropping empties.
+
+    Measured: `Secondary ID` uses `;` (`'NCI-2026-06905;2026-1028'`), as do
+    outcome and intervention fields.
+    """
+    text = clean(value)
+    if text is None:
+        return []
+    return [p.strip() for p in text.split(";") if p.strip()]
+
+
+_TARGET_ARM_RE = re.compile(r"^(.+?):\s*(\d+)\s*$")
+
+
+@dataclass(frozen=True)
+class TargetSize:
+    """Parsed `Target size`.
+
+    Either a single total, or per-arm counts. Measured examples:
+    `'200'` and `'Capecitabine maintenance group:49;S-1 maintenance group:49;'`.
+    """
+
+    total: int | None
+    arms: dict[str, int]
+    raw: str | None
+
+    @property
+    def is_arm_split(self) -> bool:
+        return bool(self.arms)
+
+    @property
+    def summed(self) -> int | None:
+        if self.total is not None:
+            return self.total
+        if self.arms:
+            return sum(self.arms.values())
+        return None
+
+
+def parse_target_size(value: str | None) -> TargetSize:
+    text = clean(value)
+    if text is None:
+        return TargetSize(total=None, arms={}, raw=None)
+
+    if text.isdigit():
+        return TargetSize(total=int(text), arms={}, raw=text)
+
+    arms: dict[str, int] = {}
+    for part in text.split(";"):
+        part = part.strip()
+        if not part:
+            continue
+        if m := _TARGET_ARM_RE.match(part):
+            arms[m.group(1).strip()] = int(m.group(2))
+    if arms:
+        return TargetSize(total=None, arms=arms, raw=text)
+
+    # Last resort: a leading integer inside free text.
+    m = re.search(r"\b(\d{1,7})\b", text)
+    return TargetSize(total=int(m.group(1)) if m else None, arms={}, raw=text)
+
+
+def parse_phase(value: str | None) -> tuple[str | None, str | None]:
+    """Return `(registry_code, phase_roman)`.
+
+    The phase vocabulary is a genuine mixture and must be read defensively. Values
+    observed in a full export include `'Phase 1'`, `'Phase 2'`, `'Phase 1/Phase 2'`,
+    a bare `'2'`, `'N/A'`, `'Not selected'`, `'Not Applicable'`, plus ChiCTR-only
+    terms that contain no "phase" token at all (`'Other'`, `'Post-market'`,
+    `'Pilot study'`, `'Retrospective study'`,
+    `'New Treatment Measure Clinical Study'`).
+
+    `None` therefore means "no phase concept applies or none was recorded", which
+    is distinct from `'OTHER'` ("a phase concept exists that we cannot map"). The
+    raw string is always retained by the caller.
+    """
+    # Read the raw cell, not `clean()`. `clean()` nulls `'N/A'` and `'Not
+    # Applicable'`, but here those are meaningful values that must be mapped to
+    # the NA code rather than collapsed into "absent".
+    if value is None:
+        return None, None
+    text = value.strip()
+    if not text:
+        return None, None
+
+    low = text.lower()
+
+    # Explicit non-phase markers.
+    if low in ("n/a", "na", "not applicable", "not selected", "none", "unknown", "null", "-"):
+        return "NA", None
+
+    # Phases appear as roman numerals ('Phase II', 'I (Phase I study)') and as
+    # bare digits ('Phase 2'). The alternation must try the longer roman numerals
+    # first, and must not use a trailing \b after a single 'i'.
+    combined = re.findall(r"phase\s*(iv|iii|ii|i|[1-4])(?![a-z0-9])", low)
+    if combined:
+        romans = sorted({_to_roman(tok) for tok in combined}, key=_ROMAN_ORDER.index)
+        if len(romans) == 1:
+            return f"PHASE{_ROMAN_NUMERAL[romans[0]]}", romans[0]
+        # Multi-phase values keep a single PHASE prefix and slash-joined numerals,
+        # e.g. 'PHASEI/II'. `phase_roman` is the human-readable pair.
+        return "PHASE" + "/".join(romans), "/".join(romans)
+
+    # Hyphenated ranges, e.g. '1-2', '2-3'.
+    if m := re.fullmatch(r"([1-4])\s*[-–]\s*([1-4])", low):
+        romans = [_NUMERAL_ROMAN[m.group(1)], _NUMERAL_ROMAN[m.group(2)]]
+        romans = sorted(set(romans), key=_ROMAN_ORDER.index)
+        return "PHASE" + "/".join(romans), "/".join(romans)
+
+    # A bare roman numeral, e.g. 'III'. Required to come after the range check so
+    # it cannot swallow a hyphenated value.
+    if low.upper() in _ROMAN_NUMERAL:
+        roman = low.upper()
+        return f"PHASE{_ROMAN_NUMERAL[roman]}", roman
+
+    # 'Phase 0' / exploratory. No PHASE0 registry code exists, so it is reported
+    # as its own concept rather than forced into PHASE1.
+    if low in ("0", "phase 0", "phase0"):
+        return "PHASE0", None
+
+    # Bare numerals, e.g. '2'. Only trusted when the cell is just a number, so a
+    # stray digit inside prose cannot be misread as a phase.
+    if low.isdigit() and low in {"1", "2", "3", "4"}:
+        return f"PHASE{low}", _NUMERAL_ROMAN[low]
+
+    if "post-market" in low or "post market" in low:
+        return "PHASE4", "IV"
+    if "pilot" in low or "retrospective" in low:
+        return "NA", None
+
+    return "OTHER", None
+
+
+def _canonical_keys() -> tuple[str, ...]:
+    """Stable snake_case keys for all 58 source columns."""
+    out: list[str] = []
+    for col in CSV_COLUMNS:
+        key = col.lower()
+        key = re.sub(r"[^a-z0-9]+", "_", key).strip("_")
+        out.append(key)
+    return tuple(out)
+
+
+CANONICAL_KEYS: tuple[str, ...] = _canonical_keys()
+
+#: source column -> canonical key
+COLUMN_TO_KEY: dict[str, str] = dict(zip(CSV_COLUMNS, CANONICAL_KEYS))
+
+#: canonical key -> source column
+KEY_TO_COLUMN: dict[str, str] = dict(zip(CANONICAL_KEYS, CSV_COLUMNS))
+
+
+def row_to_raw(row: list[str], header: tuple[str, ...]) -> dict[str, str | None]:
+    """Map one CSV row onto canonical keys, preserving source column names."""
+    out: dict[str, str | None] = {}
+    for index, column in enumerate(header):
+        key = COLUMN_TO_KEY.get(column)
+        if key is None:
+            continue
+        out[key] = row[index] if index < len(row) else None
+    for column, key in COLUMN_TO_KEY.items():
+        out.setdefault(key, None)
+    return out
+
+
+def to_trial(row: list[str], header: tuple[str, ...]) -> dict[str, Any]:
+    """Build a canonical trial dict from one CSV row.
+
+    Adds derived fields alongside the raw ones. Raw values are always retained;
+    derived values are additive and never overwrite the source.
+    """
+    raw = row_to_raw(row, header)
+    trial: dict[str, Any] = dict(raw)
+
+    trial["trial_id"] = clean(raw.get("trialid"))
+    trial["source_register"] = clean(raw.get("source_register"))
+    trial["public_title"] = clean(raw.get("public_title"))
+    trial["scientific_title"] = clean(raw.get("scientific_title"))
+    trial["condition"] = clean(raw.get("condition"))
+    trial["countries"] = split_semicolon_list(raw.get("countries"))
+    trial["secondary_ids"] = split_semicolon_list(raw.get("secondary_id"))
+    trial["interventions"] = split_semicolon_list(raw.get("intervention"))
+    trial["primary_outcomes"] = split_semicolon_list(raw.get("primary_outcome"))
+    trial["secondary_outcomes"] = split_semicolon_list(raw.get("secondary_outcome"))
+
+    # Authoritative date: registration3 is unambiguous yyyymmdd. The dd/mm/yyyy
+    # twin is day-first (verified) but only used as a fallback.
+    authoritative = parse_iso_date(raw.get("date_registration3"))
+    fallback = parse_iso_date(raw.get("date_registration"))
+    trial["registration_date"] = authoritative or fallback
+    trial["registration_date_source"] = (
+        "date_registration3" if authoritative else ("date_registration" if fallback else None)
+    )
+    trial["registration_date_display"] = clean(raw.get("date_registration"))
+    # `Last Refreshed on` is reported as `d Month yyyy`; keep the raw string too
+    # because it is the visible data-currency marker users will compare against.
+    trial["last_refreshed_display"] = clean(raw.get("last_refreshed_on"))
+    trial["last_refreshed_date"] = parse_iso_date(raw.get("last_refreshed_on"))
+    trial["export_date_raw"] = clean(raw.get("export_date"))
+    trial["export_date"] = parse_iso_date(raw.get("export_date"))
+
+    phase_code, phase_roman = parse_phase(raw.get("phase"))
+    trial["phase_code"] = phase_code
+    trial["phase_roman"] = phase_roman
+
+    status = clean(raw.get("recruitment_status"))
+    trial["recruitment_status"] = status
+    trial["recruitment_status_normalized"] = status.lower() if status else None
+
+    target = parse_target_size(raw.get("target_size"))
+    trial["target_size_total"] = target.summed
+    trial["target_size_arms"] = target.arms or None
+    trial["target_size_is_arm_split"] = target.is_arm_split
+
+    age_min = clean(raw.get("inclusion_agemin"))
+    age_max = clean(raw.get("inclusion_agemax"))
+    trial["inclusion_age_min"] = _as_int(age_min)
+    trial["inclusion_age_max"] = _as_int(age_max)
+
+    # `results yes no` is a flag, not content, so it is excluded from the test.
+    # Measured: the substantive `results *` columns are ~0.0% populated for
+    # ChiCTR records, so this is a property of the registry rather than of an
+    # individual trial -- but it is computed per trial so other registries
+    # (which do post results) are represented correctly.
+    trial["carries_results_data"] = any(
+        clean(raw.get(f"results_{suffix}"))
+        for suffix in (
+            "date_posted", "url_link", "url_protocol", "date_completed",
+            "date_first_publication", "summary", "baseline_char", "adverse_events",
+            "outcome_measures", "ipd_plan", "ipd_description",
+        )
+    )
+
+    return trial
+
+
+def _as_int(value: str | None) -> int | None:
+    text = clean(value)
+    if text is None:
+        return None
+    m = re.search(r"-?\d+", text)
+    return int(m.group(0)) if m else None

package/sidecar/vendor/ictrp_mcp/data/query.py

@@ -0,0 +1,307 @@
+"""Local querying over a materialized result set.
+
+None of these functions touch the network. That is the point: once an export has
+been materialized, filtering, faceting, summarizing and exporting are all local
+operations, so a user can refine a search repeatedly without re-hitting the
+portal.
+
+Every count produced here is a count of what we actually hold. It is never a
+claim about how many trials exist -- the export is provably incomplete
+(docs/MEASUREMENTS.md section 2), so the accompanying total from the portal is
+carried separately and never merged into these numbers.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from typing import Any, Iterable
+
+#: Operators supported by `apply_filters`.
+_OPERATORS = {
+    "eq", "ne", "contains", "not_contains", "in", "not_in",
+    "gt", "gte", "lt", "lte", "exists", "not_exists", "is_null", "is_not_null",
+}
+
+
+def _coerce(value: Any) -> Any:
+    """Lowercase strings for case-insensitive comparison; pass others through."""
+    if isinstance(value, str):
+        return value.strip().lower()
+    return value
+
+
+def _field_value(trial: dict[str, Any], field: str) -> Any:
+    """Resolve a field, preferring the curated alias over a raw source column.
+
+    Aliases must win. Several canonical raw keys (`phase`, `countries`,
+    `target_size`) hold unparsed source strings, while the derived key
+    (`phase_code`, `countries`, `target_size_total`) is what callers mean. If the
+    raw key were consulted first, `phase` would silently return `'Phase 2'`
+    instead of the normalized registry code.
+    """
+    alias = _ALIASES.get(field)
+    if alias is not None and alias in trial:
+        return trial[alias]
+    if field in trial:
+        return trial[field]
+    return None
+
+
+#: Convenience aliases so callers do not need to remember raw column spellings.
+#: Keys that already exist as canonical trial fields (e.g. `trial_id`,
+#: `source_register`) resolve directly and need no entry here; only renamed
+#: fields are listed.
+_ALIASES: dict[str, str] = {
+    "title": "public_title",
+    "status": "recruitment_status_normalized",
+    "register": "source_register",
+    "reg_date": "registration_date",
+    "phase": "phase_code",
+    "country": "countries",
+    "age_min": "inclusion_age_min",
+    "age_max": "inclusion_age_max",
+    "target_size": "target_size_total",
+}
+
+
+def _match(trial: dict[str, Any], field: str, operator: str, expected: Any) -> bool:
+    actual = _field_value(trial, field)
+
+    if operator == "exists" or operator == "is_not_null":
+        return actual is not None and actual != [] and actual != ""
+    if operator == "not_exists" or operator == "is_null":
+        return actual is None or actual == [] or actual == ""
+
+    if operator == "eq":
+        return _coerce(actual) == _coerce(expected)
+    if operator == "ne":
+        return _coerce(actual) != _coerce(expected)
+
+    if operator in ("contains", "not_contains"):
+        needle = _coerce(expected)
+        if isinstance(actual, list):
+            hit = any(_coerce(item) == needle or needle in str(_coerce(item)) for item in actual)
+        else:
+            hit = needle in str(_coerce(actual or ""))
+        return hit if operator == "contains" else not hit
+
+    if operator in ("in", "not_in"):
+        if not isinstance(expected, (list, tuple, set)):
+            expected = [expected]
+        options = {_coerce(e) for e in expected}
+        if isinstance(actual, list):
+            hit = any(_coerce(item) in options for item in actual)
+        else:
+            hit = _coerce(actual) in options
+        return hit if operator == "in" else not hit
+
+    if operator in ("gt", "gte", "lt", "lte"):
+        try:
+            left = float(actual)  # type: ignore[arg-type]
+            right = float(expected)  # type: ignore[arg-type]
+        except (TypeError, ValueError):
+            return False
+        return {
+            "gt": left > right, "gte": left >= right,
+            "lt": left < right, "lte": left <= right,
+        }[operator]
+
+    raise ValueError(f"unsupported operator: {operator!r}")
+
+
+def apply_filters(
+    trials: Iterable[dict[str, Any]],
+    filters: list[dict[str, Any]] | None,
+) -> list[dict[str, Any]]:
+    """Apply a conjunction of filters.
+
+    Each filter: `{"field": str, "op": str, "value": Any}`.
+    """
+    rows = list(trials)
+    if not filters:
+        return rows
+    for spec in filters:
+        field = spec.get("field")
+        operator = spec.get("op", "eq")
+        if not field:
+            raise ValueError("each filter needs a 'field'")
+        if operator not in _OPERATORS:
+            raise ValueError(
+                f"unsupported operator {operator!r}; supported: {sorted(_OPERATORS)}"
+            )
+        expected = spec.get("value")
+        rows = [r for r in rows if _match(r, field, operator, expected)]
+    return rows
+
+
+def sort_trials(
+    trials: list[dict[str, Any]],
+    sort_by: str | None,
+    descending: bool = False,
+) -> list[dict[str, Any]]:
+    """Sort, keeping null-ish values last in both directions.
+
+    Sorting is done on the populated subset only, then the missing ones are
+    appended, so a descending sort never floats blanks to the top.
+    """
+    if not sort_by:
+        return trials
+
+    populated: list[dict[str, Any]] = []
+    missing: list[dict[str, Any]] = []
+    for trial in trials:
+        value = _field_value(trial, sort_by)
+        if value is None or value == "" or value == []:
+            missing.append(trial)
+        else:
+            populated.append(trial)
+
+    populated.sort(key=lambda t: _sortable(_field_value(t, sort_by)), reverse=descending)
+    return populated + missing
+
+
+def _sortable(value: Any) -> Any:
+    if isinstance(value, list):
+        return ";".join(str(v) for v in value)
+    return value
+
+
+def facet(
+    trials: Iterable[dict[str, Any]],
+    field: str,
+    *,
+    limit: int = 50,
+) -> list[dict[str, Any]]:
+    """Value counts for a field, with the null bucket reported separately.
+
+    String values are case-folded before counting, because upstream casing is
+    inconsistent (measured: `'Not Recruiting'` alongside `'Not recruiting'`).
+    """
+    counter: Counter[str] = Counter()
+    nulls = 0
+
+    for trial in trials:
+        value = _field_value(trial, field)
+        if value is None or value == "" or value == []:
+            nulls += 1
+            continue
+        if isinstance(value, list):
+            for item in value:
+                counter[str(item).strip()] += 1
+        else:
+            counter[str(value).strip()] += 1
+
+    folded: Counter[str] = Counter()
+    display: dict[str, str] = {}
+    for value, count in counter.items():
+        key = value.lower()
+        folded[key] += count
+        display.setdefault(key, value)
+
+    top = folded.most_common(limit)
+    return [
+        {"value": display[key], "count": count}
+        for key, count in top
+    ] + ([{"value": None, "count": nulls}] if nulls else [])
+
+
+def field_coverage(
+    trials: Iterable[dict[str, Any]],
+    fields: Iterable[str] | None = None,
+) -> dict[str, dict[str, Any]]:
+    """Population statistics per field.
+
+    This is the honest complement to a result count: it says how much of each
+    field we actually have, so a caller can see that e.g. ethics fields are
+    sparse for one registry rather than assuming blank means "none recorded".
+    """
+    rows = list(trials)
+    total = len(rows)
+    names = list(fields) if fields else sorted({k for r in rows for k in r})
+    out: dict[str, dict[str, Any]] = {}
+    for name in names:
+        populated = 0
+        for row in rows:
+            value = _field_value(row, name)
+            if value is not None and value != "" and value != []:
+                populated += 1
+        out[name] = {
+            "populated": populated,
+            "total": total,
+            "coverage": round(populated / total, 4) if total else 0.0,
+        }
+    return out
+
+
+def find_duplicates(
+    trials: Iterable[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Group records that likely describe the same underlying trial.
+
+    Two distinct patterns are reported, because they need different handling:
+
+    * `shared_secondary_id` -- two or more held records name the same secondary
+      identifier. Both are in the set; a caller can compare them directly.
+    * `cross_reference` -- a held record points at an identifier that is itself
+      another held record's `TrialID`. The pair is a chain, not a shared value,
+      so matching on equality of secondary ids alone would miss it.
+
+    Only identifier evidence is used. Title matching is deliberately avoided: it
+    produces false positives on the multi-centre trials that legitimately share a
+    near-identical public title.
+    """
+    rows = list(trials)
+    id_index: dict[str, str] = {}
+    for row in rows:
+        trial_id = row.get("trial_id")
+        if trial_id:
+            id_index.setdefault(trial_id.strip().upper(), trial_id)
+
+    by_secondary: dict[str, list[str]] = {}
+    for row in rows:
+        trial_id = row.get("trial_id")
+        if not trial_id:
+            continue
+        for secondary in row.get("secondary_ids") or []:
+            key = secondary.strip().upper()
+            if key and key != trial_id.strip().upper():
+                by_secondary.setdefault(key, []).append(trial_id)
+
+    groups: list[dict[str, Any]] = []
+    seen_pairs: set[tuple[str, str]] = set()
+
+    # Pattern 1: several held records name the same secondary identifier.
+    for secondary, holders in sorted(by_secondary.items()):
+        if len(holders) < 2:
+            continue
+        groups.append(
+            {
+                "match_type": "shared_secondary_id",
+                "matched_value": secondary,
+                "trial_ids": sorted(dict.fromkeys(holders)),
+                "resolvable": False,
+            }
+        )
+
+    # Pattern 2: a record's secondary id resolves to another held record.
+    for secondary, holders in sorted(by_secondary.items()):
+        target = id_index.get(secondary)
+        if not target:
+            continue
+        for holder in dict.fromkeys(holders):
+            if holder.strip().upper() == target.strip().upper():
+                continue
+            pair = tuple(sorted((holder, target)))
+            if pair in seen_pairs:
+                continue
+            seen_pairs.add(pair)
+            groups.append(
+                {
+                    "match_type": "cross_reference",
+                    "matched_value": secondary,
+                    "trial_ids": list(pair),
+                    "resolvable": True,
+                }
+            )
+
+    return groups