allelix 2.2.2__tar.gz → 2.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: allelix
-Version: 2.2.2
+Version: 2.2.3
 Summary: Open-source genotype analysis toolkit. Format-agnostic ingestion, database-agnostic annotation, offline-first.
 Author: Allelix
 Maintainer-email: dial481 <dial481@users.noreply.github.com>
@@ -190,8 +190,10 @@ disease findings. Wherever you write them via `--output <path>`,
 that's where they sit until you delete them. Allelix doesn't
 auto-clean and won't warn you when you write to `/tmp/` or any
 other shared location. Treat the files as personal data: read them,
-move them somewhere you control, or delete when you're done. A
-data-lifecycle subcommand is planned for v2.1.
+move them somewhere you control, or delete when you're done.
+`allelix db clean` (shipped in v2.2.0) handles the cache side of
+the lifecycle; output reports are still the user's responsibility
+to manage.
 
 ## Configuration
 

{allelix-2.2.2 → allelix-2.2.3}/README.md

@@ -151,8 +151,10 @@ disease findings. Wherever you write them via `--output <path>`,
 that's where they sit until you delete them. Allelix doesn't
 auto-clean and won't warn you when you write to `/tmp/` or any
 other shared location. Treat the files as personal data: read them,
-move them somewhere you control, or delete when you're done. A
-data-lifecycle subcommand is planned for v2.1.
+move them somewhere you control, or delete when you're done.
+`allelix db clean` (shipped in v2.2.0) handles the cache side of
+the lifecycle; output reports are still the user's responsibility
+to manage.
 
 ## Configuration
 

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

@@ -247,34 +247,29 @@ class GnomadAnnotator(Annotator):
             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.
+        # 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 ``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.
         #
-        # 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.
+        # Each input pair binds 2 SQLite parameters (chrom + pos), so
+        # the chunk size is ``_BULK_BATCH_SIZE // 2`` to stay inside the
+        # 999-param convention every other annotator and gnomAD's own
+        # multi-param queries respect (``bulk_lookup_by_alt`` does the
+        # same 2-param shape with the same ``// 2``;
+        # ``bulk_lookup_by_position`` uses ``// 4`` for its 4-param
+        # shape, same convention scaled). Net effective batch size:
+        # 450 pairs x 2 = 900 params per chunk.
+        chunk_pairs = _BULK_BATCH_SIZE // 2
         position_list = list(positions)
-        for i in range(0, len(position_list), _BULK_BATCH_SIZE):
-            batch = position_list[i : i + _BULK_BATCH_SIZE]
+        for i in range(0, len(position_list), chunk_pairs):
+            batch = position_list[i : i + chunk_pairs]
             placeholders = ",".join("(?, ?)" for _ in batch)
             params: list[str | int] = []
             for chrom, pos in batch:

{allelix-2.2.2 → allelix-2.2.3}/allelix/parsers/twentythreeandme.py

@@ -42,7 +42,26 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-_CANONICAL_PREFIX = "# This data file generated by 23andMe"
+# Known canonical first-line banner variants 23andMe wraps raw exports in.
+# The original v2/v3/v4-era exports used the verbatim ``generated by`` form;
+# the June 2026 v5 export prose was edited to ``is generated by`` (with a
+# trailing period in some samples). Match either; future vendor banner
+# edits get a new entry here.
+#
+# Why a tuple of exact prefixes instead of a loose ``"23andMe" in line``
+# substring match: a bare substring check false-positives on transcoded
+# fixtures and third-party tool output. Files that strip the canonical
+# banner entirely (WGSExtract output, Genetic Lifehacks converter output,
+# privacy-conscious users who delete the comment block) are out of scope
+# for this parser by design — they are handled by ``GenericTsvParser`` at
+# the end of the dispatch chain (planned, see GH #146 / GH #127). That
+# two-layer design keeps banner-bearing 23andMe files attributed to
+# "23andMe" and banner-less 23andMe-shape files attributed to "generic-tsv"
+# without guessing a vendor.
+_CANONICAL_PREFIXES: tuple[str, ...] = (
+    "# This data file generated by 23andMe",
+    "# This data file is generated by 23andMe",
+)
 SNIFF_LINE_LIMIT = 50
 EXPECTED_COLUMNS = 4
 
@@ -58,10 +77,13 @@ class TwentyThreeAndMeParser(GenotypeParser):
     def can_parse(self, file_path: Path) -> bool:
         """Recognize a real 23andMe export by its canonical first-line header.
 
-        Real exports start with ``# This data file generated by 23andMe at: ...``.
+        Real exports start with one of the variants in ``_CANONICAL_PREFIXES``:
+        the historical ``# This data file generated by 23andMe at: ...`` form
+        or the June 2026 v5 ``# This data file is generated by 23andMe.`` form.
         Some files have user-prepended comments before the canonical line; the
-        fallback loop scans up to ``SNIFF_LINE_LIMIT`` comment lines. A bare
-        "23andMe" mention without the canonical prefix is rejected.
+        scan loop reads up to ``SNIFF_LINE_LIMIT`` comment lines. A bare
+        "23andMe" substring mention without one of the canonical prefixes is
+        rejected (see ``_CANONICAL_PREFIXES`` rationale).
         """
         try:
             with file_path.open("r", encoding="utf-8") as fh:
@@ -71,7 +93,7 @@ class TwentyThreeAndMeParser(GenotypeParser):
                         return False
                     if not line.startswith("#"):
                         return False
-                    if line.startswith(_CANONICAL_PREFIX):
+                    if any(line.startswith(p) for p in _CANONICAL_PREFIXES):
                         return True
         except (OSError, UnicodeDecodeError):
             return False

{allelix-2.2.2 → allelix-2.2.3}/allelix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: allelix
-Version: 2.2.2
+Version: 2.2.3
 Summary: Open-source genotype analysis toolkit. Format-agnostic ingestion, database-agnostic annotation, offline-first.
 Author: Allelix
 Maintainer-email: dial481 <dial481@users.noreply.github.com>
@@ -190,8 +190,10 @@ disease findings. Wherever you write them via `--output <path>`,
 that's where they sit until you delete them. Allelix doesn't
 auto-clean and won't warn you when you write to `/tmp/` or any
 other shared location. Treat the files as personal data: read them,
-move them somewhere you control, or delete when you're done. A
-data-lifecycle subcommand is planned for v2.1.
+move them somewhere you control, or delete when you're done.
+`allelix db clean` (shipped in v2.2.0) handles the cache side of
+the lifecycle; output reports are still the user's responsibility
+to manage.
 
 ## Configuration
 

{allelix-2.2.2 → allelix-2.2.3}/pyproject.toml

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

allelix-2.2.3/tests/test_changelog_sanitize.py

@@ -0,0 +1,179 @@
+# 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
+
+
+# Drift-vulnerable count patterns. These match the three shapes that have
+# historically shipped in release content and silently rotted across DB
+# refreshes: panel-coverage ratios ("3/20 found"), timing arrows
+# ("~165s → ~133s"), and explicit before/after pairs ("went from X to Y").
+# Each is an absolute measurement against a specific DB snapshot — the same
+# code on a refreshed DB will produce different numbers, so any reader
+# (or reviewer) re-running the analysis later sees what looks like a
+# regression.
+#
+# The patterns are deliberately narrow: they flag comparison constructs
+# specifically, not bare numbers in infrastructure descriptions ("10
+# non-blank lines", "57M-row cache", "999-param convention"). The
+# harness output format (``✓ <key>: N annotations, M unique keys, all
+# invariants hold``) deliberately does not match, because that line IS
+# the drift-tolerant signal — see ``test_data/check_ground_truth.py``.
+_DRIFT_PATTERNS = (
+    re.compile(r"\d+/\d+ found"),  # "3/20 found"
+    re.compile(r"~\d+\s*s\b.*→.*~\d+\s*s\b"),  # "~165s → ~133s"
+    re.compile(r"went from \d", re.IGNORECASE),  # "went from X to Y"
+)
+
+# Caveat keywords that opt a drift-pattern line back in: if a paragraph
+# contains a comparison count AND one of these keywords nearby, the
+# author has explicitly tagged the measurement as a snapshot. The check
+# is per-section (not per-line) so a single calibration paragraph at
+# the top of an [Unreleased] block covers all measurements inside.
+_SNAPSHOT_CAVEAT_KEYWORDS = (
+    "snapshot",
+    "drift",
+    "point-in-time",
+    "harness floor",
+    "harness invariant",
+    "ground-truth harness",
+)
+
+
+def _extract_unreleased_section(text: str) -> str:
+    """Return the ``[Unreleased]`` block (without surrounding sections).
+
+    The guard scopes drift-pattern enforcement to ``[Unreleased]`` only.
+    Already-shipped release sections are immutable history; rewriting
+    them would create churn for no reader benefit (the corresponding
+    PyPI sdist and squash commit body are forever pinned regardless).
+    The discipline is forward-looking — every release shipped from this
+    commit onward gets the check.
+    """
+    marker_open = "\n## [Unreleased]"
+    if marker_open not in text:
+        return ""
+    after = text.split(marker_open, 1)[1]
+    # The block runs until the next ``## [`` heading or EOF.
+    next_section = re.search(r"\n## \[", after)
+    if next_section:
+        return after[: next_section.start()]
+    return after
+
+
+def test_changelog_unreleased_has_no_drift_vulnerable_counts(
+    changelog_text: str,
+) -> None:
+    """GH #145-era discipline: raw drift-vulnerable counts in
+    ``[Unreleased]`` must carry an explicit snapshot caveat, or the
+    measurement must be quoted via the §19 ground-truth harness output
+    format (which is drift-tolerant by design).
+
+    See ``CONTRIBUTING.md`` § Release-content discipline for the
+    rationale and the two acceptable shapes.
+    """
+    unreleased = _extract_unreleased_section(changelog_text)
+    if not unreleased.strip():
+        # Empty [Unreleased] section is fine — nothing to validate.
+        return
+    drift_hits: list[str] = []
+    for pattern in _DRIFT_PATTERNS:
+        for match in pattern.finditer(unreleased):
+            drift_hits.append(match.group(0))
+    if not drift_hits:
+        return
+    # Any drift hit requires a snapshot caveat keyword anywhere in the
+    # [Unreleased] block. One calibration paragraph at the top of the
+    # block covers all measurements inside.
+    lowered = unreleased.lower()
+    if any(kw in lowered for kw in _SNAPSHOT_CAVEAT_KEYWORDS):
+        return
+    raise AssertionError(
+        f"CHANGELOG.md [Unreleased] contains {len(drift_hits)} drift-vulnerable "
+        f"count(s) without a snapshot caveat: {drift_hits[:5]}"
+        f"{'…' if len(drift_hits) > 5 else ''}. "
+        f"Either remove the raw counts, wrap them with an explicit snapshot "
+        f"caveat (any of: {', '.join(_SNAPSHOT_CAVEAT_KEYWORDS)}), or quote "
+        f"the §19 ground-truth harness output format instead "
+        f"(`✓ <key>: N annotations, M unique keys, all invariants hold`). "
+        f"See CONTRIBUTING.md § Release-content discipline."
+    )

allelix-2.2.2/tests/test_changelog_sanitize.py

@@ -1,83 +0,0 @@
-# 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