allelix 2.2.0__tar.gz → 2.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: allelix
-Version: 2.2.0
+Version: 2.2.1
 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.1}/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.
@@ -636,6 +735,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 +770,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.1}/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.1}/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.1}/allelix/parsers/ftdna_famfinder.py

@@ -25,9 +25,26 @@ Specifics:
       (case-insensitive); 5 columns vs FTDNA Illumina raw's 4.
     - Separate single-character allele columns (vs. concatenated
       RESULT in the Illumina raw variant).
-    - Haploid calls on MT/Y use the single-character pattern
-      ``A``/``-`` in ALLELE1 with empty / missing ALLELE2.
-    - No-calls: ``-`` in one or both allele columns.
+    - Haploid calls on MT/Y use the single-character pattern: the
+      called base in ALLELE1 with EITHER the ALLELE2 column entirely
+      absent (4-column line) OR an empty ALLELE2 cell (5-column
+      line with trailing tab). Both shapes have been observed in
+      real exports. The parser normalizes haploid input to a
+      hemizygous-looking Variant where ``allele1 == allele2 ==
+      <the called base>`` (consistent with the haploid convention
+      in ``_helpers.split_genotype``). GH #113.
+
+      Chromosome-aware: the haploid shape (4-column line OR
+      5-column line with empty ALLELE2) is accepted ONLY when the
+      chromosome is MT or Y. FTDNA does not publish haploid calls
+      on any other chromosome, so the same shape on an autosome or
+      X is almost certainly a truncated diploid that lost an
+      allele in transit — promoting it to hemizygous would silently
+      double the surviving allele and synthesize a wrong-zygosity
+      genotype. The parser warns-and-skips that case instead.
+      Tightened against the v2.2.1 cross-PR review on PR #117.
+    - No-calls: ``-`` in one or both allele columns (with both
+      columns present and ALLELE1 != empty).
     - Build 37 (GRCh37) on every export observed.
     - Detection key: ``famfinder`` substring (case-insensitive) in
       the first ``SNIFF_LINE_LIMIT`` lines AND the canonical 5-column
@@ -136,11 +153,18 @@ class FTDNAFamFinderParser(GenotypeParser):
                     continue
 
                 parts = line.split("\t")
-                if len(parts) != EXPECTED_COLUMNS:
+                # GH #113: accept the 4-column haploid shape (missing
+                # ALLELE2 column for hemizygous MT/Y calls) in addition
+                # to the canonical 5-column diploid shape. The docstring
+                # already claimed haploid support; the impl didn't.
+                # Anything other than 4 or 5 columns is genuinely
+                # malformed.
+                if len(parts) not in (EXPECTED_COLUMNS - 1, EXPECTED_COLUMNS):
                     logger.warning(
-                        "Line %d: expected %d columns, got %d — skipping",
+                        "Line %d: expected %d columns (or %d for haploid), got %d — skipping",
                         lineno,
                         EXPECTED_COLUMNS,
+                        EXPECTED_COLUMNS - 1,
                         len(parts),
                     )
                     continue
@@ -149,7 +173,55 @@ class FTDNAFamFinderParser(GenotypeParser):
                 chrom = parts[1].strip()
                 pos_str = parts[2].strip()
                 allele1 = _normalize_allele(parts[3])
-                allele2 = _normalize_allele(parts[4])
+                # Normalize early — the chromosome-aware haploid guard
+                # below compares against the canonical form {"MT", "Y"}.
+                normalized_chrom = normalize_chromosome(chrom)
+                # Haploid: either the 4-column shape (no ALLELE2 column)
+                # OR the 5-column shape with an empty ALLELE2 cell. Both
+                # are real in FTDNA's MT/Y output. A genuine hemizygous
+                # call is represented as allele1 == allele2 (the
+                # convention shared by 23andMe / _helpers.split_genotype),
+                # NOT allele2 = NO_CALL_MARKER (which would render as a
+                # half no-call and surface the GH #113 reporter's
+                # "lab-spec MT/Y vanishes" behavior).
+                #
+                # GH #113 cross-PR review (#117 review): only accept the
+                # haploid shape on MT and Y — the only chromosomes FTDNA
+                # publishes haploid calls on. A 4-column line (or
+                # 5-column-empty-ALLELE2) on an autosome or X is almost
+                # certainly a truncated diploid that lost an allele in
+                # transit; promoting it to hemizygous would silently
+                # double the surviving allele. Warn-skip instead. This
+                # closes the trade-off the v2.3 follow-up was opened
+                # for; no real MT/Y haploid call is lost (the canonical
+                # shape on those chromosomes is unchanged).
+                if len(parts) == EXPECTED_COLUMNS - 1:
+                    if normalized_chrom not in {"MT", "Y"}:
+                        logger.warning(
+                            "Line %d: %d-column haploid line on non-haploid "
+                            "chromosome %r — almost certainly a truncated "
+                            "diploid; skipping",
+                            lineno,
+                            len(parts),
+                            chrom,
+                        )
+                        continue
+                    allele2 = allele1
+                else:
+                    raw_allele2 = parts[4].strip()
+                    if raw_allele2 == "":
+                        if normalized_chrom not in {"MT", "Y"}:
+                            logger.warning(
+                                "Line %d: empty ALLELE2 on non-haploid "
+                                "chromosome %r — almost certainly a "
+                                "truncated diploid; skipping",
+                                lineno,
+                                chrom,
+                            )
+                            continue
+                        allele2 = allele1
+                    else:
+                        allele2 = _normalize_allele(parts[4])
 
                 try:
                     position = int(pos_str)
@@ -159,7 +231,7 @@ class FTDNAFamFinderParser(GenotypeParser):
 
                 yield Variant(
                     rsid=rsid,
-                    chromosome=normalize_chromosome(chrom),
+                    chromosome=normalized_chrom,
                     position=position,
                     allele1=allele1,
                     allele2=allele2,

{allelix-2.2.0 → allelix-2.2.1}/allelix/parsers/vcf.py

@@ -133,7 +133,17 @@ class VcfParser(GenotypeParser):
     # ── Public API ──────────────────────────────────────────────
 
     def can_parse(self, file_path: Path) -> bool:
-        """True if the first non-blank line is ``##fileformat=VCF...``."""
+        """True if the first non-blank line is ``##fileformat=VCF...``.
+
+        GH #121: catches ``UnicodeDecodeError`` and ``EOFError`` (corrupt
+        gzip / truncated BGZF) on top of ``OSError`` so format sniffing
+        never raises through into ``detect_parser``. A real-world
+        ``.vcf.gz`` shouldn't reach the decode path's replacement
+        substitution (``_open_vcf`` uses ``errors="replace"``), but
+        binary garbage or a truncated tabix index masquerading as a
+        ``.vcf.gz`` would otherwise still leak a traceback at the
+        ``read`` boundary in ``gzip.open``.
+        """
         try:
             with _open_vcf(file_path) as handle:
                 for line in handle:
@@ -141,7 +151,7 @@ class VcfParser(GenotypeParser):
                     if not stripped:
                         continue
                     return stripped.startswith("##fileformat=VCF")
-        except OSError:
+        except (OSError, UnicodeDecodeError, EOFError):
             return False
         return False
 
@@ -548,6 +558,18 @@ def _open_vcf(file_path: Path) -> TextIO:
     gzipped content still parse). The caller is responsible for closing
     the returned handle (it's a context manager).
 
+    GH #121: ``errors="replace"`` on the text decode. Real-world VCFs
+    routinely carry non-UTF-8 bytes in tool headers — a ``©`` (latin-1
+    ``0xa9``) in a ``##CL=`` line is extremely common (GATK / DeepVariant
+    / bcftools all do it). A strict decode would raise ``UnicodeDecodeError``
+    mid-iteration, leaking a Python traceback through ``can_parse`` and
+    ``parse``. Replacement renders the bad byte as U+FFFD inside the
+    header block — VCF data lines are pure ASCII tab-separated values
+    and never reach the substitution path, so genotype fidelity is
+    preserved. ``can_parse`` also catches ``UnicodeDecodeError`` as a
+    belt-and-braces guard for the case where ``errors="replace"`` is
+    ever lifted.
+
     Returns ``typing.TextIO`` rather than the concrete ``io.TextIOBase``
     so mypy-strict callers see the ``__enter__`` / ``__exit__`` protocol
     on the returned handle.
@@ -555,5 +577,5 @@ def _open_vcf(file_path: Path) -> TextIO:
     with open(file_path, "rb") as raw:
         magic = raw.read(2)
     if magic == b"\x1f\x8b":
-        return gzip.open(file_path, "rt", encoding="utf-8")
-    return open(file_path, encoding="utf-8")
+        return gzip.open(file_path, "rt", encoding="utf-8", errors="replace")
+    return open(file_path, encoding="utf-8", errors="replace")

{allelix-2.2.0 → allelix-2.2.1}/allelix/reports/_pipeline.py

@@ -138,6 +138,14 @@ class AnalysisResult:
     panel_rsids: frozenset[str] | None = None
     genotyped_panel_rsids: frozenset[str] | None = None
     panel_annotated_rsids: frozenset[str] | None = None
+    # GH #120: per-rsID genotype string (e.g. "C/T", "A/-", "-/-")
+    # for each panel rsID present in the input file. Populated only
+    # when --filter-file supplied a panel. None on default analyze
+    # runs (zero behavior change on the default path). The HTML
+    # Panel coverage section renders this in a GT column; JSON shape
+    # stays v6 untouched — display-only addition. The genotype-aware
+    # MECE redesign that lands this in JSON + terminal is #115 (v2.3).
+    panel_genotypes: dict[str, str] | None = None
     # GH #90: variants reaching the annotator phase with ref=None.
     # Used by the CLI to surface the strand-aware-matching-inactive
     # info line once per run for array inputs.
@@ -148,7 +156,9 @@ class AnalysisResult:
     # warning until #62's dbSNP resolution lands.
     rsidless_variant_count: int = 0
 
-    def panel_coverage(self) -> PanelCoverage | None:
+    def panel_coverage(
+        self, filtered_annotations: list[Annotation] | None = None
+    ) -> PanelCoverage | None:
         """Return panel-coverage info when a rsid panel was supplied.
 
         States, per GH #75:
@@ -175,15 +185,56 @@ class AnalysisResult:
         chip presence, not call success. High-value no-calls are
         separately surfaced by the ``hv_warnings`` path in the CLI;
         readers should not interpret ``found`` as "called."
+
+        GH #106 (v2.2.1 patch): when ``filtered_annotations`` is
+        supplied — the post-magnitude-filter list each renderer
+        already produces for the main annotation table — the
+        "annotated" set is derived from THAT list, not from
+        ``panel_annotated_rsids`` (which is populated from the
+        unfiltered annotation set in ``run_analysis``). Without
+        this, panel rsIDs whose only annotations score below the
+        analyze display floor land in ``found`` but render nowhere
+        — they're counted as "found" then filtered out of the
+        annotation table, then NOT folded into ``no_findings``
+        (because the pipeline thinks they had annotations). Pure
+        limbo, a flat lie in ``found``. Passing the filtered list
+        in makes "annotated" equal "actually rendered" and the
+        below-floor variants drop into ``no_findings`` honestly.
+
+        The redesign (genotype-aware MECE 4-state with `no_call`
+        distinct from `typed_no_annotation`, schema 6→7) lands in
+        v2.3 (#115).
         """
         if self.panel_rsids is None:
             return None
         genotyped = self.genotyped_panel_rsids or frozenset()
-        annotated = self.panel_annotated_rsids or frozenset()
-        missing = sorted(self.panel_rsids - genotyped)
+        panel_rsids = self.panel_rsids
+        if filtered_annotations is not None:
+            # GH #106 patch: "annotated" is the set of panel rsIDs that
+            # actually got rendered — derived from the post-filter
+            # annotation list the renderer passes in. Sub-floor-only
+            # panel rsids drop out of `annotated`, so they fall into
+            # `no_findings` instead of limbo. The `found` field still
+            # means "in input file" (genotyped count) — same v6
+            # contract — only `no_findings` widens to be honest.
+            annotated: frozenset[str] = frozenset(
+                a.rsid for a in filtered_annotations if a.rsid in panel_rsids
+            )
+        else:
+            # Back-compat path for callers that don't thread the
+            # filtered list. `annotated` stays the raw pre-filter set,
+            # reproducing the v6.0 behavior (sub-floor panel rsids
+            # land in `found` and vanish from every rendered surface —
+            # the limbo bug the #106 patch retires when the filtered
+            # list IS supplied).
+            annotated = self.panel_annotated_rsids or frozenset()
+        missing = sorted(panel_rsids - genotyped)
+        # Below-floor panel rsids land here on the filtered path: in
+        # genotyped but not in the post-filter annotated set. They had
+        # annotations in the cache but none survived the display floor.
         no_findings = sorted(genotyped - annotated)
         return {
-            "requested": len(self.panel_rsids),
+            "requested": len(panel_rsids),
             "found": len(genotyped),
             "missing": missing,
             "no_findings": no_findings,
@@ -442,6 +493,11 @@ def run_analysis(
     # so a 600k-variant input contributes ~panel-size memory, not
     # 600k rsids.
     genotyped_panel: set[str] = set()
+    # GH #120: per-rsID genotype for panel members. First-occurrence
+    # wins (a 23andMe-style chip emits one row per rsID anyway; multi-
+    # row input formats keep the earliest reading). HTML-only surface
+    # in v2.2.1; #115 carries the JSON + terminal addition in v2.3.
+    panel_genotypes_map: dict[str, str] = {}
     # GH #90 / #91: per-run diagnostic totals for ref-None and
     # rsidless variants reaching the annotator phase. Used by the CLI
     # to emit the "strand-aware inactive" info line (#90) and the
@@ -513,7 +569,14 @@ def run_analysis(
             if hv_set:
                 hv_variants.extend(v for v in batch_buf if v.rsid in hv_set)
             if panel_rsids:
-                genotyped_panel.update(v.rsid for v in batch_buf if v.rsid in panel_rsids)
+                for v in batch_buf:
+                    if v.rsid in panel_rsids:
+                        genotyped_panel.add(v.rsid)
+                        # First-occurrence wins; renders as "A/G",
+                        # "C/C", "A/-", "-/-" honestly — uses the
+                        # same Variant.genotype property the rest of
+                        # the codebase uses.
+                        panel_genotypes_map.setdefault(v.rsid, v.genotype)
             # GH #90 / #91: per-batch diagnostic counters. Tallied AFTER
             # the ref-population and resolver passes so the counts
             # reflect the final state annotators see — not the raw input.
@@ -629,10 +692,12 @@ def run_analysis(
         result_panel = frozenset(panel_rsids)
         result_genotyped = frozenset(genotyped_panel)
         result_annotated = frozenset(a.rsid for a in annotations if a.rsid in panel_rsids)
+        result_genotypes: dict[str, str] | None = dict(panel_genotypes_map)
     else:
         result_panel = None
         result_genotyped = None
         result_annotated = None
+        result_genotypes = None
 
     return AnalysisResult(
         file_path=file_path,
@@ -649,6 +714,7 @@ def run_analysis(
         panel_rsids=result_panel,
         genotyped_panel_rsids=result_genotyped,
         panel_annotated_rsids=result_annotated,
+        panel_genotypes=result_genotypes,
         no_ref_variant_count=no_ref_total,
         rsidless_variant_count=rsidless_total,
     )

{allelix-2.2.0 → allelix-2.2.1}/allelix/reports/html.py

@@ -486,14 +486,26 @@ def _hv_nocall_banner(warnings: list[str] | None) -> str:
     )
 
 
-def _panel_coverage_section(coverage: PanelCoverage | None) -> str:
-    """GH #75: render the Panel Coverage section.
+def _panel_coverage_section(
+    coverage: PanelCoverage | None,
+    panel_genotypes: dict[str, str] | None = None,
+) -> str:
+    """GH #75 / #120: render the Panel Coverage section.
 
     Quiet when no panel was supplied. Otherwise show the requested/found
     counts plus a table of rsIDs that weren't on the user's chip (state
     3) and rsIDs that were on the chip but produced no findings (state
     2). State 1 hits render in the main annotation table as before, so
     this section is purely a "what's NOT in the table" summary.
+
+    GH #120: when ``panel_genotypes`` is supplied (the rsid → "A/G"
+    map collected during run_analysis), a GT column is added between
+    rsID and Note. Genotyped rsIDs (state 2 + no-call) render their
+    literal call — including "-/-" for full no-calls and "A/-" for
+    half no-calls so the dash is visually obvious even though the v6
+    accounting still folds no-calls into ``no_findings`` (the
+    dedicated ``no_call`` MECE state is #115's job in v2.3). Rows
+    that aren't on the chip (state 3) show "—" (em dash).
     """
     if coverage is None:
         return ""
@@ -501,23 +513,38 @@ def _panel_coverage_section(coverage: PanelCoverage | None) -> str:
     found = int(coverage["found"])
     missing = list(coverage["missing"])
     no_findings = list(coverage["no_findings"])
+    show_gt = panel_genotypes is not None
+
+    def _gt(rsid: str, in_input: bool) -> str:
+        """Render the GT column cell (GH #120).
+
+        State-3 rows (not_on_chip) show em dash; state-2 rows show
+        the literal Variant.genotype (e.g. "A/G", "-/-", "A/-").
+        """
+        if not in_input:
+            return "<td>—</td>"
+        gt = (panel_genotypes or {}).get(rsid, "—")
+        return f"<td><code>{_escape(gt)}</code></td>"
 
     rows = []
     for rsid in missing:
         rows.append(
             f"<tr><td><code>{_escape(rsid)}</code></td>"
+            f"{_gt(rsid, in_input=False) if show_gt else ''}"
             "<td>not genotyped on this chip/platform</td></tr>"
         )
     for rsid in no_findings:
         rows.append(
             f"<tr><td><code>{_escape(rsid)}</code></td>"
+            f"{_gt(rsid, in_input=True) if show_gt else ''}"
             "<td>genotyped, no annotations matched</td></tr>"
         )
     table = ""
     if rows:
+        gt_th = "<th>GT</th>" if show_gt else ""
         table = (
             "<table class='panel-coverage'><thead>"
-            "<tr><th>rsID</th><th>Note</th></tr></thead>"
+            f"<tr><th>rsID</th>{gt_th}<th>Note</th></tr></thead>"
             f"<tbody>{''.join(rows)}</tbody></table>"
         )
     return (
@@ -1187,7 +1214,7 @@ def render_html(
         f"{_escape(REGULATORY_NOTICE)}</div>"
         f"{build_warn}"
         f"{_hv_nocall_banner(high_value_no_calls)}"
-        f"{_panel_coverage_section(result.panel_coverage())}"
+        f"{_panel_coverage_section(result.panel_coverage(filtered), result.panel_genotypes)}"
         f"{_EDUCATION_SECTION}"
         f"{_MAGNITUDE_LEGEND}"
         f"{diff_banner}"

{allelix-2.2.0 → allelix-2.2.1}/allelix/reports/json_report.py

@@ -157,7 +157,11 @@ def render_json(
     # object distinguishes "not on chip" from "homozygous reference"
     # from "had a finding". `missing` is state 3, `no_findings` is
     # state 2, both lists are sorted for deterministic diffs.
-    panel_coverage = result.panel_coverage()
+    # GH #106 (v2.2.1 patch): thread the post-filter annotation list so
+    # `panel_coverage` derives "annotated" from what actually got
+    # rendered. Without this, sub-floor panel rsids vanished from every
+    # rendered surface while still being counted as "found".
+    panel_coverage = result.panel_coverage(filtered)
     if panel_coverage is not None:
         payload["panel_coverage"] = panel_coverage
 

{allelix-2.2.0 → allelix-2.2.1}/allelix/reports/terminal.py

@@ -60,7 +60,7 @@ def render_terminal(
     )
     filtered = rollup_gwas_duplicates(filtered)
     _print_table(filtered, console)
-    _print_panel_coverage_warning(result, console)
+    _print_panel_coverage_warning(result, console, filtered)
     _print_regulatory_notice(console)
     return len(filtered)
 
@@ -78,14 +78,24 @@ def _print_regulatory_notice(console: Console) -> None:
     console.print(f"\n[dim italic]{REGULATORY_NOTICE}[/dim italic]")
 
 
-def _print_panel_coverage_warning(result: AnalysisResult, console: Console) -> None:
+def _print_panel_coverage_warning(
+    result: AnalysisResult,
+    console: Console,
+    filtered_annotations: list[Annotation],
+) -> None:
     """GH #75: surface panel rsIDs that weren't in the user's input file.
 
     "Not on your chip" is critically different from "homozygous reference"
     — making this invisible was the original audit complaint. Quiet when
     no panel was supplied, or when every panel rsID was genotyped.
+
+    GH #106: the post-filter annotation list is threaded through so
+    `panel_coverage()` derives "annotated" from what was actually rendered,
+    not from the unfiltered set. Without this thread, panel rsids whose
+    only annotations were below the magnitude floor showed in "found" but
+    not in any rendered surface (the 9-of-20 limbo bug).
     """
-    coverage = result.panel_coverage()
+    coverage = result.panel_coverage(filtered_annotations)
     if coverage is None:
         return
     missing = coverage["missing"]

{allelix-2.2.0 → allelix-2.2.1}/allelix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: allelix
-Version: 2.2.0
+Version: 2.2.1
 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.1}/allelix.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ allelix/reports/terminal.py
 allelix/utils/__init__.py
 allelix/utils/allele.py
 allelix/utils/build_detect.py
+tests/test_changelog_sanitize.py
 tests/test_cli.py
 tests/test_cli_helpers.py
 tests/test_compare.py

{allelix-2.2.0 → allelix-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "allelix"
-version = "2.2.0"
+version = "2.2.1"
 description = "Open-source genotype analysis toolkit. Format-agnostic ingestion, database-agnostic annotation, offline-first."
 readme = "README.md"
 requires-python = ">=3.11"

allelix-2.2.1/tests/test_changelog_sanitize.py

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2026 Allelix
+"""Release-gate sanitize guard for the public CHANGELOG.
+
+GH #118: CHANGELOG.md ships verbatim from the private allelix-dev
+repo to the public allelix repo and PyPI. Bare `#NN` references
+auto-link on GitHub against the surrounding repo's numbering — on
+the public repo they ALL 404, because the issues/PRs only exist on
+the private tracker. Same hazard for an `### Internal` section,
+which is forensic provenance no public user needs.
+
+These two assertions are the structural guard the issue requires:
+   - any bare issue/PR reference (#NN) fails the gate
+   - any `### Internal` heading fails the gate
+
+The guard runs on every fast-tier pytest pass, so a PR that
+re-introduces either form gets caught at PR time, not at tag time.
+
+If you genuinely need internal traceability for an entry, put the
+issue number in the git commit body (the private dev branch keeps
+the squash commit + the private-only release commit body — both
+retain forensic context for anyone tracing history). Public users
+read the CHANGELOG; everything in there must stand on its own.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+_CHANGELOG = Path(__file__).resolve().parent.parent / "CHANGELOG.md"
+_ISSUE_REF_PATTERN = re.compile(r"#\d+\b")
+_INTERNAL_HEADING_PATTERN = re.compile(r"^###\s+Internal\b", re.MULTILINE)
+
+
+@pytest.fixture(scope="module")
+def changelog_text() -> str:
+    return _CHANGELOG.read_text(encoding="utf-8")
+
+
+def test_changelog_has_no_issue_or_pr_references(changelog_text: str) -> None:
+    """GH #118: every `#NN` token in CHANGELOG.md auto-links to the
+    surrounding repo on GitHub. Private-repo issue/PR numbers don't
+    exist on the public repo, so every shipped `#NN` is a dead link.
+
+    If you need to credit an issue, restructure the prose so it
+    stands without the tracker number, and put the reference in the
+    git commit body (forensic context the squash commit retains).
+    """
+    matches = _ISSUE_REF_PATTERN.findall(changelog_text)
+    assert not matches, (
+        f"CHANGELOG.md contains {len(matches)} bare issue/PR reference(s) "
+        f"that would become dead links on the public repo: "
+        f"{sorted(set(matches))[:10]}{'…' if len(set(matches)) > 10 else ''}. "
+        f"Strip them (forensic context lives in the git commit body, not "
+        f"in the user-facing CHANGELOG)."
+    )
+
+
+def test_changelog_has_no_internal_section(changelog_text: str) -> None:
+    """GH #118: an `### Internal` heading carries forensic provenance
+    (architectural notes, plumbing details, fixture changes) that no
+    public user needs. The squash commit on main + the private
+    release commit body both retain this context for anyone tracing
+    history.
+    """
+    matches = _INTERNAL_HEADING_PATTERN.findall(changelog_text)
+    assert not matches, (
+        "CHANGELOG.md contains an '### Internal' heading. Move that "
+        "content into the squash commit body on main (the load-bearing "
+        "forensic surface) and drop the heading from the CHANGELOG."
+    )
+
+
+def test_changelog_keep_a_changelog_header_intact(changelog_text: str) -> None:
+    """Light sanity check that the file structure isn't accidentally
+    truncated by an over-aggressive sanitize pass — the Keep a
+    Changelog header should always be present at the top."""
+    first_lines = "\n".join(changelog_text.splitlines()[:3])
+    assert "# Changelog" in first_lines
+    assert "Keep a Changelog" in changelog_text

{allelix-2.2.0 → allelix-2.2.1}/tests/test_cli.py

@@ -533,7 +533,14 @@ class TestDbCommands:
         ):
             info = get_database_info(db_path, clinvar_record_name(build))
             assert info is not None, f"{build} cache missing version row"
-            assert info["record_count"] == 13
+            # GH #111 grew the fixture set: 13 → 20 (added 3 identical-SCV
+            # rows for rs999000111, 2 conflicting-SCV rows for rs999000222,
+            # 1 sub-floor row for rs999000333, 1 unmapped-CLNSIG row for
+            # rs999000444). #109 cross-PR review (Finding 1) added 2 more
+            # rows for rs999000555 (multi-allelic distinct-alt dedup
+            # guard) → 22 total. Cache row count stays at 22 even after
+            # #109's dedup — dedup is annotator-side, not loader-side.
+            assert info["record_count"] == 22
             assert info["version"] == "20260101"
 
         pharmgkb_info = get_database_info(pharmgkb_sqlite, "pharmgkb")
@@ -1047,6 +1054,18 @@ class TestDbCommands:
         import os
         import stat
 
+        # GH #110: chmod 0 is bypassed by root — root sees a "readonly"
+        # dir as writable (DAC override) and the test silently passes
+        # for the wrong reason. CI runners and dev containers commonly
+        # run as root; skip there with a clear message so the test
+        # isn't a false-green on those environments. Hermetic
+        # local-dev runs (non-root) keep the real assertion.
+        if hasattr(os, "geteuid") and os.geteuid() == 0:
+            pytest.skip(
+                "chmod-readonly is bypassed under root (DAC override); "
+                "test is non-hermetic in that environment. Run as a "
+                "non-root user to exercise the writability check."
+            )
         # Make the dir non-writable
         os.chmod(tmp_path, stat.S_IRUSR | stat.S_IXUSR)
         try:
@@ -1211,6 +1230,33 @@ class TestDbCommands:
         stderr_flat = " ".join(result.stderr.split())
         assert "doesn't look like an allelix cache" in stderr_flat
 
+    def test_db_clean_refuses_dir_with_only_generic_config_toml(self, tmp_path: Path):
+        """GH #112: a `config.toml` alongside non-allelix content (the
+        Rust / Hugo / Rocket / etc. project shape) must NOT pass the
+        guard. Pre-#112 the guard accepted any dir with a config.toml
+        — so a typo'd `--data-dir ~/my-rust-project` could trigger
+        `rm -rf` against a Cargo project root.
+
+        Pinned: a generic config.toml + any non-allelix file →
+        guard refuses with the "doesn't look like an allelix cache"
+        error and exit code 1, regardless of what's in config.toml.
+        """
+        # A Rust-shaped config.toml (no allelix-specific sections).
+        (tmp_path / "config.toml").write_text("[package]\nname = 'not-allelix'\n")
+        (tmp_path / "Cargo.lock").write_text("# cargo lockfile\n")
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src" / "main.rs").write_text("fn main() {}\n")
+
+        runner = CliRunner()
+        result = runner.invoke(main, ["db", "clean", "--data-dir", str(tmp_path), "--yes"])
+        assert result.exit_code == 1
+        stderr_flat = " ".join(result.stderr.split())
+        assert "doesn't look like an allelix cache" in stderr_flat
+        # And the Cargo project survives the encounter unharmed.
+        assert (tmp_path / "config.toml").exists()
+        assert (tmp_path / "Cargo.lock").exists()
+        assert (tmp_path / "src" / "main.rs").exists()
+
 
 class TestAnalyzeOutputDispatch:
     def test_analyze_writes_json(