allelix 2.2.0__tar.gz → 2.2.2__tar.gz

{allelix-2.2.0 → allelix-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: allelix
-Version: 2.2.0
+Version: 2.2.2
 Summary: Open-source genotype analysis toolkit. Format-agnostic ingestion, database-agnostic annotation, offline-first.
 Author: Allelix
 Maintainer-email: dial481 <dial481@users.noreply.github.com>

{allelix-2.2.0 → allelix-2.2.2}/allelix/annotators/clinvar.py

@@ -92,6 +92,101 @@ def _magnitude(clnsig: str) -> float:
     return _CLNSIG_MAGNITUDE.get(_normalize_clnsig(clnsig), 5.0)
 
 
+# GH #109: ClinVar review-status ranking — lower index = stronger
+# evidence per ClinVar's star-rating documentation. Used to pick the
+# winning row when N SCVs with identical (significance, condition,
+# gene) tuples collapse during per-SCV dedup; the surviving Annotation
+# carries the highest-rated review_status across the group instead of
+# silently dropping provenance.
+#
+# Real cache rows use the comma-and-underscore form
+# (`criteria_provided,_multiple_submitters,_no_conflicts`). The rank
+# helper normalizes via _normalize_clnsig so it's robust to spacing
+# variation. Unknown values fall through to "weakest known."
+_REVIEW_STATUS_RANK: tuple[str, ...] = (
+    "practice_guideline",
+    "reviewed_by_expert_panel",
+    "criteria_provided,_multiple_submitters,_no_conflicts",
+    "criteria_provided,_conflicting_classifications",
+    "criteria_provided,_conflicting_interpretations",
+    "criteria_provided,_single_submitter",
+    "no_assertion_criteria_provided",
+    "no_assertion_provided",
+    "no_classification_provided",
+)
+
+
+def _review_status_rank(status: str) -> int:
+    """Return the rank index for a review_status string.
+
+    Lower index = stronger evidence. Unknown / unrecognized values get
+    the max rank (weakest), so a known SCV always beats an unknown one
+    when collapsing.
+    """
+    if not status:
+        return len(_REVIEW_STATUS_RANK)
+    normalized = _normalize_clnsig(status)
+    for i, candidate in enumerate(_REVIEW_STATUS_RANK):
+        if candidate == normalized:
+            return i
+    return len(_REVIEW_STATUS_RANK)
+
+
+def _collapse_identical_scvs(annotations: list[Annotation]) -> list[Annotation]:
+    """Collapse identical per-SCV rows from the #42 TSV loader (GH #109).
+
+    Two Annotations are identical for dedup purposes if they share
+    (rsid, significance, condition, gene, alt). The surviving row carries:
+
+      - the strongest ``review_status`` across the collapsed group
+        (per ``_REVIEW_STATUS_RANK``)
+      - the union of ``references`` across the collapsed group
+        (preserving first-seen order — never silently drops provenance)
+
+    Distinct (significance, condition) pairs on the same variant are
+    preserved as separate rows — that's exactly what #42 was built to
+    surface, and collapsing them would be the Frankenstein-pair
+    regression #42 retired.
+
+    GH #109 cross-PR review (Finding 1): ``alt`` is in the key for the
+    #18 wrong-allele safety invariant. Two SCVs at a multi-allelic site
+    can share (significance, condition, gene) but differ in alt — e.g.
+    rs1065852 (G→A drug_response/Codeine_response + G→C drug_response/
+    Codeine_response would be a hypothetical). Collapsing across alts
+    would (a) drop a distinct-allele annotation and (b) mis-attach the
+    surviving row's ``alt`` field to the merged result, breaking the
+    downstream exact-(rsid, alt) lookup that gnomAD / AlphaMissense /
+    CADD use for allele-specific enrichment. The pre-#109 v2.2.0 code
+    emitted one Annotation per cache row, so this case was always
+    handled correctly; the post-#109 dedup must preserve that property.
+
+    Input order is preserved for the kept rows: each group is replaced
+    by its winner at the position of the group's first occurrence.
+    """
+    from dataclasses import replace
+
+    groups: dict[tuple[str, str, str, str, str], list[Annotation]] = {}
+    for a in annotations:
+        key = (a.rsid, a.significance, a.condition, a.gene, a.alt)
+        groups.setdefault(key, []).append(a)
+
+    out: list[Annotation] = []
+    for group in groups.values():
+        if len(group) == 1:
+            out.append(group[0])
+            continue
+        winner = min(group, key=lambda a: _review_status_rank(a.review_status))
+        seen_refs: set[str] = set()
+        merged_refs: list[str] = []
+        for a in group:
+            for ref in a.references:
+                if ref not in seen_refs:
+                    seen_refs.add(ref)
+                    merged_refs.append(ref)
+        out.append(replace(winner, references=merged_refs))
+    return out
+
+
 class ClinVarAnnotator(Annotator):
     """Annotates variants with ClinVar's clinical significance classifications.
 
@@ -502,7 +597,11 @@ class ClinVarAnnotator(Annotator):
                     alt=alt,
                 )
             )
-        return annotations
+        # GH #109: collapse identical per-SCV rows from the #42 TSV loader.
+        # Without this, a variant with N identical Pathogenic submissions
+        # emits N identical Annotation objects (visible duplicates on every
+        # surface). Distinct (significance, condition) pairs survive.
+        return _collapse_identical_scvs(annotations)
 
     def bulk_resolve_rsids(self, variants: list[Variant]) -> dict[tuple[str, int, str, str], str]:
         """Resolve rsIDs by (chromosome, position) for variants with no ID.
@@ -586,6 +685,12 @@ class ClinVarAnnotator(Annotator):
                 ]
                 if len(matches) == 1:
                     ref, alt, rsid = matches[0]
+                    # GH #128: stash the pre-resolution pseudo-rsID
+                    # for audit / debug before stamping. Debug-only —
+                    # see Variant.original_rsid docstring; the
+                    # serialization-guard test asserts this never
+                    # reaches public output.
+                    v.original_rsid = v.rsid
                     v.rsid = rsid
                     resolved[(v.chromosome, v.position, ref, alt)] = rsid
         return resolved
@@ -636,6 +741,12 @@ class ClinVarAnnotator(Annotator):
                 continue
             user_is_multibase = len(variant.allele1) > 1 or len(variant.allele2) > 1
             user_diploid = _user_diploid(variant)
+            # GH #109: collect per-variant Annotations and dedup before
+            # yielding, mirroring the annotate() collapse. Without this,
+            # bulk callers (the analyze pipeline goes through
+            # batch_annotate) leak the same per-SCV duplicates the
+            # single-variant path used to.
+            variant_annotations: list[Annotation] = []
             for row in rows:
                 (
                     _chrom,
@@ -665,21 +776,24 @@ class ClinVarAnnotator(Annotator):
                     f"{clnsig.replace('_', ' ') if clnsig else 'unknown significance'}"
                 )
                 references = [f"clinvar:allele/{allele_id}"] if allele_id else []
-                yield Annotation(
-                    source=self.name,
-                    rsid=variant.rsid,
-                    significance=f"clinvar_{sig_label}",
-                    category="clinical",
-                    magnitude=_magnitude(clnsig),
-                    description=description,
-                    attribution=self.attribution,
-                    genotype_match=user_diploid,
-                    references=references,
-                    condition="" if not condition or condition == "." else condition,
-                    gene=gene or "",
-                    review_status=review_status or "",
-                    alt=alt,
+                variant_annotations.append(
+                    Annotation(
+                        source=self.name,
+                        rsid=variant.rsid,
+                        significance=f"clinvar_{sig_label}",
+                        category="clinical",
+                        magnitude=_magnitude(clnsig),
+                        description=description,
+                        attribution=self.attribution,
+                        genotype_match=user_diploid,
+                        references=references,
+                        condition="" if not condition or condition == "." else condition,
+                        gene=gene or "",
+                        review_status=review_status or "",
+                        alt=alt,
+                    )
                 )
+            yield from _collapse_identical_scvs(variant_annotations)
 
 
 def _user_diploid(variant: Variant) -> str:

{allelix-2.2.0 → allelix-2.2.2}/allelix/annotators/gnomad.py

@@ -76,6 +76,24 @@ class GnomadAnnotator(Annotator):
                     f"gnomAD cache not found at {self._db_path}. Run `allelix db update` first."
                 )
             self._conn = sqlite3.connect(self._db_path)
+            # GH #134: lazy-create the position index on caches built before
+            # the index landed (anything <= v2.2.1). The index is required
+            # for ``bulk_resolve_rsids_from_positions`` (GH #128) to perform
+            # well — without it that method scans the full 57M-row
+            # ``gnomad_frequencies`` table per query, which is the root
+            # cause of the ~2x analyze slowdown on rsID-less WGS VCFs
+            # observed at the v2.2.2 ship gate. ``CREATE INDEX IF NOT
+            # EXISTS`` is a no-op once the index is in place (microseconds
+            # to check the schema); the one-time build cost on first run
+            # against a pre-v2.2.2 cache is a few minutes against the 57M
+            # rows but only happens once per cache. Doing this here in
+            # ``_connection`` rather than as a schema migration avoids
+            # forcing every user to re-download the 2.7 GB compressed
+            # cache for what's a transparent index addition.
+            self._conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_gnomad_position ON gnomad_frequencies(chrom, pos)"
+            )
+            self._conn.commit()
         return self._conn
 
     def setup(self) -> None:
@@ -198,6 +216,84 @@ class GnomadAnnotator(Annotator):
                 result.setdefault(rsid, []).append((chrom, pos, ref, alt))
         return result
 
+    def bulk_resolve_rsids_from_positions(
+        self, positions: set[tuple[str, int]]
+    ) -> dict[tuple[str, int], list[tuple[str, str, str]]]:
+        """Reverse-lookup rsIDs by ``(chromosome, position)``.
+
+        Counterpart to :meth:`bulk_resolve_coordinates` for the GH #128
+        flow: a VCF variant arriving with an empty ID column (DeepVariant
+        gVCFs, GIAB GRCh38 benchmarks, anything that doesn't stamp dbSNP
+        IDs) is parsed as a positional pseudo-ID. The ClinVar resolver
+        (:meth:`allelix.annotators.clinvar.ClinVarAnnotator.bulk_resolve_rsids`)
+        recovers an rsID only for variants in ClinVar's curated subset —
+        which excludes most pharmacogenomic, GWAS-only, and SNPedia-only
+        rsIDs commonly found in wellness panels. This method fills the
+        gap by querying ``gnomad_frequencies`` (keyed on the full dbSNP
+        rsID universe with published allele frequencies).
+
+        Returns ``{(chrom, pos): [(ref, alt, rsid), ...]}``. Multi-allelic
+        positions return multiple rows; the caller is responsible for
+        applying carrier-rule disambiguation (matching the user's allele
+        pair as a subset of ``{ref, alt}`` and abstaining on ties — same
+        pattern as the ClinVar resolver).
+
+        Bare chromosomes are expected on both the input set and the
+        ``gnomad_frequencies.chrom`` column — Allelix normalizes all
+        internal chromosome identifiers to bare form
+        (:func:`allelix.parsers._helpers.normalize_chromosome`).
+        """
+        if not positions:
+            return {}
+        conn = self._connection()
+        result: dict[tuple[str, int], list[tuple[str, str, str]]] = {}
+        # GH #134: issue a single combined SQL statement per chunk
+        # using SQLite's row-value ``(chrom, pos) IN ((?, ?), ...)``
+        # form instead of grouping by chromosome and issuing one
+        # statement per (chrom, chunk) pair. On WGS input each batch
+        # touches all ~24 chromosomes; the per-chrom shape was a 24x
+        # query multiplier the new ``idx_gnomad_position`` index could
+        # not amortize away. The row-value IN form keeps the same
+        # carrier-rule contract — both ``chrom`` and ``pos`` must
+        # match the input pair simultaneously — and the
+        # ``idx_gnomad_position`` covering index on (chrom, pos)
+        # serves the lookup directly. ``_BULK_BATCH_SIZE`` here
+        # refers to (chrom, pos) PAIRS not single ints, so each
+        # chunk binds 2 * batch_size parameters.
+        #
+        # SQLite parameter-limit awareness: 2 * _BULK_BATCH_SIZE =
+        # 1800 bind parameters per chunk. The historical SQLite
+        # ``SQLITE_MAX_VARIABLE_NUMBER`` default was 999, raised to
+        # 32766 in SQLite 3.32 (2020-05-22). Every Python version
+        # Allelix supports (>= 3.11) ships with SQLite >= 3.34, so
+        # the 1800-param chunk is well within the modern limit. If a
+        # future change bumps ``_BULK_BATCH_SIZE`` toward 16000 or
+        # the project drops Python's bundled SQLite for a system
+        # ``libsqlite3`` of unknown vintage, re-check this against
+        # the runtime ``sqlite3.sqlite_version`` before assuming
+        # capacity.
+        position_list = list(positions)
+        for i in range(0, len(position_list), _BULK_BATCH_SIZE):
+            batch = position_list[i : i + _BULK_BATCH_SIZE]
+            placeholders = ",".join("(?, ?)" for _ in batch)
+            params: list[str | int] = []
+            for chrom, pos in batch:
+                params.append(chrom)
+                params.append(pos)
+            rows = conn.execute(
+                f"SELECT chrom, pos, ref, alt, rsid FROM gnomad_frequencies"
+                f" WHERE (chrom, pos) IN ({placeholders})",
+                params,
+            ).fetchall()
+            for c, p, ref, alt, rsid in rows:
+                if not rsid:
+                    continue
+                result.setdefault((c, p), []).append((ref, alt, rsid))
+        # Deterministic ordering for the carrier-rule pass.
+        for rows in result.values():
+            rows.sort()
+        return result
+
     def bulk_lookup_by_alt(self, keys: set[tuple[str, str]]) -> dict[tuple[str, str], float]:
         """Return ``{(rsid, alt): af}`` for exact allele matches."""
         if not keys:

{allelix-2.2.0 → allelix-2.2.2}/allelix/cli/db.py

@@ -221,16 +221,27 @@ _CADD_PREFIXES: tuple[str, ...] = ("cadd",)
 # pre-deletion guard. Matched by prefix so future variants (e.g. multi-
 # build forms like clinvar.GRCh37.sqlite, sidecar files like
 # snpedia.sqlite-bak, the PharmGKB raw zip `clinicalAnnotations.zip`) are
-# all caught. `config.toml` is included as a presence-only marker — it
-# never appears in the deletion entries (it's preserved), but its
-# presence is the strongest signal "yes, this is an allelix data dir."
+# all caught.
+#
+# GH #112 (v2.2.1): `config.toml` is intentionally NOT a marker here.
+# It used to be — on the reasoning that any allelix data dir likely
+# carries one — but `config.toml` is a generic filename (Rust projects,
+# Hugo, Rocket, etc. all use it). A typo'd `--data-dir ~/my-rust-project`
+# slipped past the guard simply because that project's root has a
+# `Cargo.lock` and a `config.toml`. The marker set must be allelix-
+# specific.
+#
+# The fresh-install case — a dir with only config.toml and no cache
+# files — is unaffected: `_iter_cache_entries` excludes config.toml,
+# so `entries` is empty and the `if not entries: ... return` short-
+# circuit in `db_clean` reports "Nothing to clean" before the guard
+# ever runs.
 _KNOWN_ARTIFACT_PREFIXES: frozenset[str] = frozenset(
     {
         "alphamissense",
         "cadd",
         "clinicalAnnotations",
         "clinvar",
-        "config.toml",
         "gnomad",
         "gwas",
         "pharmgkb",

{allelix-2.2.0 → allelix-2.2.2}/allelix/cli/utility.py

@@ -20,6 +20,7 @@ from allelix.cli._options import (
     _SAMPLE_OPT,
 )
 from allelix.databases import resolve_data_dir
+from allelix.models import NO_CALL_MARKER
 
 if TYPE_CHECKING:
     from allelix.models import Variant
@@ -67,7 +68,21 @@ def stats(file_path: Path, fmt: str | None, sample: str | None) -> None:
     summary.add_column("Value", style="green")
     summary.add_row("Format", parser.display_name)
     summary.add_row("Sample ID", metadata["sample_id"] or "(unknown)")
-    summary.add_row("Build", metadata["build"])
+    # ``metadata["build"]`` is blank on every VCF that doesn't declare
+    # ``##reference=`` in the header — i.e. most caller outputs
+    # (DeepVariant / DRAGEN / GIAB GRCh38 benchmark). A blank cell read
+    # as broken on the v2.2.1 battery; ``stats`` deliberately does not
+    # run build detection (that's an ``analyze`` job per the protocol),
+    # so the honest display when no header build is declared is an em
+    # dash plus the chr-prefix hint when available. The user can run
+    # ``analyze`` to get the real detected build.
+    if metadata["build"]:
+        build_display = metadata["build"]
+    elif metadata.get("chr_prefix_observed"):
+        build_display = "— (chr-prefixed contigs; run `analyze` to confirm)"
+    else:
+        build_display = "—"
+    summary.add_row("Build", build_display)
     summary.add_row("Total SNPs", f"{total:,}")
     summary.add_row("No-calls", f"{no_calls:,} ({_helpers._percent(no_calls, total)})")
     summary.add_row("Heterozygous", f"{het:,} ({_helpers._percent(het, total)})")
@@ -136,28 +151,90 @@ def extract(
     found = _try_tabix_extract(file_path, wanted, sample, data_dir)
     if found is None:
         # Sequential fallback — works for any parser.
-        found = _sequential_extract(parser, file_path, wanted)
+        found = _sequential_extract(parser, file_path, wanted, data_dir)
         _maybe_print_vcf_index_hint(file_path)
 
     _render_extract_table(file_path, wanted, found)
 
 
 def _sequential_extract(
-    parser: GenotypeParser, file_path: Path, wanted: set[str]
+    parser: GenotypeParser,
+    file_path: Path,
+    wanted: set[str],
+    data_dir: Path | None = None,
 ) -> dict[str, Variant]:
     """Stream the file once; collect Variants whose rsID is in ``wanted``.
 
     Streaming early-exit once all wanted rsIDs are found — for arrays
     that yield <1 M variants this is fast enough on any input.
+
+    GH #128: for VCF inputs the parser may emit a positional pseudo-ID
+    (``chr1:11856378:G:A``) when the row's ID column is empty — every
+    modern caller (DeepVariant, DRAGEN, GIAB GRCh38 benchmark) emits
+    these. The rsID-only fast path on the iterator misses them. To
+    cover the rsID-less VCF case, the function pre-resolves the wanted
+    set's coordinates via gnomAD (when ready) and matches variants by
+    ``(chrom, pos, ref, alt)`` whenever the rsID match misses. The
+    ``ref + alt-in-alleles`` rule matches the tabix path's correctness
+    contract and the resolver's carrier-rule disambiguation.
     """
+    from allelix.annotators.gnomad import GnomadAnnotator
+
     counter, stderr_handler, snapshot = _helpers._wire_parser_logging()
     found: dict[str, Variant] = {}
+    # Pre-resolve wanted → (chrom, pos, ref, alt) → rsid via gnomAD so
+    # the iterator can cover rsID-less VCFs by coord-matching. ``data_dir``
+    # is optional only because tests construct mock parsers without a
+    # configured cache; production CLI invocations always reach
+    # ``resolve_data_dir`` (which defaults to the standard cache
+    # location when the user didn't pass ``--data-dir``). The if-test
+    # below gates only on gnomAD readiness, not on whether the user
+    # explicitly opted in.
+    coord_to_rsid: dict[tuple[str, int, str, str], str] = {}
+    try:
+        resolved_data_dir = resolve_data_dir(data_dir)
+    except (OSError, ValueError):
+        resolved_data_dir = None
+    if resolved_data_dir is not None:
+        gnomad = GnomadAnnotator(resolved_data_dir)
+        try:
+            if gnomad.is_ready():
+                coord_map = gnomad.bulk_resolve_coordinates(wanted)
+                for rsid, entries in coord_map.items():
+                    for chrom, pos, ref, alt in entries:
+                        coord_to_rsid[(chrom, pos, ref, alt)] = rsid
+        finally:
+            gnomad.close()
     try:
         for variant in parser.parse(file_path):
             if variant.rsid in wanted:
                 found[variant.rsid] = variant
                 if len(found) == len(wanted):
                     break
+                continue
+            # rsID fast path missed — try coord match for the rsID-less
+            # VCF case. Requires ref populated; non-VCF parsers (arrays)
+            # don't carry ref but always stamp rsIDs in the file, so
+            # they never reach this branch.
+            if not coord_to_rsid or variant.ref is None:
+                continue
+            matched_rsid: str | None = None
+            for alt in (variant.allele1, variant.allele2):
+                if alt in (NO_CALL_MARKER, variant.ref):
+                    continue
+                key = (variant.chromosome, variant.position, variant.ref, alt)
+                candidate = coord_to_rsid.get(key)
+                if candidate is None or candidate in found or candidate not in wanted:
+                    continue
+                matched_rsid = candidate
+                break
+            if matched_rsid is None:
+                continue
+            variant.original_rsid = variant.rsid
+            variant.rsid = matched_rsid
+            found[matched_rsid] = variant
+            if len(found) == len(wanted):
+                break
     finally:
         _helpers._unwire_parser_logging(counter, stderr_handler, snapshot)
     return found
@@ -247,7 +324,7 @@ def _execute_tabix_extract(  # pragma: no cover
         for rsid, coords in coord_map.items():
             if rsid in found or not coords:
                 continue
-            for chrom, pos, _ref, _alt in coords:
+            for chrom, pos, ref, alt in coords:
                 # gnomAD chromosomes are bare ('1', 'X'); the VCF might
                 # use 'chr1'. Try both.
                 for chrom_candidate in (chrom, f"chr{chrom}"):
@@ -259,9 +336,31 @@ def _execute_tabix_extract(  # pragma: no cover
                         variant = _parse_data_line(row, sample_idx)
                         if variant is None:
                             continue
-                        if variant.rsid == rsid:
+                        # GH #128: match the tabix-fetched row to the
+                        # gnomAD record by (ref, alt) rather than by
+                        # rsID equality. On rsID-stamped VCFs (e.g. GIAB
+                        # GRCh37, 23andMe) the parser populates
+                        # ``variant.rsid`` with the file's ID column and
+                        # the prior equality check happened to work; on
+                        # rsID-less VCFs (DeepVariant gVCFs, GIAB GRCh38
+                        # benchmark, Sequencing.com DRAGEN output)
+                        # ``variant.rsid`` is a positional pseudo-ID and
+                        # the equality check silently discarded every
+                        # tabix-fetched row. Ref+alt match is correct on
+                        # both — that's what the gnomAD coord was
+                        # resolved against.
+                        if variant.ref == ref and alt in (
+                            variant.allele1,
+                            variant.allele2,
+                        ):
                             # _parse_data_line already normalizes chromosome;
-                            # no re-normalization needed.
+                            # no re-normalization needed. Stash + stamp
+                            # so the displayed table shows the requested
+                            # rsID rather than the pseudo-ID, with audit
+                            # preserved per Variant.original_rsid.
+                            if variant.rsid != rsid:
+                                variant.original_rsid = variant.rsid
+                                variant.rsid = rsid
                             found[rsid] = variant
                             break
                     if rsid in found:

{allelix-2.2.0 → allelix-2.2.2}/allelix/databases/manager.py

@@ -187,8 +187,10 @@ _SS_CONTRIBUTES = 15  # "ContributesToAggregateClassification"
 
 # GH #42 follow-up (evaluator defect 5, PR #101): exact set of
 # ClinicalSignificance values the TSV loader filters at ingest.
-# These are placeholders that ClinVar uses to mark SCVs with no
-# recorded classification AND that aren't in
+# These are values that ClinVar uses to mark SCVs with no actionable
+# classification — placeholders ("-", "", "not specified") AND
+# non-classification curatorial categories ("other", "association",
+# "association not found") — AND that aren't in
 # `allelix.annotators.clinvar._CLNSIG_MAGNITUDE` (so without this
 # filter they'd land at the 5.0 default — equal to the analyze
 # display floor — and surface to users as bogus annotations).
@@ -199,6 +201,13 @@ _SS_CONTRIBUTES = 15  # "ContributesToAggregateClassification"
 #     would lose real submitter records.
 #   - "no classification for the single variant" — same.
 #
+# GH #116 added the three non-classification terms ("other",
+# "association", "association not found"). The per-SCV TSV
+# switch (#42) surfaced these from the underlying submission_summary
+# rows where the old summarized data hid them; they're meaningfully
+# distinct from placeholders (a curator chose them) but equally
+# unactionable as report content.
+#
 # The protocol's §7b significance-sentinel ship-gate scans the
 # same set to verify the loader's commitment against the live cache.
 # Keep both in sync.
@@ -208,6 +217,13 @@ _CLINVAR_PLACEHOLDER_CLNSIGS: frozenset[str] = frozenset(
         "-",
         "not specified",
         "no classification provided",
+        # GH #116: non-classification curatorial terms — kept out of
+        # _CLNSIG_MAGNITUDE deliberately (they aren't classifications)
+        # and out of _BENIGN_CLNSIGS (they aren't benign; #56's repute
+        # work must not see them as "good").
+        "other",
+        "association",
+        "association not found",
     }
 )
 

{allelix-2.2.0 → allelix-2.2.2}/allelix/databases/schema.py

@@ -127,6 +127,8 @@ CREATE TABLE IF NOT EXISTS gnomad_frequencies (
 );
 
 CREATE INDEX IF NOT EXISTS idx_gnomad_rsid ON gnomad_frequencies(rsid);
+CREATE INDEX IF NOT EXISTS idx_gnomad_position
+    ON gnomad_frequencies(chrom, pos);
 """
     + _DATABASE_VERSIONS_TABLE
 )

{allelix-2.2.0 → allelix-2.2.2}/allelix/models.py

@@ -47,6 +47,27 @@ class Variant:
     allele2: str
     build: str = DEFAULT_BUILD
     ref: str | None = None
+    # GH #128: pre-resolution rsID stashed when a resolver
+    # (`ClinVarAnnotator.bulk_resolve_rsids` or
+    # `GnomadAnnotator.bulk_resolve_rsids_from_positions`, both invoked
+    # in ``_pipeline._flush()``) recovers the real ``rs...`` ID for a
+    # variant that arrived without one — e.g. a DeepVariant gVCF row
+    # whose ID column is ``.``, parsed as a positional pseudo-ID like
+    # ``chr1:11856378:G:A``. The stamp rewrites ``rsid`` to the
+    # recovered value so every downstream call site that compares
+    # ``v.rsid`` against a requested set (panel coverage, high-value
+    # match, extract, PLINK ref/alt, GWAS must-include) works
+    # transparently; ``original_rsid`` holds the pre-stamp value
+    # purely for audit / debug.
+    #
+    # **DEBUG-ONLY — do not branch production logic on this field.**
+    # Reading ``original_rsid`` outside of logging, debugging, or
+    # ``__repr__``-style introspection couples production behavior to
+    # provenance metadata and turns this into an unintended API
+    # surface. The serialization-guard test in
+    # ``tests/test_original_rsid_never_serializes.py`` asserts this
+    # field never reaches JSON / HTML / ``--diff`` output.
+    original_rsid: str | None = None
 
     def __post_init__(self) -> None:
         """Normalize allele case at construction (GH #14, ADR-0035).