gnomad-api-cache 0.1.0__py3-none-any.whl

gnomad_api_cache/fetch.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import Any
+
+import requests
+from tqdm import tqdm
+
+from gnomad_api_cache._utils import _chunked
+from gnomad_api_cache.cache import VariantCache
+from gnomad_api_cache.client import post_gnomad
+from gnomad_api_cache.keys import VariantKey
+from gnomad_api_cache.query import (
+    MAX_BATCH_SIZE,
+    build_mitochondrial_query,
+    build_variant_query,
+    parse_batch_response,
+)
+
+# Documented limit is 10 requests per IP per 60s.
+REQUEST_DELAY_SECONDS = 8
+
+QueryBuilder = Callable[[list[str]], tuple[str, dict[str, str]]]
+
+
+@dataclass(frozen=True)
+class FetchSummary:
+    """Fetch run summary. Returned by fetch_into and VariantCache.fetch."""
+
+    requested: int = 0
+    already_cached: int = 0
+    fetched: int = 0
+    not_found: int = 0
+    errors: int = 0
+    failed_batches: int = 0
+
+    def __str__(self) -> str:
+        return (
+            f"{self.requested} requested, {self.already_cached} already cached, "
+            f"{self.fetched} fetched, {self.not_found} not in gnomAD, "
+            f"{self.errors} errored"
+        )
+
+
+def _fetch_batches(
+    cache: VariantCache,
+    keys: Sequence[VariantKey],
+    build_query: QueryBuilder,
+    progress: tqdm,
+    delay: float,
+) -> FetchSummary:
+    """Query `keys` in batches, depositing each response as it arrives.
+
+    Returns the tally for these batches only; the caller merges it."""
+    fetched = not_found = errors = failed_batches = 0
+    for batch in _chunked(keys, MAX_BATCH_SIZE):
+        ids = [v.id for v in batch]
+        try:
+            query, variables = build_query(ids)
+            payload = post_gnomad(query, variables)
+            records = parse_batch_response(payload, ids)
+            cache.put_many(records)
+        except (requests.RequestException, KeyError) as e:
+            cache.mark_errors(batch)
+            errors += len(batch)
+            failed_batches += 1
+            tqdm.write(f"batch of {len(batch)} failed, recorded for retry: {e}")
+        else:
+            # A null record means gnomAD has no such variant, not a failure.
+            found = sum(1 for record in records.values() if record is not None)
+            fetched += found
+            not_found += len(records) - found
+        progress.update(len(batch))
+        time.sleep(delay)
+    return FetchSummary(
+        fetched=fetched,
+        not_found=not_found,
+        errors=errors,
+        failed_batches=failed_batches,
+    )
+
+
+def fetch_into(
+    cache: VariantCache,
+    variants: list[VariantKey],
+    retry_errors: bool = True,
+    retry_not_found: bool = False,
+    delay: float = REQUEST_DELAY_SECONDS,
+) -> FetchSummary:
+    """Populate an open cache with gnomAD records for `variants`.
+
+    The cache is left open: it belongs to the caller, who may well want to
+    export from it next.
+    """
+    variants_to_fetch = cache.needs_query(
+        variants,
+        retry_errors=retry_errors,
+        retry_not_found=retry_not_found,
+    )
+    summary = FetchSummary(
+        requested=len(variants),
+        already_cached=len(variants) - len(variants_to_fetch),
+    )
+
+    if not variants_to_fetch:
+        tqdm.write("All variants already cached.")
+        return summary
+
+    nuclear = [v for v in variants_to_fetch if not v.is_mitochondrial]
+    mitochondrial = [v for v in variants_to_fetch if v.is_mitochondrial]
+
+    with tqdm(
+        total=len(variants_to_fetch), unit="variant", desc="Querying gnomAD"
+    ) as progress:
+        nuclear_tally = _fetch_batches(
+            cache, nuclear, build_variant_query, progress, delay
+        )
+        mito_tally = _fetch_batches(
+            cache, mitochondrial, build_mitochondrial_query, progress, delay
+        )
+
+    summary = replace(
+        summary,
+        fetched=nuclear_tally.fetched + mito_tally.fetched,
+        not_found=nuclear_tally.not_found + mito_tally.not_found,
+        errors=nuclear_tally.errors + mito_tally.errors,
+        failed_batches=nuclear_tally.failed_batches + mito_tally.failed_batches,
+    )
+
+    if summary.failed_batches:
+        tqdm.write(
+            f"{summary.failed_batches} batch(es) failed and were recorded as "
+            f"errors; re-run to retry them."
+        )
+    return summary
+
+
+def fetch_gnomad(
+    variants: list[VariantKey],
+    cache_file: str | Path,
+    **kwargs: Any,
+) -> FetchSummary:
+    """Populate a cache file with gnomAD records for `variants`,
+    creating the cache if it does not exist."""
+    with VariantCache(cache_file) as cache:
+        return fetch_into(cache, variants, **kwargs)

gnomad_api_cache/keys.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+CANONICAL_CHROMS = frozenset([str(i) for i in range(1, 23)] + ["X", "Y", "M"])
+
+_ALLELE_RE = re.compile(r"^[ACGTN]+$")
+
+
+class InvalidVariantError(ValueError):
+    """Raised when a record cannot be expressed as a gnomAD variant ID."""
+
+
+def normalize_chrom(chrom: str) -> str:
+    """Canonicalize a contig name to the form gnomAD expects."""
+    c = str(chrom).strip()
+
+    # strip "chr" prefix
+    if c.lower().startswith("chr"):
+        c = c[3:]
+
+    # convert "MT" to "M"
+    c = c.upper()
+    if c == "MT":
+        c = "M"
+
+    # remove leading zeros from numeric chromosomes
+    if c.isdigit():
+        c = str(int(c))  # "01" -> "1"
+
+    return c
+
+
+@dataclass(frozen=True)
+class VariantKey:
+    chrom: str
+    pos: int
+    ref: str
+    alt: str
+
+    @property
+    def id(self) -> str:
+        return f"{self.chrom}-{self.pos}-{self.ref}-{self.alt}"
+
+    @property
+    def is_mitochondrial(self) -> bool:
+        return self.chrom == "M"
+
+    @classmethod
+    def from_parts(cls, chrom: str, pos: int | str, ref: str, alt: str) -> VariantKey:
+        """Build a key from raw record fields, canonicalizing and validating."""
+        c = normalize_chrom(chrom)
+        r = str(ref).strip().upper()
+        a = str(alt).strip().upper()
+
+        if c not in CANONICAL_CHROMS:
+            raise InvalidVariantError(f"non-canonical contig: {chrom!r}")
+        try:
+            p = int(pos)
+        except (TypeError, ValueError):
+            raise InvalidVariantError(f"non-integer position: {pos!r}") from None
+        if p < 1:
+            raise InvalidVariantError(f"position must be 1-based: {pos!r}")
+        if not _ALLELE_RE.match(r):
+            raise InvalidVariantError(f"non-ACGTN ref allele: {ref!r}")
+        if not _ALLELE_RE.match(a):
+            raise InvalidVariantError(f"non-ACGTN alt allele: {alt!r}")
+
+        return cls(chrom=c, pos=p, ref=r, alt=a)
+
+    @classmethod
+    def from_id(cls, variant_id: str) -> VariantKey:
+        """Parse a "chrom-pos-ref-alt" string, e.g. from a text file or the cache."""
+        parts = str(variant_id).strip().split("-")
+        if len(parts) != 4:
+            raise InvalidVariantError(f"expected chrom-pos-ref-alt, got {variant_id!r}")
+        return cls.from_parts(*parts)

gnomad_api_cache/query.py

@@ -0,0 +1,305 @@
+"""GraphQL query construction for the gnomAD API."""
+
+from __future__ import annotations
+
+DEFAULT_DATASET = "gnomad_r4"
+
+# Server-enforced: MAX_QUERY_COST is 25 and a root `variant` field costs 1.
+MAX_BATCH_SIZE = 25
+
+# Bump whenever the fragments below change, so the cache can tell which stored
+# records predate the new fields and re-fetch only those.
+QUERY_VERSION = 1
+
+
+# --- Fragments ------------------------------------------------------------
+#
+# A fragment is a named, reusable selection set. `...VariantDetail` splices it
+# in. Declaring it once is what keeps the request small no matter how many
+# variants the batch carries.
+
+# Frequency block shared by the `exome` and `genome` fields, which have the
+# same type. `joint` is a *different* type with fewer fields, so it is spelled
+# out separately in VariantDetail below.
+SEQUENCING_DATA_FRAGMENT = """
+fragment SeqData on VariantDetailsSequencingTypeData {
+  ac
+  an
+  homozygote_count
+  hemizygote_count
+  filters
+  flags
+  faf95 { popmax popmax_population }
+  faf99 { popmax popmax_population }
+  populations { id ac an homozygote_count hemizygote_count }
+  local_ancestry_populations { id ac an }
+  age_distribution {
+    het { bin_edges bin_freq n_smaller n_larger }
+    hom { bin_edges bin_freq n_smaller n_larger }
+  }
+  quality_metrics {
+    allele_balance { alt { bin_edges bin_freq n_smaller n_larger } }
+    genotype_depth {
+      all { bin_edges bin_freq n_smaller n_larger }
+      alt { bin_edges bin_freq n_smaller n_larger }
+    }
+    genotype_quality {
+      all { bin_edges bin_freq n_smaller n_larger }
+      alt { bin_edges bin_freq n_smaller n_larger }
+    }
+    site_quality_metrics { metric value }
+  }
+}
+"""
+
+# Everything VariantDetails exposes that is worth caching. Deliberately omitted:
+#   af, ac_hom, ac_hemi  -- deprecated; derive from ac/an and *_count
+#   va                   -- GA4GH restatement of the frequency data already here;
+#                           roughly doubles the payload for no new information
+VARIANT_FRAGMENT = """
+fragment VariantDetail on VariantDetails {
+  variant_id
+  reference_genome
+  chrom
+  pos
+  ref
+  alt
+  caid
+  rsids
+  colocated_variants
+  flags
+
+  coverage {
+    exome { mean median over_1 over_5 over_10 over_15 over_20 over_25 over_30 over_50 over_100 }
+    genome { mean median over_1 over_5 over_10 over_15 over_20 over_25 over_30 over_50 over_100 }
+  }
+
+  exome { ...SeqData }
+  genome { ...SeqData }
+
+  joint {
+    ac
+    an
+    homozygote_count
+    hemizygote_count
+    filters
+    faf95 { popmax popmax_population }
+    faf99 { popmax popmax_population }
+    populations { id ac an homozygote_count hemizygote_count }
+    age_distribution {
+      het { bin_edges bin_freq n_smaller n_larger }
+      hom { bin_edges bin_freq n_smaller n_larger }
+    }
+    quality_metrics { site_quality_metrics { metric value } }
+    freq_comparison_stats {
+      contingency_table_test { p_value odds_ratio }
+      cochran_mantel_haenszel_test { chisq p_value }
+      stat_union { p_value stat_test_name gen_ancs }
+    }
+  }
+
+  transcript_consequences {
+    consequence_terms
+    domains
+    gene_id
+    gene_version
+    gene_symbol
+    hgvs
+    hgvsc
+    hgvsp
+    is_canonical
+    is_mane_select
+    is_mane_select_version
+    lof
+    lof_flags
+    lof_filter
+    major_consequence
+    polyphen_prediction
+    sift_prediction
+    refseq_id
+    refseq_version
+    transcript_id
+    transcript_version
+  }
+
+  in_silico_predictors { id value flags }
+  lof_curations { gene_id gene_version gene_symbol verdict flags project }
+  multi_nucleotide_variants {
+    combined_variant_id
+    changes_amino_acids
+    n_individuals
+    other_constituent_snvs
+  }
+  non_coding_constraint { chrom start stop element_id possible observed expected oe z }
+  vrs {
+    _id
+    type
+    location {
+      _id
+      type
+      sequence_id
+      interval { type start { type value } end { type value } }
+    }
+    state { type sequence }
+  }
+}
+"""
+
+# Mitochondrial variants live behind a different root field with a different
+# type. `variant(...)` returns null for them, which would otherwise be cached
+# as "not in gnomAD". Note the heteroplasmy-aware counts: there is no single
+# `ac`, because a mitochondrial call is homoplasmic or heteroplasmic.
+MITOCHONDRIAL_FRAGMENT = """
+fragment MitoDetail on MitochondrialVariantDetails {
+  variant_id
+  reference_genome
+  pos
+  ref
+  alt
+  rsids
+  flags
+  filters
+  an
+  ac_hom
+  ac_het
+  ac_hom_mnv
+  excluded_ac
+  max_heteroplasmy
+  heteroplasmy_distribution { bin_edges bin_freq n_smaller n_larger }
+  haplogroup_defining
+  haplogroups { id an ac_het ac_hom faf faf_hom }
+  populations { id an ac_het ac_hom heteroplasmy_distribution { bin_edges bin_freq } }
+  mitotip_score
+  mitotip_trna_prediction
+  pon_ml_probability_of_pathogenicity
+  pon_mt_trna_prediction
+  age_distribution {
+    het { bin_edges bin_freq n_smaller n_larger }
+    hom { bin_edges bin_freq n_smaller n_larger }
+  }
+  site_quality_metrics { name value }
+  genotype_quality_metrics { name all { bin_edges bin_freq } alt { bin_edges bin_freq } }
+  genotype_quality_filters { name filtered { bin_edges bin_freq } }
+  transcript_consequences {
+    consequence_terms
+    gene_id
+    gene_symbol
+    hgvsc
+    hgvsp
+    is_canonical
+    is_mane_select
+    lof
+    lof_flags
+    lof_filter
+    major_consequence
+    transcript_id
+  }
+}
+"""
+
+
+def alias_for(index: int) -> str:
+    """Alias used for the Nth variant in a batch.
+
+    Every field in a GraphQL response is keyed by its name, so 25 `variant`
+    fields would collide. Aliasing renames each one in the response.
+    """
+    return f"v{index}"
+
+
+def build_variant_query(
+    variant_ids: list[str],
+    dataset: str = DEFAULT_DATASET,
+) -> tuple[str, dict[str, str]]:
+    """Build one batched query for up to MAX_BATCH_SIZE nuclear variants.
+
+    Returns (query_text, variables), to be POSTed as
+    {"query": query_text, "variables": variables}.
+    """
+    if not variant_ids:
+        raise ValueError("no variant ids given")
+    if len(variant_ids) > MAX_BATCH_SIZE:
+        raise ValueError(
+            f"{len(variant_ids)} variants exceeds the server's per-request " +
+            f"cost ceiling of {MAX_BATCH_SIZE}"
+        )
+
+    # One "$vN: String!" per variant, plus the dataset. Declaring the dataset as
+    # a variable keeps the query text identical for every batch of a given size,
+    # which is friendlier to the server's response cache.
+    declarations = ", ".join(
+        ["$dataset: DatasetId!"]
+        + [f"${alias_for(i)}: String!" for i in range(len(variant_ids))]
+    )
+    selections = "\n".join(
+        f"  {alias_for(i)}: variant(variantId: ${alias_for(i)}, dataset: $dataset)" +
+        f" {{ ...VariantDetail }}"  # noqa: F541
+        for i in range(len(variant_ids))
+    )
+
+    query = (
+        f"query VariantBatch({declarations}) {{\n{selections}\n}}\n"
+        f"{VARIANT_FRAGMENT}{SEQUENCING_DATA_FRAGMENT}"
+    )
+    variables: dict[str, str] = {"dataset": dataset}
+    for i, vid in enumerate(variant_ids):
+        variables[alias_for(i)] = vid
+
+    return query, variables
+
+
+def build_mitochondrial_query(
+    variant_ids: list[str],
+    dataset: str = DEFAULT_DATASET,
+) -> tuple[str, dict[str, str]]:
+    """Same as build_variant_query, for chrM variants."""
+    if not variant_ids:
+        raise ValueError("no variant ids given")
+    if len(variant_ids) > MAX_BATCH_SIZE:
+        raise ValueError(
+            f"{len(variant_ids)} variants exceeds the server's per-request " +
+            f"cost ceiling of {MAX_BATCH_SIZE}"
+        )
+
+    declarations = ", ".join(
+        ["$dataset: DatasetId!"]
+        + [f"${alias_for(i)}: String!" for i in range(len(variant_ids))]
+    )
+    selections = "\n".join(
+        f"  {alias_for(i)}: mitochondrial_variant" +
+        f"(variant_id: ${alias_for(i)}, dataset: $dataset) {{ ...MitoDetail }}"
+        for i in range(len(variant_ids))
+    )
+
+    query = (
+        f"query MitoBatch({declarations}) {{\n{selections}\n}}\n"
+        f"{MITOCHONDRIAL_FRAGMENT}"
+    )
+    variables: dict[str, str] = {"dataset": dataset}
+    for i, vid in enumerate(variant_ids):
+        variables[alias_for(i)] = vid
+
+    return query, variables
+
+
+def parse_batch_response(
+    payload: dict,
+    variant_ids: list[str],
+) -> dict[str, dict | None]:
+    """Map a response body back onto the variant ids that produced it.
+
+    Returns {variant_id: record_or_None}, where None means the server had no
+    such variant.
+
+    Raises KeyError if the body has no `data` at all, which indicates a
+    transport- or query-level failure the caller should retry rather than
+    interpret as 25 absent variants.
+    """
+    data = payload.get("data")
+    if data is None:
+        raise KeyError("response contained no 'data'")
+
+    return {
+        vid: data.get(alias_for(i))
+        for i, vid in enumerate(variant_ids)
+    }

gnomad_api_cache-0.1.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: gnomad-api-cache
+Version: 0.1.0
+Summary: Fetch and cache gnomAD annotations for VCF variants.
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: cyvcf2<0.35,>=0.34.0
+Requires-Dist: pyarrow<26,>=25.0.0
+Requires-Dist: requests<3,>=2.32
+Requires-Dist: tqdm<5,>=4.66
+Description-Content-Type: text/markdown
+
+# gnomad-api-cache
+
+Fetch gnomAD annotations for the variants in a VCF, cache them in SQLite, and
+export to various output formats (parquet, csv, tsv, json).
+
+The public gnomAD API allows roughly 10 requests (of 25 variants each) per minute. 
+Annotating a cohort twice — or exporting a second format — fetches from the locally 
+built cache rather than requerying. 
+
+Re-running into an existing cache fetches only what is missing.
+
+## Install
+
+```bash
+pip install gnomad-api-cache
+
+# or with uv
+uv pip install gnomad-api-cache    # into the active environment
+uv add gnomad-api-cache            # into a project
+uv tool install gnomad-api-cache   # just the CLI
+```
+
+Requires Python 3.11 or newer.
+
+## Usage
+
+### Command line
+
+Inputs are any VCF-like file (VCF, BCF, or bgzipped VCF) and a SQLite database to store the cache. The output retrieves all variants from the cache and writes them to a file in the specified format.
+```bash
+gnomad-api-cache -i cohort.vcf.gz -c gnomad.sqlite -o annotations.parquet
+```
+
+The output format is inferred from the file extension (`.csv`, `.tsv`,
+`.parquet`, `.json`, `.jsonl`) and can be forced with `-f`:
+
+```bash
+gnomad-api-cache -i cohort.vcf.gz -c gnomad.sqlite -o annotations.txt -f tsv
+```
+
+Omit `-o` to populate the cache without writing a table:
+
+```bash
+gnomad-api-cache -i cohort.vcf.gz -c gnomad.sqlite
+```
+
+`python -m gnomad_api_cache` accepts the same arguments. Run
+`gnomad-api-cache --help` for the full list, including `--dataset`,
+`--include-populations`, and `--require-build`.
+
+### Python
+
+```python
+from gnomad_api_cache import VariantCache
+
+with VariantCache("gnomad.sqlite") as cache:
+    summary = cache.fetch_vcf("cohort.vcf.gz")
+    print(summary)  # 1234 requested, 0 already cached, 1200 fetched, ...
+
+    cache.to_parquet("annotations.parquet")
+    cache.to_csv("annotations.csv")
+```
+
+Pass a `filter_function(cyvcf2.Variant) -> bool` to decide which variants are worth querying:
+
+```python
+from cyvcf2 import Variant
+from gnomad_api_cache import VariantCache
+
+def rare_only(variant: Variant) -> bool:
+    af = variant.INFO.get("gnomad41_exome_AF", 0)
+    return float(0 if af == "." else af) <= 0.05
+
+with VariantCache("gnomad.sqlite") as cache:
+    cache.fetch_vcf("cohort.vcf.gz", filter_function=rare_only)
+```
+
+An open cache is a read-only `Mapping` keyed by `chrom-pos-ref-alt`, so cached
+records are available without another request:
+
+```python
+record = cache["1-55051215-G-A"]  # None if gnomAD has no such variant
+print(len(cache), cache.status_counts())
+```
+
+## Acknowledgement & Citation
+
+This is an unofficial client. It queries the public gnomAD GraphQL API at
+<https://gnomad.broadinstitute.org/api> and is not affiliated with or endorsed
+by the Broad Institute or the gnomAD project. Please use the shared API
+considerately — the default delay between requests is set to stay within the
+documented rate limit.
+
+If you use gnomAD data obtained through this tool, cite the current flagship
+gnomAD paper. As of the latest release, it is as follows (v4 Preprint, Vancouver):
+
+> Guez J, Goodrich JK, Moldovan MA, Chao KR, Kar P, Panchal R, Wilson MW, Laricchia KM, Rohlicek G, Biba D, Marten D. Integrating 730,947 exome sequences with clinical literature improves gene discovery. Medrxiv. 2026 Mar 25. <https://doi.org/10.64898/2026.03.23.26349081>
+
+gnomAD data use terms: <https://gnomad.broadinstitute.org/terms>
+
+## License
+
+MIT — see [LICENSE](LICENSE).

gnomad_api_cache-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+gnomad_api_cache/__init__.py,sha256=jQuyaHkYkXBy_C40vdi8mLlvt9PkfUiwLrJxSwZm2UE,911
+gnomad_api_cache/__main__.py,sha256=d_KM_g0AGvoSLaWuR3WHcJSEgadDyM2bISLxFdScsc4,176
+gnomad_api_cache/_utils.py,sha256=7hQhd6HAvDcrwZcBv5kM-GHoiGi7YCfigF0le9SjgPk,372
+gnomad_api_cache/cache.py,sha256=pcah2J1CiErkM8WKRDkbvzx7nplhxwO4evGntYJkJEw,11763
+gnomad_api_cache/cli.py,sha256=yUJyjViyIwbYlsxLU0emSgTPP5waZQK-CWFxRgCpunc,8839
+gnomad_api_cache/client.py,sha256=uZhpHeh0cp_eZAhGjBeClg4i1P-_fU5asAaUefUVoLg,566
+gnomad_api_cache/export.py,sha256=8-QQkvSz-F8_-PPl3tUj3fCLYLW3RM52JhNPDr5gkP0,11277
+gnomad_api_cache/fetch.py,sha256=P2JuQxEj20RfDU9VL87UkGW8_EeTBt1We9hhQ7nc3Xc,4659
+gnomad_api_cache/keys.py,sha256=c26ulJEyPcSo2-7902fkobe6i17uWLvRCmRyvHio_so,2316
+gnomad_api_cache/query.py,sha256=x703RuA7TKkIEOAnCUuM1UuATWQuoEDRKwSn-pXNvh0,8860
+gnomad_api_cache/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gnomad_api_cache/adapters/vcf_adapter.py,sha256=JjY1GRGOOvA_7LxAVcobaKO1TWggGiRcaIm6JkLPbN0,4350
+gnomad_api_cache-0.1.0.dist-info/METADATA,sha256=3PgyiQRm6648Cd_y_z0iZ5zZ6Sso6R-A5Y4hUf3szV8,3785
+gnomad_api_cache-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+gnomad_api_cache-0.1.0.dist-info/entry_points.txt,sha256=kb9VVmRxneYatXKPPkcp-ebFqh1zZ8aolHGNv1XOC0Y,63
+gnomad_api_cache-0.1.0.dist-info/licenses/LICENSE,sha256=04X5_8K92nIndcQhx7eO3jBWvIMsBdAgrIoE-T1t3hQ,1065
+gnomad_api_cache-0.1.0.dist-info/RECORD,,

gnomad_api_cache-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gnomad_api_cache-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gnomad-api-cache = gnomad_api_cache.cli:main

gnomad_api_cache-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 limenode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.