gapit 0.2.2__py3-none-any.whl

gapit/minimap.py

@@ -0,0 +1,20 @@
+"""COVERAGE_MAP minimap — exact abricate arithmetic (SPEC.md §4)."""
+
+
+def minimap(x: int, y: int, length: int, broken: int) -> str:
+    """15-char coverage bar: '=' over [x, y] scaled onto the map width.
+
+    Replicates the Perl int() truncation quirks verbatim — do not "fix" the
+    1-based coordinate artifacts (yi may exceed width-1). ``broken`` is the
+    gap-open count; a broken map is 14 boxes with '/' after box width//2.
+    """
+    width = 15 - (1 if broken > 0 else 0)
+    scale = length / width
+    xi = int(x / scale)
+    yi = int(y / scale)
+    chars: list[str] = []
+    for i in range(width):
+        chars.append("=" if xi <= i <= yi else ".")
+        if broken > 0 and i == width // 2:
+            chars.append("/")
+    return "".join(chars)

gapit/minimap2_run.py

@@ -0,0 +1,114 @@
+"""The minimap2 invocation layer for reads mode (SPEC.md §10).
+
+Split from reads.py (which was over the 250 pure-LOC ceiling) so this module
+owns exactly one thing: running minimap2 and streaming its PAF rows. The
+minimap2 invocation's own preset vocabulary (``ReadType``) lives in paf.py,
+the lowest layer of the reads stack. Not to be confused with minimap.py,
+which owns the blastn-side COVERAGE_MAP arithmetic.
+"""
+
+import shlex
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+from gapit.db import Database
+from gapit.errors import DependencyError, GapitError
+from gapit.paf import PafRecord, ReadType, parse_paf_row
+
+
+def _stream_minimap2(argv: list[str], r1: Path) -> list[PafRecord]:
+    """Run one minimap2 invocation, streaming PAF rows off stdout as lines
+    arrive (no full-PAF materialization). stderr is drained by a background
+    thread: an undrained stderr pipe fills (~64 KB) and blocks the child
+    mid-run. Returncode != 0 raises MINIMAP2_FAILED with the captured
+    stderr text."""
+    try:
+        process = subprocess.Popen(
+            argv,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except FileNotFoundError as exc:
+        raise DependencyError(
+            "required binary not found on PATH: minimap2",
+            code="MISSING_DEPENDENCY",
+            context={"binary": "minimap2"},
+        ) from exc
+    stderr_chunks: list[str] = []
+
+    def drain() -> None:
+        if process.stderr is not None:
+            stderr_chunks.append(process.stderr.read())
+
+    thread = threading.Thread(target=drain)
+    thread.start()
+    rows: list[PafRecord] = []
+    try:
+        if process.stdout is not None:
+            for line in process.stdout:
+                stripped = line.rstrip("\n")
+                if stripped.strip():
+                    rows.append(parse_paf_row(stripped))
+    finally:
+        if process.stdout is not None:
+            process.stdout.close()  # on a parse error, SIGPIPE stops the child
+        process.wait()
+        thread.join()
+    if process.returncode != 0:
+        raise GapitError(
+            f"minimap2 failed: {''.join(stderr_chunks).strip()}",
+            code="MINIMAP2_FAILED",
+            context={"binary": "minimap2", "file": str(r1)},
+        )
+    return rows
+
+
+def run_minimap2(
+    lanes: list[tuple[Path, Path | None]],
+    database: Database,
+    *,
+    read_type: ReadType,
+    threads: int,
+    debug: bool = False,
+    nm_tags: bool = False,
+) -> list[PafRecord]:
+    """Run one minimap2 invocation per lane (PAF on stdout) and concatenate
+    the rows, streaming each lane's output row by row. The index argument is
+    always the ``sequences`` FASTA — minimap2 indexes it in memory with the
+    invocation preset's own parameters. A persisted ``.mmi`` is deliberately
+    rejected even when one sits beside the FASTA: a default-built index
+    overrides the ``-x`` preset's indexing parameters (``-k, -w or -H
+    overridden by prebuilt index``), which misassigns close homologs and
+    benchmarks slower than in-memory indexing (2026-09-19: blaCTX-M/blaSHV
+    allele divergence, +1.2 s on the ncbi db). minimap2's pairing semantics
+    for >2 input files are undocumented; per-lane runs (r1[i] alone or with
+    its mate r2[i]) are deterministic. With ``nm_tags``, ``--cs`` is added so
+    rows carry ``NM:i:`` (minimap2 omits NM from PAF output without it; the
+    alignments themselves are unchanged) — used by gapit.reads/2 identity
+    filtering. With ``debug``, echo each argv to stderr (abricate --debug
+    parity)."""
+    rows: list[PafRecord] = []
+    for r1, r2 in lanes:
+        argv = [
+            "minimap2",
+            "-x",
+            read_type,
+            "-t",
+            str(threads),
+        ]
+        if nm_tags:
+            argv.append("--cs")
+        # Input paths go to argv absolutized: an absolute path starts with
+        # "/" and can never parse as a minimap2 option, so a query file
+        # named "-d" cannot make minimap2 dump an index over its mate path.
+        argv += [str(database.sequences_path.absolute()), str(r1.absolute())]
+        if r2 is not None:
+            argv.append(str(r2.absolute()))
+        if debug:
+            print(f"gapit: run: {shlex.join(argv)}", file=sys.stderr)
+        rows.extend(_stream_minimap2(argv, r1))
+    return rows

gapit/paf.py

@@ -0,0 +1,115 @@
+"""PAF row parsing and interval arithmetic (minimap2 output boundary).
+
+Typed parsing of minimap2's PAF rows (12 required fields + tags), the
+half-open interval math used to aggregate alignment spans into coverage, and
+the per-alignment identity rule behind gapit.reads/2 filtering.
+"""
+
+from collections.abc import Iterable
+from typing import Literal
+
+from pydantic import BaseModel
+
+from gapit.errors import GapitError
+
+ReadType = Literal["sr", "map-ont", "map-hifi"]
+
+
+class PafRecord(BaseModel, frozen=True):
+    """One PAF alignment row: 12 required fields + primary flag (tp:A:P) and
+    mismatch count (NM:i:, None when minimap2 emitted no NM tag — it only
+    does with ``--cs``)."""
+
+    qname: str
+    qlen: int
+    qstart: int
+    qend: int
+    strand: Literal["+", "-"]
+    tname: str
+    tlen: int
+    tstart: int
+    tend: int
+    nmatch: int
+    alen: int
+    mapq: int
+    is_primary: bool = True
+    nm: int | None = None
+
+
+def parse_paf_row(line: str) -> PafRecord:
+    """Parse one tab-delimited PAF line; <12 fields is a hard error. Records
+    without a tp tag count as primary; NM:i: is extracted when present."""
+    fields = line.split("\t")
+    if len(fields) < 12:
+        raise GapitError(
+            f"can not parse PAF row (expected >= 12 fields): {line!r}",
+            code="PAF_PARSE_FAILED",
+        )
+    is_primary = True
+    nm: int | None = None
+    for tag in fields[12:]:
+        if tag.startswith("tp:A:"):
+            is_primary = tag == "tp:A:P"
+        elif tag.startswith("NM:i:"):
+            nm = int(tag[len("NM:i:") :])
+    strand = fields[4]
+    if strand not in ("+", "-"):
+        raise GapitError(
+            f"can not parse PAF strand (expected + or -): {strand!r}",
+            code="PAF_PARSE_FAILED",
+        )
+    # model_construct: the manual int()/strand checks above already guarantee
+    # the field types; re-validating per PAF row would be redundant.
+    return PafRecord.model_construct(
+        qname=fields[0],
+        qlen=int(fields[1]),
+        qstart=int(fields[2]),
+        qend=int(fields[3]),
+        strand=strand,
+        tname=fields[5],
+        tlen=int(fields[6]),
+        tstart=int(fields[7]),
+        tend=int(fields[8]),
+        nmatch=int(fields[9]),
+        alen=int(fields[10]),
+        mapq=int(fields[11]),
+        is_primary=is_primary,
+        nm=nm,
+    )
+
+
+def alignment_identity(record: PafRecord) -> float:
+    """Per-alignment identity for gapit.reads/2: ``100 * (alen - nm) / alen``
+    over the block length (column 10) and the NM tag (mismatches + gaps per
+    the PAF spec). A row without NM cannot be assessed and counts as 100.0;
+    a degenerate zero-length block also counts as 100.0 (no division)."""
+    if record.nm is None or record.alen <= 0:
+        return 100.0
+    return 100.0 * (record.alen - record.nm) / record.alen
+
+
+def filter_alignments(
+    rows: Iterable[PafRecord], *, min_identity: float = 0.0, min_mapq: int = 0
+) -> list[PafRecord]:
+    """gapit.reads/2 row filter: keep alignments with identity >= min_identity
+    and mapq >= min_mapq (applied after the primary-only rule upstream; both
+    thresholds default off, in which case every row is kept verbatim — the
+    gapit.reads/1 path must stay byte-identical, even for pathological rows
+    whose arithmetic identity is negative)."""
+    if min_identity <= 0.0 and min_mapq <= 0:
+        return list(rows)
+    return [row for row in rows if row.mapq >= min_mapq and alignment_identity(row) >= min_identity]
+
+
+def union_length(intervals: Iterable[tuple[int, int]]) -> int:
+    """Total length of the union of half-open [start, end) intervals:
+    sort + linear sweep. Identical arithmetic to counting positions whose
+    per-base depth is > 0, without materializing any per-base array."""
+    covered = 0
+    reach = -1
+    for start, end in sorted(intervals):
+        if end <= reach:
+            continue
+        covered += end - max(start, reach)
+        reach = end
+    return covered

gapit/proctools.py

@@ -0,0 +1,24 @@
+"""Shared external-tool plumbing: the argv subprocess runner and stderr notes."""
+
+import subprocess
+import sys
+
+from gapit.errors import DependencyError
+
+
+def run_tool(argv: list[str]) -> subprocess.CompletedProcess[str]:
+    """Run an external tool with an argv list (never a shell)."""
+    try:
+        return subprocess.run(argv, check=False, capture_output=True, text=True)
+    except FileNotFoundError as exc:
+        raise DependencyError(
+            f"required binary not found on PATH: {argv[0]}",
+            code="MISSING_DEPENDENCY",
+            context={"binary": argv[0]},
+        ) from exc
+
+
+def note(quiet: bool, message: str) -> None:
+    """Per-step progress on stderr when quiet is disabled (stdout stays pure)."""
+    if not quiet:
+        print(f"gapit: {message}", file=sys.stderr)

gapit/providers/__init__.py

@@ -0,0 +1,39 @@
+"""Database providers: the Provider contract and per-provider modules (Wave B).
+
+Each concrete provider (Wave B1..B12) is a module exporting a ``Provider``
+value consumed by :func:`gapit.providers.common.fetch_provider`.
+``REGISTRY`` maps every provider name to its ``Provider`` — the CLI's
+``gapit db fetch`` / ``gapit db list`` lookup table (Wave C-a). Imports are
+static and alphabetized; no dynamic import magic.
+"""
+
+from gapit.providers import (
+    argannot,
+    bacmet2,
+    card,
+    ecoh,
+    ecoli_vf,
+    megares,
+    ncbi,
+    plasmidfinder,
+    resfinder,
+    upec_expec_vf,
+    vfdb,
+    victors,
+)
+from gapit.providers.common import Provider
+
+REGISTRY: dict[str, Provider] = {
+    argannot.PROVIDER.name: argannot.PROVIDER,
+    bacmet2.PROVIDER.name: bacmet2.PROVIDER,
+    card.PROVIDER.name: card.PROVIDER,
+    ecoh.PROVIDER.name: ecoh.PROVIDER,
+    ecoli_vf.PROVIDER.name: ecoli_vf.PROVIDER,
+    megares.PROVIDER.name: megares.PROVIDER,
+    ncbi.PROVIDER.name: ncbi.PROVIDER,
+    plasmidfinder.PROVIDER.name: plasmidfinder.PROVIDER,
+    resfinder.PROVIDER.name: resfinder.PROVIDER,
+    upec_expec_vf.PROVIDER.name: upec_expec_vf.PROVIDER,
+    vfdb.PROVIDER.name: vfdb.PROVIDER,
+    victors.PROVIDER.name: victors.PROVIDER,
+}

gapit/providers/argannot.py

@@ -0,0 +1,94 @@
+"""ARG-ANNOT provider (acquired resistance genes) — transform only.
+
+Upstream ``get_argannot`` (abricate-get_db 1.4.0) downloads
+``ARG-ANNOT_NT_V6_July2019.txt`` — a nucleotide FASTA whose raw text is
+littered with stray backslashes (upstream calls this "fix syntax errors in
+the FASTA file"), so every backslash is stripped BEFORE parsing. Headers
+look like::
+
+    >(AGly)aac2-Ie:NC_011896:3039059-3039607:549
+
+The id token splits on ``:``: gene is ``x[0]``, accession is ``x[1]:x[2]``
+(later fields, e.g. the trailing length, are ignored — upstream never reads
+``x[3]``). Product falls back to the gene when the header carries no
+description (save_fasta's ``DESC || ID``); real ARG-ANNOT headers carry
+none. Records with fewer than 3 colon-separated fields are SKIPPED
+(documented deviation): upstream perl would splice an undefined ``x[2]``
+into the accession; a typed Record refuses to carry that.
+"""
+
+from collections.abc import Iterator
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+from gapit.fasta import iter_fasta
+from gapit.providers.common import Provider
+from gapit.records import Record
+
+NAME = "argannot"
+SOURCE_FILE = "ARG-ANNOT_NT_V6_July2019.txt"
+
+
+def transform(workdir: Path) -> Iterator[Record]:
+    """Yield Records from ``workdir/ARG-ANNOT_NT_V6_July2019.txt``.
+
+    The raw text is repaired first — every backslash stripped, upstream's
+    global ``s/\\\\//g`` — and written to a scratch file inside the workdir
+    so :func:`gapit.fasta.iter_fasta` can parse it (it takes a path). The
+    scratch file is removed on completion or early generator close.
+    Sequence arrives raw — fetch_provider N-normalizes it for the nucl
+    dbtype.
+    """
+    repaired = (workdir / SOURCE_FILE).read_text(encoding="utf-8").replace("\\", "")
+    with NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        newline="\n",
+        prefix=".argannot.",
+        suffix=".txt",
+        dir=workdir,
+        delete=False,
+    ) as handle:
+        handle.write(repaired)
+        scratch = Path(handle.name)
+    try:
+        for fasta in iter_fasta(scratch):
+            parts = fasta.id.split(":")
+            if len(parts) < 3:
+                continue
+            gene = parts[0]
+            yield Record(
+                db=NAME,
+                gene=gene,
+                sequence=fasta.sequence,
+                accession=":".join(parts[1:3]),
+                function=(),
+                product=fasta.description or gene,
+                source_id=fasta.id,
+            )
+    finally:
+        scratch.unlink(missing_ok=True)
+
+
+PROVIDER = Provider(
+    name=NAME,
+    description="ARG-ANNOT acquired resistance genes",
+    # Upstream 301-migrated; the deep link 404s on both domains (verified 2026-09-17).
+    # Wayback CDX: 2020-06-26 + 2026-01-14 captures share digest 5ZDVKAPZ4ZGIUDSYFVTFUYYY4CS5MUXZ
+    # (2024 differs: suspect partial). The 2026-01-14 memento intermittently serves a 9KB
+    # Wayback outage interstitial (LoadShardBlock datanode, observed 2026-09-18); the
+    # 2020-06-26 memento probed good (text/plain, 2,139,519 bytes, same stable digest
+    # family). Snapshot pinned, not latest; veto to upstream if it returns.
+    # The id_ suffix requests the original WARC bytes with no Wayback rewrite/redirect
+    # layer — the right form for machine fetching: verified 2026-09-18 (200, text/plain,
+    # 2139519B, FASTA head ">(AGly)aac:AJ628983:1985-2539:555") while the plain
+    # memento form flapped (interstitial twice, 45s apart).
+    source_urls=(
+        "https://web.archive.org/web/20200626214628id_/"
+        "https://www.mediterranee-infection.com/wp-content/uploads/2019/09/"
+        "ARG-ANNOT_NT_V6_July2019.txt",
+    ),
+    dbtype="nucl",
+    transform=transform,
+    snapshot=None,
+)

gapit/providers/bacmet2.py

@@ -0,0 +1,59 @@
+"""BacMet2 provider (experimentally confirmed, PROTEIN) — transform only.
+
+Upstream ``get_bacmet2`` (abricate-get_db 1.4.0) downloads
+``BacMet2_EXP_database.fasta`` — a protein file, hence the set's one
+``dbtype="prot"`` provider (screening uses blastx). Headers look like::
+
+    >BAC0098|ctpC|sp|P0A502|CTPC_MYCTU Probable manganese/zinc-exporting
+
+The id token splits on ``|``: ``bac_id|gene|db|uniprot`` plus an optional
+5th field (the UniProt entry name) that upstream ignores. Upstream
+recombines ``gene-bac_id`` as the gene name and ``db:uniprot`` as the
+accession; product falls back to the gene when the description is empty
+(save_fasta's ``DESC || ID``). Function is the locked ``biocide`` constant:
+BacMet covers biocides + metals but the 4-field id carries no class, so
+``biocide`` is the user-approved approximation (Wave F2c).
+"""
+
+from collections.abc import Iterable
+from pathlib import Path
+
+from gapit.fasta import iter_fasta
+from gapit.providers.common import Provider
+from gapit.records import Record
+
+_NAME = "bacmet2"
+_FUNCTION = ("biocide",)  # locked gapit/v1 func vocabulary (Wave F2c)
+
+
+def transform(workdir: Path) -> Iterable[Record]:
+    """Yield Records from ``workdir/BacMet2_EXP_database.fasta``.
+
+    A record whose id has fewer than 4 pipe-separated fields is skipped
+    (upstream perl would emit undef-indexed garbage). Sequence arrives raw
+    — fetch_provider X-normalizes it for the prot dbtype.
+    """
+    for fasta in iter_fasta(workdir / "BacMet2_EXP_database.fasta"):
+        parts = fasta.id.split("|")
+        if len(parts) < 4:
+            continue
+        gene = f"{parts[1]}-{parts[0]}"
+        yield Record(
+            db=_NAME,
+            gene=gene,
+            sequence=fasta.sequence,
+            accession=f"{parts[2]}:{parts[3]}",
+            function=_FUNCTION,
+            product=fasta.description or gene,
+            source_id=fasta.id,
+        )
+
+
+PROVIDER = Provider(
+    name=_NAME,
+    description="BacMet2 experimentally confirmed biocide/resistance genes (protein)",
+    source_urls=("http://bacmet.biomedicine.gu.se/download/BacMet2_EXP_database.fasta",),
+    dbtype="prot",
+    transform=transform,
+    snapshot=None,
+)

gapit/providers/card.py

@@ -0,0 +1,150 @@
+"""CARD provider (Wave B2): transform card.mcmaster.ca data into Records.
+
+Upstream quirk: the source URL ``https://card.mcmaster.ca/latest/data`` has no
+extension but serves a tar.bz2, so the download lands at ``<workdir>/data``.
+Only the root-level ``card.json`` is extracted (upstream:
+``tar xf card.tar.bz2 card.json``), matched by root-normalized member name
+because the re-tarred archive prefixes members with ``./``. Every dict-valued
+top-level entry whose
+``model_type`` is ``"protein homolog model"`` becomes one Record; a homolog
+model carrying ``model_param.snp`` is a hard error (upstream ``err()``); every
+other model type — and any non-dict entry, like the ``_version`` string — is
+    skipped. Sequence/function normalization is NOT done here: that is
+    fetch_provider's job (B0 contract).
+
+``Any`` is confined to the parsed-JSON values flowing through these helpers:
+CARD node shapes are heterogeneous, and checking them into pydantic models
+would dwarf the module. Every value crossing out to a Record is a str/int.
+"""
+
+import json
+import re
+import tarfile
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+from gapit.errors import DatabaseError
+from gapit.providers.common import Dbtype, Provider
+from gapit.records import Record
+
+NAME = "card"
+DESCRIPTION = "CARD protein homolog resistance models"
+SOURCE_URLS = ("https://card.mcmaster.ca/latest/data",)
+DBTYPE: Dbtype = "nucl"
+
+_MEMBER = "card.json"  # the one member we extract from the tarball root
+_CHAR_SPACE = re.compile(r"\s")  # per character, like perl s/\s/_/g (drug classes)
+_RUN_SPACE = re.compile(r"\s+")  # per run, like perl s/\s+/_/g (model names)
+
+
+def _root_name(member_name: str) -> str:
+    """Member path with a leading './' and a single leading '/' stripped:
+    card.mcmaster.ca re-tarred its archive with './'-prefixed members
+    (Wave E), so exact-name lookups miss."""
+    return member_name.removeprefix("./").removeprefix("/")
+
+
+def _models(tarball: Path) -> Iterator[dict[str, Any]]:
+    """Extract card.json from the tarball; yield its dict-valued entries.
+
+    The member is matched by root-normalized name (first hit in archive
+    order). Non-dict top-level values (the ``_version`` metadata string) are
+    skipped — upstream's ``next unless ref($g) eq 'HASH'``.
+    """
+    with tarfile.open(tarball, "r:bz2") as tar:
+        member = next(
+            (m for m in tar.getmembers() if _root_name(m.name) == _MEMBER),
+            None,
+        )
+        if member is None:
+            raise DatabaseError(
+                f"no {_MEMBER} member in {tarball}",
+                code="PROVIDER_INVALID",
+                context={"archive": str(tarball), "expected": _MEMBER},
+            )
+        extracted = tar.extractfile(member)
+        if extracted is None:
+            raise DatabaseError(
+                f"{_MEMBER} in {tarball} is not a regular file",
+                code="PROVIDER_INVALID",
+                context={"db": NAME},
+            )
+        card: Any = json.loads(extracted.read())
+    for model in card.values():
+        if isinstance(model, dict):
+            yield model
+
+
+def _drug_classes(model: dict[str, Any]) -> tuple[str, ...]:
+    """Drug Class category names: ' antibiotic' stripped once, then each
+    whitespace character -> '_' (upstream's two s/// on $abx), in category
+    order — sorting is fetch_provider's job."""
+    categories: Any = model.get("ARO_category", {})
+    classes: list[str] = []
+    for category in categories.values():
+        if category.get("category_aro_class_name") == "Drug Class":
+            name: str = category.get("category_aro_name", "")
+            classes.append(_CHAR_SPACE.sub("_", name.replace(" antibiotic", "", 1)))
+    return tuple(classes)
+
+
+def _first_dna(model: dict[str, Any]) -> Any:
+    """The dna_sequence dict of the lexicographically-first key under
+    model_sequences.sequence (perl: ``my ($key) = sort keys %$dna``).
+
+    Its siblings carry accession/strand/fmin/fmax; the sequence itself is the
+    ``sequence`` key of that same dict.
+    """
+    sequences: Any = model.get("model_sequences", {}).get("sequence", {})
+    first = sorted(sequences)[0]
+    return sequences[first].get("dna_sequence", {})
+
+
+def _model_record(model: dict[str, Any]) -> Record:
+    """One 'protein homolog model' -> one Record (db=card)."""
+    model_name: str = model.get("model_name", "")
+    model_param: Any = model.get("model_param") or {}
+    if "snp" in model_param:
+        raise DatabaseError(
+            f"{model_name} has model_param.snp",
+            code="PROVIDER_INVALID",
+            context={"model": model_name},
+        )
+    dna: Any = _first_dna(model)
+    strand: Any = dna.get("strand", "+")
+    fmin: Any = dna.get("fmin", 0)
+    fmax: Any = dna.get("fmax", 0)
+    start, stop = (fmax, fmin) if strand == "-" else (fmin, fmax)
+    product: Any = model.get("ARO_description") or model.get("ARO_accession", "")
+    return Record(
+        db=NAME,
+        gene=_RUN_SPACE.sub("_", model_name),
+        sequence=dna.get("sequence", ""),
+        accession=f"{dna.get('accession', '')}:{start}-{stop}",
+        function=_drug_classes(model),
+        product=product,
+        source_id=model.get("ARO_accession", ""),
+    )
+
+
+def transform(workdir: Path) -> Iterator[Record]:
+    """Provider transform: the tarball at ``<workdir>/data`` -> Records.
+
+    Non-homolog model types are skipped BEFORE the model_param.snp check
+    (upstream's statement order), so a variant model carrying an snp is
+    skipped, not an error.
+    """
+    for model in _models(workdir / "data"):
+        if model.get("model_type") == "protein homolog model":
+            yield _model_record(model)
+
+
+PROVIDER = Provider(
+    name=NAME,
+    description=DESCRIPTION,
+    source_urls=SOURCE_URLS,
+    dbtype=DBTYPE,
+    transform=transform,
+    snapshot="card.tar.gz",
+)