afquery 0.3.3__tar.gz → 0.4.0__tar.gz

{afquery-0.3.3 → afquery-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: afquery
-Version: 0.3.3
+Version: 0.4.0
 Summary: Genomic allele frequency query engine with bitmap-encoded genotypes
 License: MIT
 License-File: LICENSE
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/pypi/pyversions/afquery.svg)](https://pypi.org/project/afquery/)
 [![License: MIT](https://img.shields.io/github/license/babelomics/afquery)](https://github.com/babelomics/afquery/blob/master/LICENSE)
 
-**Fast, capture-aware allele frequency queries on local genomic cohorts — without re-scanning VCFs.**
+**Fast, capture-aware allele frequency queries on local genomic cohorts**
 
 AFQuery is a bitmap-indexed engine that recomputes AC/AN/AF for arbitrary subcohorts (by phenotype, sex, sequencing technology, or any combination) in tens of milliseconds, independently of cohort size. It accounts for capture-kit heterogeneity, ploidy on sex chromosomes, and FILTER/coverage evidence, and runs locally as a file-based system (Parquet + SQLite) with no server or cluster required.
 
@@ -231,7 +231,6 @@ AFQuery indexes each variant as three Roaring Bitmaps — heterozygous PASS carr
 | Workload | AFQuery | bcftools | Speedup |
 |---|---|---|---|
 | Full-chromosome AC/AN/AF export | ~7.0 s | ~3.8 min | **~33×** |
-| AF concordance over 1,106,181 common variants | — | — | **R² > 0.99999** |
 
 Point-query latency on AFQuery is ~14 ms and constant from 1K to 50K samples (median over 50 replicates, warm cache).
 
@@ -250,7 +249,3 @@ If you use AFQuery in your work, please cite:
 
 > AFQuery: fast, capture-aware allele frequency queries on local genomic cohorts.
 > *(manuscript in preparation)*
-
-## License
-
-[MIT](LICENSE)

{afquery-0.3.3 → afquery-0.4.0}/README.md

@@ -10,7 +10,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/afquery.svg)](https://pypi.org/project/afquery/)
 [![License: MIT](https://img.shields.io/github/license/babelomics/afquery)](https://github.com/babelomics/afquery/blob/master/LICENSE)
 
-**Fast, capture-aware allele frequency queries on local genomic cohorts — without re-scanning VCFs.**
+**Fast, capture-aware allele frequency queries on local genomic cohorts**
 
 AFQuery is a bitmap-indexed engine that recomputes AC/AN/AF for arbitrary subcohorts (by phenotype, sex, sequencing technology, or any combination) in tens of milliseconds, independently of cohort size. It accounts for capture-kit heterogeneity, ploidy on sex chromosomes, and FILTER/coverage evidence, and runs locally as a file-based system (Parquet + SQLite) with no server or cluster required.
 
@@ -201,7 +201,6 @@ AFQuery indexes each variant as three Roaring Bitmaps — heterozygous PASS carr
 | Workload | AFQuery | bcftools | Speedup |
 |---|---|---|---|
 | Full-chromosome AC/AN/AF export | ~7.0 s | ~3.8 min | **~33×** |
-| AF concordance over 1,106,181 common variants | — | — | **R² > 0.99999** |
 
 Point-query latency on AFQuery is ~14 ms and constant from 1K to 50K samples (median over 50 replicates, warm cache).
 
@@ -220,7 +219,3 @@ If you use AFQuery in your work, please cite:
 
 > AFQuery: fast, capture-aware allele frequency queries on local genomic cohorts.
 > *(manuscript in preparation)*
-
-## License
-
-[MIT](LICENSE)

{afquery-0.3.3 → afquery-0.4.0}/docs/advanced/debugging-results.md

@@ -16,6 +16,8 @@ AN=0 means no eligible samples at the queried position. Work through these check
 | Position exists in database | `afquery query --db ./db/ --locus chr1:12345678` | If no result at all, the variant was not observed in any sample during ingestion. |
 | BED coverage (WES) | `afquery info --db ./db/` | If all eligible samples are WES and the position is outside capture regions, AN=0 is correct. |
 | Sample filter too restrictive | Remove `--phenotype` and `--sex` filters | Query with no filters first. If AN>0 without filters, the filter is excluding all samples. |
+| WES samples missing from AN | Compare `variant-info` carriers against `query` counts | If `variant-info` shows many WES carriers but AN reflects only the WGS samples, that technology's capture index is not matching the position. `afquery` warns on open when a capture BED is empty or matches no known chromosome, naming the offending contigs. |
+| AN=0 only on chrM | `afquery query --db ./db/ --locus chrM:3243` | Mitochondrial coverage is easy to lose on its own: a BED naming it `chrMT` still matches on the autosomes, so nothing else looks wrong. Names are normalized (`MT`, `M`, `chrMT` → `chrM`) since v0.4.0 — databases built before that may need the capture BED re-checked. |
 | Technology filter | Remove `--tech` filter | Check if any samples match the requested technology. |
 
 ### 2. Unexpected AF Value

{afquery-0.3.3 → afquery-0.4.0}/docs/faq.md

@@ -100,7 +100,11 @@ Yes. Both GRCh37 and GRCh38 are supported. Specify at database creation:
 afquery create-db --genome-build GRCh37 ...
 ```
 
-The genome build affects PAR1/PAR2 coordinates on chrX (see [Ploidy & Special Chromosomes](advanced/ploidy-and-sex-chroms.md)). Chromosome names in your VCFs should match the chosen build (`chr1`/`1` both work — `normalize_chrom()` handles the `chr` prefix).
+The genome build affects PAR1/PAR2 coordinates on chrX (see [Ploidy & Special Chromosomes](advanced/ploidy-and-sex-chroms.md)). Chromosome names in your VCFs and capture BEDs are normalized to a canonical `chr`-prefixed
+form, so the common naming conventions interoperate: `1` and `chr1` both become `chr1`, `X`
+and `x` become `chrX`, and `MT`, `M` and `chrMT` all become `chrM`. Unplaced and alt contigs
+(`GL000209.1`, `chr1_KI270706v1_random`) are left alone and skipped at build time — the build
+log reports which ones it dropped.
 
 ---
 

{afquery-0.3.3 → afquery-0.4.0}/docs/guides/variant-info.md

@@ -15,6 +15,18 @@ afquery variant-info --db ./db/ --locus chr1:925952
 !!! tip
     `variant-info` is the natural next step after `query` — once you find a variant of interest, use it to see which specific samples carry it.
 
+!!! note "Carrier counts may exceed the counts reported by `query`"
+    `variant-info` lists every carrier present in the source VCFs. `query` additionally
+    restricts to samples whose capture regions cover the position, so a WES sample with a
+    call just outside its own BED appears here but is not counted in `AN`, `AC` or the
+    genotype tallies. The two commands answer different questions — "who carries it?"
+    versus "what is the frequency among samples that could have been called?" — so a
+    modest difference is expected.
+
+    A *large* gap is worth investigating: if `variant-info` shows many carriers from a
+    technology that contributes nothing to `AN`, check that technology's capture index
+    (see [Debugging Results](../advanced/debugging-results.md)).
+
 By default all samples are queried and results are printed as an aligned text table:
 
 ```

{afquery-0.3.3 → afquery-0.4.0}/src/afquery/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.3'
-__version_tuple__ = version_tuple = (0, 3, 3)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

afquery-0.4.0/src/afquery/capture.py

@@ -0,0 +1,216 @@
+import bisect
+import itertools
+import pickle
+import warnings
+import pyranges as pr
+import pandas as pd
+from .constants import ALL_CHROMS, normalize_chrom
+from .models import Technology
+
+
+class CaptureIndex:
+    """Interval index over a capture BED, queried by 1-based position.
+
+    Chromosome keys in ``_index`` are always normalized (see
+    :func:`~afquery.constants.normalize_chrom`), because queries reach
+    :meth:`covers` already normalized. BED files in the wild use either
+    convention ('1' for GRCh37/hs37d5, 'chr1' for hg38), so normalizing on
+    construction is what keeps the two sides in agreement.
+    """
+
+    _always_covered: bool
+    _pr: "pr.PyRanges | None"
+    # Per-chrom sorted interval index, keyed by normalized chrom:
+    #   {chrom: (sorted_starts, corresponding_ends, running_max_of_ends)}
+    # The running max lets covers() answer in O(log n) — see there.
+    _index: "dict[str, tuple[list[int], list[int], list[int]]]"
+
+    def __init__(self, *, always_covered: bool = False, pyranges_obj=None):
+        self._always_covered = always_covered
+        self._pr = pyranges_obj
+        self._index = {}
+        if pyranges_obj is not None:
+            df = pyranges_obj.df
+            by_chrom: dict[str, list[tuple[int, int]]] = {}
+            for chrom, group in df.groupby("Chromosome", observed=True):
+                # Normalizing can merge two groups ('1' and 'chr1') into one key,
+                # so accumulate before sorting rather than assigning per group.
+                key = normalize_chrom(str(chrom))
+                by_chrom.setdefault(key, []).extend(
+                    zip(group["Start"].tolist(), group["End"].tolist())
+                )
+            self._index = {
+                chrom: self._pack(pairs) for chrom, pairs in by_chrom.items()
+            }
+
+    @staticmethod
+    def _pack(pairs: list[tuple[int, int]]) -> tuple[list[int], list[int], list[int]]:
+        """Sort (start, end) pairs by start and precompute the running max of ends."""
+        pairs = sorted(pairs)
+        starts = [s for s, _ in pairs]
+        ends = [e for _, e in pairs]
+        return starts, ends, list(itertools.accumulate(ends, max))
+
+    @classmethod
+    def wgs(cls) -> "CaptureIndex":
+        return cls(always_covered=True)
+
+    @classmethod
+    def from_bed(cls, bed_path: str) -> "CaptureIndex":
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=pd.errors.DtypeWarning)
+            try:
+                ranges = pr.read_bed(bed_path)
+            except (IndexError, AssertionError, pd.errors.EmptyDataError):
+                # pyranges raises rather than returning an empty frame when a BED
+                # holds no intervals: IndexError for a zero-byte file, AssertionError
+                # for a comment-only one. An empty index is the honest representation
+                # — the caller reports it (see describe_capture_problem) instead of
+                # the build dying on an opaque traceback.
+                return cls()
+        return cls(pyranges_obj=ranges)
+
+    def covers(self, chrom: str, pos: int) -> bool:
+        """Return True if 1-based pos is within any region for this chrom.
+
+        BED is 0-based half-open: [Start, End) → 1-based: Start < pos <= End
+        """
+        if self._always_covered:
+            return True
+        entry = self._index.get(chrom)
+        if entry is None:
+            return False
+        starts, _ends, max_ends = entry
+        # Find rightmost interval whose Start < pos (0-based start, so Start < pos_1based)
+        # bisect_left gives insertion point for pos in starts; all starts[:idx] < pos
+        idx = bisect.bisect_left(starts, pos) - 1
+        # Intervals may overlap, so any of starts[:idx+1] could reach pos. max_ends[idx]
+        # is the largest End among them, so it alone decides — no backwards scan needed.
+        return idx >= 0 and max_ends[idx] >= pos
+
+    @property
+    def is_always_covered(self) -> bool:
+        """True for the WGS sentinel: every position counts as covered."""
+        return self._always_covered
+
+    def indexed_chroms(self) -> set[str]:
+        """Normalized chrom names present in the index, unknown contigs included."""
+        return set(self._index)
+
+    def known_chroms(self) -> set[str]:
+        """Indexed chrom names that are real chromosomes (subset of ALL_CHROMS)."""
+        return self.indexed_chroms() & set(ALL_CHROMS)
+
+    def is_empty(self) -> bool:
+        """True when the index holds no intervals at all.
+
+        The WGS sentinel is not empty — it covers everything without an index.
+        """
+        return not self._always_covered and not self._index
+
+    def __getstate__(self) -> dict:
+        """Pickle without _pr — nothing outside this class reads the PyRanges object.
+
+        Keeping it put a pandas DataFrame in every WES pickle and made loading depend
+        on the pyranges/pandas versions that wrote it. Worse, __init__ normalizes the
+        chrom keys of _index but not of _pr, so a pickled _pr is a stale copy of the
+        raw BED names — exactly what a future reader would reintroduce this bug from.
+        _index alone answers covers() and is enough to rebuild after a normalization
+        change.
+        """
+        state = self.__dict__.copy()
+        state.pop("_pr", None)
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Migrate pickles written by older versions.
+
+        Three generations are repaired here, so existing databases self-heal on
+        load with no rebuild:
+          1. no _index at all (pre binary-search refactor) — rebuilt from _pr;
+          2. un-normalized chrom keys ('1' instead of 'chr1'), which made covers()
+             miss every WES technology and silently drop them from AN;
+          3. 2-tuple entries lacking the running max of ends.
+        """
+        self.__dict__.update(state)
+        # Pickles written since __getstate__ carry no _pr; keep the attribute present
+        # so it stays safe to read on any restored object.
+        self.__dict__.setdefault("_pr", None)
+        index = getattr(self, "_index", None)
+
+        if index is None:
+            self._index = {}
+            if getattr(self, "_pr", None) is not None:
+                CaptureIndex.__init__(
+                    self,
+                    always_covered=self._always_covered,
+                    pyranges_obj=self._pr,
+                )
+            return
+
+        needs_migration = any(
+            chrom != normalize_chrom(chrom) or len(entry) < 3
+            for chrom, entry in index.items()
+        )
+        if not needs_migration:
+            return
+
+        # Rebuild from the stored intervals rather than from _pr: _pr is absent in
+        # some pickles, and the intervals themselves are all we need.
+        by_chrom: dict[str, list[tuple[int, int]]] = {}
+        for chrom, entry in index.items():
+            starts, ends = entry[0], entry[1]
+            by_chrom.setdefault(normalize_chrom(chrom), []).extend(zip(starts, ends))
+        self._index = {chrom: self._pack(pairs) for chrom, pairs in by_chrom.items()}
+
+    def save(self, path: str) -> None:
+        with open(path, "wb") as f:
+            pickle.dump(self, f)
+
+    @classmethod
+    def load(cls, path: str) -> "CaptureIndex":
+        with open(path, "rb") as f:
+            return pickle.load(f)
+
+
+def describe_capture_problem(index: CaptureIndex, tech_name: str) -> "str | None":
+    """Return a ready-to-emit message if this index cannot cover anything, else None.
+
+    Build time and load time both need this verdict; sharing one implementation is
+    what stops them drifting on what counts as broken. The two failures are reported
+    separately because they need different fixes:
+      - empty: the BED held no intervals (missing, empty or malformed file);
+      - unknown contigs: intervals exist but none is on a real chromosome.
+    """
+    if index.is_always_covered or index.known_chroms():
+        return None
+    consequence = (
+        "its samples will be counted as uncovered at every position, "
+        "lowering AN and inflating AF."
+    )
+    if index.is_empty():
+        return f"Capture regions for technology {tech_name!r} are empty — {consequence}"
+    found = sorted(index.indexed_chroms())
+    shown = ", ".join(found[:5]) + (", ..." if len(found) > 5 else "")
+    return (
+        f"Capture regions for technology {tech_name!r} match no known chromosome "
+        f"(found: {shown}) — {consequence}"
+    )
+
+
+def load_capture_indices(
+    technologies: list[Technology], capture_dir: str
+) -> dict[int, "CaptureIndex"]:
+    result = {}
+    for tech in technologies:
+        path = f"{capture_dir}/tech_{tech.tech_id}.pickle"
+        try:
+            result[tech.tech_id] = CaptureIndex.load(path)
+        except FileNotFoundError as exc:
+            # Defaulting to WGS here would silently inflate AN, so this must stay fatal
+            # — only the message improves.
+            raise FileNotFoundError(
+                f"Missing capture index for technology {tech.tech_name!r} at {path} — "
+                "the database is incomplete; rebuild it or re-run 'afquery update-db'."
+            ) from exc
+    return result

afquery-0.4.0/src/afquery/constants.py

@@ -0,0 +1,59 @@
+# PAR1 and PAR2 for GRCh37 and GRCh38
+PAR = {
+    "GRCh38": {
+        "chrX": [(10_001, 2_781_479), (155_701_383, 156_030_895)],
+        "chrY": [(10_001, 2_781_479), (56_887_903, 57_217_415)],
+    },
+    "GRCh37": {
+        "chrX": [(60_001, 2_699_520), (154_931_044, 155_260_560)],
+        "chrY": [(10_001, 2_649_520), (59_034_050, 59_363_566)],
+    },
+}
+
+AUTOSOMES = [f"chr{i}" for i in range(1, 23)]
+SEX_CHROMS = ["chrX", "chrY"]
+MITO_CHROM = "chrM"
+# Mitochondrion aliases seen in the wild (Ensembl 'MT', UCSC 'chrM', hybrid 'chrMT').
+_MITO_ALIASES = frozenset(["m", "mt", "chrm", "chrmt"])
+# Chromosomes whose canonical spelling is uppercase after the 'chr' prefix.
+_UPPERCASE_SUFFIXES = {"x": "X", "y": "Y"}
+ALL_CHROMS = AUTOSOMES + SEX_CHROMS + [MITO_CHROM]
+CHROM_ORDER: dict[str, int] = {c: i for i, c in enumerate(ALL_CHROMS)}
+VALID_GENOME_BUILDS = frozenset(["GRCh37", "GRCh38"])
+VALID_SEX = frozenset(["male", "female"])
+
+
+def normalize_chrom(chrom: str) -> str:
+    """Normalize chromosome name to 'chr'-prefixed canonical form.
+
+    '1' -> 'chr1', 'chr1' -> 'chr1', 'CHR1' -> 'chr1'
+    'X' -> 'chrX', 'x' -> 'chrX', 'MT' -> 'chrM', 'chrMT' -> 'chrM'
+
+    Only the 'chr' prefix and the known chromosome suffixes are case-normalized;
+    anything else keeps its body byte-for-byte ('GL000209.1' -> 'chrGL000209.1',
+    'chr1_KI270706v1_random' unchanged), so unplaced and alt contigs stay outside
+    ALL_CHROMS and are still dropped by the build stage rather than guessed at.
+
+    Idempotent on every member of ALL_CHROMS: the output is what gets persisted as
+    the Parquet partition name, so a name that changed under normalization would
+    orphan the partitions of already-built databases.
+    """
+    chrom = chrom.strip()
+    if chrom.lower() in _MITO_ALIASES:
+        return MITO_CHROM
+    body = chrom[3:] if chrom[:3].lower() == "chr" else chrom
+    if body.lower() in _UPPERCASE_SUFFIXES:
+        return "chr" + _UPPERCASE_SUFFIXES[body.lower()]
+    return "chr" + body
+
+
+def is_autosome(chrom: str) -> bool:
+    return normalize_chrom(chrom) in AUTOSOMES
+
+
+def is_sex_chrom(chrom: str) -> bool:
+    return normalize_chrom(chrom) in SEX_CHROMS
+
+
+def is_mito(chrom: str) -> bool:
+    return normalize_chrom(chrom) == MITO_CHROM

{afquery-0.3.3 → afquery-0.4.0}/src/afquery/preprocess/build.py

@@ -33,6 +33,24 @@ PARQUET_SCHEMA = pa.schema([
 ])
 
 
+def _filter_known_chroms(chroms: list[str], source: str) -> list[str]:
+    """Keep only real chromosomes, reporting the dropped contigs once.
+
+    Chrom discovery happens in three places and every one of them must drop
+    unplaced and alt contigs. Centralizing the filter is what keeps the report
+    from either vanishing — it used to live downstream of the filter, where it
+    could never fire — or firing once per row.
+    """
+    known = [c for c in chroms if c in ALL_CHROMS]
+    unknown = sorted({c for c in chroms if c not in ALL_CHROMS})
+    if unknown:
+        logger.warning(
+            "[build] Skipping %d unknown contig(s) from %s: %s",
+            len(unknown), source, ", ".join(unknown),
+        )
+    return known
+
+
 def _get_chroms_from_file(parquet_path: str) -> list[str]:
     """SELECT DISTINCT chrom from a single consolidated Parquet file."""
     path = parquet_path.replace("'", "''")
@@ -46,7 +64,7 @@ def _get_chroms_from_file(parquet_path: str) -> list[str]:
         return []
     finally:
         con.close()
-    return [r[0] for r in rows if r[0] in ALL_CHROMS]
+    return _filter_known_chroms([r[0] for r in rows], parquet_path)
 
 
 def consolidate_temp_files(
@@ -81,13 +99,12 @@ def _get_chroms_from_consolidated(path: str) -> list[str]:
     """Discover chromosomes from consolidated path (Hive-partitioned directory or single file)."""
     if os.path.isdir(path):
         # Hive-partitioned: scan chrom=X/ subdirs — fast, no SQL needed
-        chroms = []
-        for entry in os.scandir(path):
-            if entry.is_dir() and entry.name.startswith("chrom="):
-                chrom = entry.name[6:]  # strip "chrom="
-                if chrom in ALL_CHROMS:
-                    chroms.append(chrom)
-        return chroms
+        chroms = [
+            entry.name[6:]  # strip "chrom="
+            for entry in os.scandir(path)
+            if entry.is_dir() and entry.name.startswith("chrom=")
+        ]
+        return _filter_known_chroms(chroms, path)
     else:
         # Single file (legacy) — use SQL
         return _get_chroms_from_file(path)
@@ -111,7 +128,7 @@ def get_chroms_in_temp_files(tmp_dir: str) -> list[str]:
     finally:
         con.close()
 
-    return [r[0] for r in rows if r[0] in ALL_CHROMS]
+    return _filter_known_chroms([r[0] for r in rows], tmp_dir)
 
 
 def _make_table(
@@ -524,12 +541,8 @@ def build_all_parquets(
         chroms = _get_chroms_from_consolidated(consolidated_path)
     else:
         chroms = get_chroms_in_temp_files(tmp_dir)
-    valid_chroms = []
-    for chrom in chroms:
-        if chrom in ALL_CHROMS:
-            valid_chroms.append(chrom)
-        else:
-            logger.warning("Skipping unknown contig: %s", chrom)
+    # Both discovery helpers already filter to ALL_CHROMS and report what they drop.
+    valid_chroms = chroms
 
     if not valid_chroms:
         return {}

afquery-0.4.0/src/afquery/preprocess/regions.py

@@ -0,0 +1,25 @@
+import warnings
+
+from ..capture import CaptureIndex, describe_capture_problem
+from ..models import AfqueryWarning, Technology
+
+
+def build_capture_indices(
+    technologies: list[Technology],
+    capture_dir: str,
+) -> None:
+    for tech in technologies:
+        if tech.bed_path is None:
+            idx = CaptureIndex.wgs()
+        else:
+            idx = CaptureIndex.from_bed(tech.bed_path)
+            problem = describe_capture_problem(idx, tech.tech_name)
+            if problem is not None:
+                # warnings, not logger: this is also reached from the Python API via
+                # update.py, where a logger message is invisible unless the caller
+                # configured a handler. "Your allele frequencies will be wrong" has to
+                # surface on both paths.
+                warnings.warn(
+                    f"{problem} (BED: {tech.bed_path})", AfqueryWarning, stacklevel=2,
+                )
+        idx.save(f"{capture_dir}/tech_{tech.tech_id}.pickle")

{afquery-0.3.3 → afquery-0.4.0}/src/afquery/query.py

@@ -7,7 +7,7 @@ import duckdb
 from pyroaring import BitMap
 
 from .bitmaps import deserialize
-from .capture import CaptureIndex, load_capture_indices
+from .capture import CaptureIndex, describe_capture_problem, load_capture_indices
 from .constants import normalize_chrom, ALL_CHROMS, CHROM_ORDER
 from .models import AfqueryWarning, QueryParams, QueryResult, SampleCarrier, VariantKey, Sample, Technology, SampleFilter
 from .ploidy import compute_AN, split_ploidy
@@ -70,6 +70,12 @@ class QueryEngine:
         self._male_bm = sex_bms.get("male", BitMap())
         self._female_bm = sex_bms.get("female", BitMap())
         self._capture = load_capture_indices(techs, str(self._db / "capture"))
+        for tech_id, capture_idx in self._capture.items():
+            problem = describe_capture_problem(
+                capture_idx, self._tech_map[tech_id].tech_name
+            )
+            if problem is not None:
+                warnings.warn(problem, AfqueryWarning, stacklevel=2)
         self._tech_bitmaps = self._bitmaps.get("tech", {})
         self._all_samples_bm = BitMap(s.sample_id for s in self._samples)
         self._tech_name_to_id: dict[str, str] = {
@@ -95,10 +101,19 @@ class QueryEngine:
         # For each tech, store its bitmap; also precompute the union of all WGS tech bitmaps
         self._covered_all_bm: BitMap = BitMap()
         for tech_id, capture_idx in self._capture.items():
-            if capture_idx._always_covered:
+            if capture_idx.is_always_covered:
                 bm = self._tech_bitmaps.get(str(tech_id), BitMap())
                 self._covered_all_bm |= bm
 
+        # Targeted (non-WGS) technologies only. The per-position loops below run once
+        # per queried position, so the WGS ones are skipped here rather than re-tested
+        # on every iteration — they are already folded into _covered_all_bm.
+        self._targeted_capture: dict[int, CaptureIndex] = {
+            tech_id: capture_idx
+            for tech_id, capture_idx in self._capture.items()
+            if not capture_idx.is_always_covered
+        }
+
         # Cache parquet glob patterns per chrom (avoids filesystem scan on every query)
         self._glob_cache: dict[str, str | None] = {}
 
@@ -213,9 +228,7 @@ class QueryEngine:
 
         # Phase 1: count-based gate
         if min_pass > 0 or min_observed > 0:
-            for tech_id, capture_idx in self._capture.items():
-                if capture_idx._always_covered:
-                    continue
+            for tech_id in self._targeted_capture:
                 tech_bm = self._tech_bitmaps.get(str(tech_id), BitMap())
                 tech_eligible = eligible & tech_bm
                 if len(tech_eligible) == 0:
@@ -232,9 +245,7 @@ class QueryEngine:
         # Phase 2: quality_pass gate (--min-quality-evidence K)
         if quality_pass_bm is not None and min_quality_evidence > 0:
             already_filtered = filtered_bm if filtered_bm is not None else BitMap()
-            for tech_id, capture_idx in self._capture.items():
-                if capture_idx._always_covered:
-                    continue
+            for tech_id in self._targeted_capture:
                 tech_bm = self._tech_bitmaps.get(str(tech_id), BitMap())
                 tech_eligible = eligible & tech_bm
                 if len(tech_eligible) == 0:
@@ -287,9 +298,7 @@ class QueryEngine:
     ) -> tuple[BitMap, int]:
         """Return (eligible_bitmap, AN) for a single position."""
         covered = BitMap(self._covered_all_bm)  # start with WGS samples (always covered)
-        for tech_id, capture_idx in self._capture.items():
-            if capture_idx._always_covered:
-                continue  # already included in _covered_all_bm
+        for tech_id, capture_idx in self._targeted_capture.items():
             if capture_idx.covers(chrom, pos):
                 covered |= self._tech_bitmaps.get(str(tech_id), BitMap())
         eligible = sample_bitmap & covered

afquery-0.4.0/tests/data/beds/wes_kit_nochr.bed

@@ -0,0 +1,2 @@
+1	999	2000
+X	999	2000