allelign 0.1.0__py3-none-any.whl

allelign/alleles.py

@@ -0,0 +1,90 @@
+"""Allele and chromosome primitives shared by every module.
+
+The rules here decide whether two records describe the same variant and which
+way round its effect points, so they are kept small, explicit and in one place.
+Ported unchanged from ldpred3's harmonisation module.
+"""
+
+from __future__ import annotations
+
+__all__ = ["normalize_chrom", "reverse_complement", "is_ambiguous",
+           "allele_orientation", "CHROM_ALIASES", "AUTOSOMES"]
+
+_COMP = {"A": "T", "T": "A", "C": "G", "G": "C"}
+
+#: PLINK numeric sex/mitochondrial codes and spellings -> canonical labels.
+#: ``25`` (PLINK's pseudoautosomal code) and ``XY`` both map to ``X``: PAR
+#: variants sit on X coordinates in PLINK filesets while GWAS summary
+#: statistics label the same loci X, and matching is by (normalised chrom,
+#: pos), so a separate XY label left every PAR variant silently unmatched.
+CHROM_ALIASES = {"23": "X", "24": "Y", "25": "X", "26": "MT", "M": "MT",
+                 "XY": "X"}
+
+AUTOSOMES = frozenset(str(i) for i in range(1, 23))
+
+_PALINDROMIC = frozenset((("A", "T"), ("T", "A"), ("C", "G"), ("G", "C")))
+
+
+def normalize_chrom(label):
+    """Canonical chromosome label.
+
+    Drops a ``chr`` prefix (any case) and zero padding (``01`` -> ``1``), and
+    maps sex/mitochondrial codes (``23``/``25``/``XY`` -> ``X``, ``24`` -> ``Y``,
+    ``26``/``M`` -> ``MT``). A ``chr1``/``1`` or ``X``/``23`` labelling clash is
+    one of the commonest reasons a real-data run silently matches nothing.
+    Sumstats that label PAR loci ``Y`` are not supported.
+    """
+    s = str(label).strip()
+    if s[:3].lower() == "chr":
+        s = s[3:]
+    s = s.upper()
+    if s.isdecimal():
+        s = str(int(s))
+    return CHROM_ALIASES.get(s, s)
+
+
+def reverse_complement(allele):
+    """Reverse complement of a (single- or multi-base) allele; ``None`` if not ACGT."""
+    try:
+        return "".join(_COMP[b] for b in reversed(allele))
+    except KeyError:
+        return None
+
+
+def is_ambiguous(ea, oa):
+    """True when a strand change exchanges the two alleles.
+
+    Such a pair cannot be oriented from alleles alone, because changing strand
+    also changes the effect sign. The single-base A/T and C/G case is the
+    common one; the general rule also catches multi-base pairs such as an
+    indel ``AA``/``TT``. Alleles that are individually self reverse
+    complementary (``AT``/``CG``) are safe: a strand change preserves their
+    order and therefore the sign. Inputs are expected upper-cased.
+    """
+    if (ea, oa) in _PALINDROMIC:
+        return True
+    if len(ea) == 1 and len(oa) == 1:
+        return False
+    cea, coa = reverse_complement(ea), reverse_complement(oa)
+    return cea is not None and coa is not None and cea == oa and coa == ea
+
+
+def allele_orientation(ea, oa, a1, a2):
+    """How ``(ea, oa)`` maps onto ``(a1, a2)``.
+
+    Returns ``(flip, strand)``: ``flip`` is True when the effect must be
+    negated to count ``a1``, ``strand`` is True when the match needed the
+    reverse complement. ``(None, False)`` means the allele pairs disagree.
+    Inputs are expected upper-cased.
+    """
+    if ea == a1 and oa == a2:
+        return False, False
+    if ea == a2 and oa == a1:
+        return True, False
+    cea, coa = reverse_complement(ea), reverse_complement(oa)
+    if cea is not None and coa is not None:
+        if cea == a1 and coa == a2:
+            return False, True
+        if cea == a2 and coa == a1:
+            return True, True
+    return None, False

allelign/build.py

@@ -0,0 +1,57 @@
+"""Genome-build labels and the declared-build check.
+
+A build mismatch does not look like an error: a GRCh38 file against a GRCh37
+reference keeps about 1% of variants by coordinate and still yields numbers.
+Declaring both builds turns that into a one-line refusal naming the cause.
+"""
+
+from __future__ import annotations
+
+__all__ = ["normalize_build", "check_build", "BuildMismatchError", "BUILDS"]
+
+BUILDS = ("GRCh37", "GRCh38")
+
+_ALIASES = {
+    "grch37": "GRCh37", "hg19": "GRCh37", "b37": "GRCh37", "build37": "GRCh37",
+    "37": "GRCh37", "hs37d5": "GRCh37",
+    "grch38": "GRCh38", "hg38": "GRCh38", "b38": "GRCh38", "build38": "GRCh38",
+    "38": "GRCh38",
+}
+
+
+class BuildMismatchError(ValueError):
+    """Two inputs are declared on different genome builds."""
+
+
+def normalize_build(value, *, name="genome build"):
+    """``'GRCh37'`` or ``'GRCh38'`` for any common spelling; ``None`` stays ``None``."""
+    if value is None:
+        return None
+    key = str(value).strip().lower()
+    try:
+        return _ALIASES[key]
+    except KeyError:
+        raise ValueError(f"unknown {name} {value!r}; use GRCh37 (hg19, b37) "
+                         "or GRCh38 (hg38, b38)") from None
+
+
+def check_build(declared, reference, *, what="summary statistics",
+                against="the reference"):
+    """Refuse inputs declared on different builds.
+
+    Returns ``{"declared", "reference", "status"}`` with status ``match`` or
+    ``unchecked`` (either side unknown), and raises
+    :class:`BuildMismatchError` on a disagreement, naming the remedies.
+    """
+    declared = normalize_build(declared, name=f"{what} build")
+    reference = normalize_build(reference, name="reference build")
+    if declared is None or reference is None:
+        return {"declared": declared, "reference": reference,
+                "status": "unchecked"}
+    if declared != reference:
+        raise BuildMismatchError(
+            f"{what} are declared {declared} but {against} is {reference}. "
+            f"Lift the statistics over to {reference} (UCSC liftOver, CrossMap "
+            "or bcftools +liftover, keeping the chain and failed mappings), or "
+            "re-anchor on identifiers (allelign.reanchor_on_identifier).")
+    return {"declared": declared, "reference": reference, "status": "match"}

allelign/catalog.py

@@ -0,0 +1,88 @@
+"""Header rules for streamed GWAS Catalog normalisation.
+
+This deposit profile preserves the Catalog consumers' column priorities and
+output names. It is deliberately narrower than the general sumstats reader:
+``n`` here records reported sample size, not an inferred effective N; the
+consumer must apply its study-specific sample-size policy.
+"""
+
+__all__ = ["resolve_gwas_catalog_columns"]
+
+_ALIASES = {
+    "rsid": ("hm_rsid", "rsid", "rs_id", "variant_id"),
+    "chrom": ("hm_chrom", "chromosome", "chr"),
+    "pos": ("hm_pos", "base_pair_location", "position"),
+    "effect_allele": ("hm_effect_allele", "effect_allele"),
+    "other_allele": ("hm_other_allele", "other_allele"),
+    "beta": ("hm_beta", "beta"),
+    "se": ("standard_error", "se", "standarderror"),
+    "eaf": ("hm_effect_allele_frequency", "effect_allele_frequency", "eaf"),
+    "pval": ("p_value", "pvalue", "p"),
+    "n": ("n", "sample_size", "n_total"),
+}
+_ODDS = ("hm_odds_ratio", "odds_ratio")
+# A z-score with a standard error IS an effect: beta = z * se, sign included.
+_ZSCORE = ("hm_z_score", "z_score", "zscore", "z")
+_REQUIRED = ("rsid", "effect_allele", "other_allele", "se")
+
+def resolve_gwas_catalog_columns(fieldnames, extra_aliases=None):
+    """Map normalised names onto whichever harmonised layout this file uses.
+
+    ``extra_aliases`` adds provider-scoped source names per target, tried
+    before the Catalog aliases. Returns ``(mapping, odds, zscore)`` using
+    the original header spellings; the latter two columns supply per-row
+    fallback effects. Alleles, effects (including fallbacks) and frequency
+    come from one orientation: harmonised when a complete set is available,
+    submitted otherwise. Provider allele/effect aliases choose their own
+    orientation first. This is header-only: consumers keep their streaming
+    row filters and their sample-size provenance.
+    """
+    have = {}
+    for field in (fieldnames or []):
+        have.setdefault(field.strip().lower(), field.strip())
+    aliases = dict(_ALIASES)
+    for target, names in (extra_aliases or {}).items():
+        # Provider names FIRST (only providers pass extras), so a generic
+        # column (``beta`` beside ``all_inv_var_meta_beta``) cannot override
+        # the explicit mapping.
+        aliases[target] = tuple(names) + tuple(aliases.get(target, ()))
+    mapping = {}
+    for target, names in aliases.items():
+        for alias in names:
+            if alias in have:
+                mapping[target] = have[alias]
+                break
+    # A finite submitted beta must not override a harmonised OR, nor may a
+    # row with missing hm_beta fall back to a submitted OR or z-score.
+    directional = ("effect_allele", "other_allele", "beta", "eaf")
+    provider_modes = {
+        mapping[target].lower().startswith("hm_")
+        for target in directional[:3]
+        if target in mapping and mapping[target].lower()
+        in (extra_aliases or {}).get(target, ())}
+    if len(provider_modes) > 1:
+        raise ValueError("provider aliases mix submitted and harmonised effects/alleles")
+    modes = (next(iter(provider_modes)),) if provider_modes else (True, False)
+    chosen, odds, zscore = {}, None, None
+    for harmonised in modes:
+        def pick(names):
+            return next((have[name] for name in names if name in have
+                         and name.startswith("hm_") == harmonised), None)
+
+        candidate = {target: pick(aliases[target]) for target in directional}
+        candidate_odds, candidate_z = pick(_ODDS), pick(_ZSCORE)
+        if (candidate["effect_allele"] and candidate["other_allele"]
+                and (candidate["beta"] or candidate_odds or candidate_z)):
+            chosen = {target: name for target, name in candidate.items() if name}
+            odds, zscore = candidate_odds, candidate_z
+            break
+    for target in directional:
+        mapping.pop(target, None)
+    mapping.update(chosen)
+    missing = [c for c in _REQUIRED if c not in mapping]
+    if "beta" not in mapping and odds is None and zscore is None:
+        missing.append("beta/odds_ratio/z_score")
+    if missing:
+        raise ValueError(f"unmappable columns {missing}; header={fieldnames}")
+    return mapping, odds, zscore
+

allelign/cli.py

@@ -0,0 +1,323 @@
+"""Command-line interface: ``allelign inspect | clean | align | pgs-export | download``.
+
+``align --ld-screen`` adds the LD-consistency screen, with LD computed from the
+reference fileset's own genotypes (``.bed``/``.fam`` beside the ``.bim``).
+``download`` fetches a published summary-statistics or scoring file by its
+source reference (GWAS Catalog accession, ``FINNGEN:R11:I9_AF`` and the
+other providers in :mod:`allelign.download`).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+import numpy as np
+
+from . import __version__
+from . import status as _st
+from ._common import atomic_text
+
+
+def _columns(pairs):
+    out = {}
+    for item in pairs or []:
+        if "=" not in item:
+            raise SystemExit(f"allelign: --column expects FIELD=COLUMN, got {item!r}")
+        field, col = item.split("=", 1)
+        out[field.strip()] = col.strip()
+    return out
+
+
+def _read_kwargs(args):
+    kwargs = _columns(args.column)
+    if args.n_eff is not None:
+        kwargs["n_eff"] = args.n_eff
+    if args.n_cases is not None or args.n_controls is not None:
+        kwargs["n_cases"] = args.n_cases
+        kwargs["n_controls"] = args.n_controls
+    return kwargs
+
+
+def _read(args):
+    from .sumstats import read_sumstats
+    return read_sumstats(args.sumstats, **_read_kwargs(args))
+
+
+def _qc(args, ss, status):
+    from .qc import qc_sumstats
+    if args.no_qc:
+        return np.ones(len(ss), dtype=bool), {"skipped": True}
+    return qc_sumstats(ss, min_n_ratio=args.min_n_ratio, min_maf=args.min_maf,
+                       min_info=args.min_info, max_chisq=args.max_chisq,
+                       drop_duplicates=not args.keep_duplicates, status=status)
+
+
+def _write_log(out, log):
+    with atomic_text(f"{out}.log.json") as fh:
+        json.dump(log, fh, indent=2, sort_keys=True, default=str)
+        fh.write("\n")
+
+
+def _write_status(path, ss, status):
+    _st.write_status_table(path, id=ss.id, chrom=ss.chrom, pos=ss.pos,
+                           ea=ss.ea, oa=ss.oa, codes=status)
+
+
+def cmd_inspect(args):
+    from .sumstats import inspect_columns
+    info = inspect_columns(args.sumstats, **_read_kwargs(args))
+    print(json.dumps(info, indent=2))
+    return 1 if info["missing"] else 0
+
+
+def cmd_clean(args):
+    ss = _read(args)
+    status = _st.new_status(len(ss))
+    keep, qc_log = _qc(args, ss, status)
+    out = ss.subset(keep)
+    out.write(args.out)
+    if args.status_out:
+        _write_status(args.status_out, ss, status)
+    _write_log(args.out, {"allelign": __version__, "parse": ss.parse_log,
+                          "qc": qc_log, "status": _st.status_counts(status)})
+    print(f"allelign: kept {len(out):,} of {len(ss):,} rows -> {args.out}",
+          file=sys.stderr)
+    return 0
+
+
+def cmd_align(args):
+    from .build import BuildMismatchError, check_build, normalize_build
+    from .align import (coverage_message, harmonize, reanchor_on_identifier,
+                            reference_coverage)
+    from .qc import gwas_af_on_counted_allele
+    from .sumstats import Sumstats
+    from .variants import read_variants
+
+    try:
+        build = check_build(args.sumstats_build, args.reference_build)
+    except BuildMismatchError:
+        if not args.reanchor_on_identifier:
+            raise
+        build = {"declared": normalize_build(args.sumstats_build),
+                 "reference": normalize_build(args.reference_build),
+                 "status": "reanchored"}
+    build["output"] = (build["reference"] if args.reanchor_on_identifier
+                       else build["reference"] or build["declared"])
+    ref = read_variants(args.reference).freeze()
+    ss = _read(args)
+    status = _st.new_status(len(ss))
+    keep, qc_log = _qc(args, ss, status)
+    rows = np.flatnonzero(keep)
+    sub = ss.subset(keep)
+    log = {"allelign": __version__, "parse": ss.parse_log, "qc": qc_log,
+           "build": build}
+    if args.reanchor_on_identifier:
+        sub, log["reanchor"], rkeep = reanchor_on_identifier(
+            sub, ref, return_keep=True)
+        status[rows[~rkeep]] = _st.REANCHOR_DROPPED
+        rows = rows[rkeep]
+    sub_status = _st.new_status(len(sub)) if args.status_out else None
+    h = harmonize(sub, ref, drop_ambiguous=not args.keep_ambiguous,
+                  status=sub_status)
+    if sub_status is not None:
+        # Per-row harmonisation reasons (the row loop) only when a status
+        # table was asked for; otherwise the harmonize log has the counts.
+        status[rows] = np.where(status[rows] == 0, sub_status, status[rows])
+    log["harmonize"] = h.log
+    coverage = reference_coverage(sub, ref, h)
+    log["coverage"] = coverage
+    message = coverage_message(coverage, label=str(args.sumstats))
+    if message:
+        print(f"allelign: {message}", file=sys.stderr)
+    passed = np.ones(len(h), dtype=bool)
+    if args.ld_screen:
+        passed, log["ld_screen"] = _ld_screen(args, ref, h)
+        status[rows[h.src_index[~passed]]] = _st.LD_INCONSISTENT
+    vi, src = h.var_index[passed], h.src_index[passed]
+    aligned = Sumstats(
+        id=np.asarray(ref.id, dtype=object)[vi],
+        chrom=np.asarray(ref.chrom, dtype=object)[vi],
+        pos=np.asarray(ref.pos, dtype=np.int64)[vi],
+        ea=np.asarray(ref.a1, dtype=object)[vi],
+        oa=np.asarray(ref.a2, dtype=object)[vi],
+        beta=h.beta[passed], se=h.se[passed], n_eff=h.n_eff[passed],
+        eaf=gwas_af_on_counted_allele(sub.eaf, src, h.flipped[passed]),
+        info=np.asarray(sub.info, dtype=float)[src])
+    aligned.write(args.out)
+    if args.status_out:
+        _write_status(args.status_out, ss, status)
+        log["status"] = _st.status_counts(status)
+    else:
+        log["status_before_harmonize"] = _st.status_counts(status)
+    _write_log(args.out, log)
+    print(f"allelign: aligned {len(aligned):,} of {len(ss):,} rows to "
+          f"{len(ref):,} reference variants -> {args.out}", file=sys.stderr)
+    return 0
+
+
+def _ld_screen(args, ref, h):
+    """Keep-mask over the aligned rows, and its log, from the reference genotypes."""
+    from .genotypes import (Bed, ld_consistency_screen_genotypes,
+                            read_sample_list)
+    if not str(args.reference).endswith(".bim"):
+        raise ValueError("--ld-screen needs a PLINK 1 --reference (.bim with "
+                         ".bed and .fam beside it)")
+    samples = read_sample_list(args.ld_keep) if args.ld_keep else None
+    bed = Bed(args.reference, variants=ref, samples=samples)
+    options = {"rounds": args.ld_rounds, "threshold": args.ld_threshold}
+    keep, stats = ld_consistency_screen_genotypes(
+        bed, h.var_index, h.beta / h.se, max_block=args.ld_block_size,
+        seed=args.seed, return_stats=True, **options)
+    stats.update(options, n_reference_samples=bed.n_samples,
+                 max_block=args.ld_block_size, seed=args.seed)
+    print(f"allelign: LD screen dropped {stats['n_dropped']:,} of "
+          f"{stats['n_tested']:,} tested variants ({bed.n_samples:,} "
+          "reference samples)", file=sys.stderr)
+    return keep, stats
+
+
+def cmd_pgs_export(args):
+    from .weights import read_weights, write_pgs_scoring_file
+    wt = read_weights(args.weights, sd_source=args.sd_source)
+    write_pgs_scoring_file(args.out, wt, genome_build=args.genome_build,
+                           pgs_id=args.pgs_id, trait_reported=args.trait)
+    print(f"allelign: wrote {len(wt):,} variants -> {args.out}", file=sys.stderr)
+    return 0
+
+
+def cmd_download(args):
+    from .download import download_ref, read_keep_ids, resolve_ref
+    if args.dry_run:
+        plan = resolve_ref(args.ref, build=args.build)
+        print(json.dumps(plan, indent=2, sort_keys=True, default=str))
+        return 0
+    keep_ids = read_keep_ids(args.keep_ids) if args.keep_ids else None
+    record = download_ref(args.ref, args.out, build=args.build,
+                          keep_ids=keep_ids, meta=not args.no_meta)
+    kept = f", kept {record['n_kept']:,} of {record['n_input']:,} rows" \
+        if "n_kept" in record else ""
+    print(f"allelign: downloaded {record['label']} -> {args.out} "
+          f"({record['n_bytes_written']:,} bytes{kept})", file=sys.stderr)
+    return 0
+
+
+def _add_read_options(p):
+    p.add_argument("sumstats", help="summary-statistics file (.gz accepted)")
+    p.add_argument("--column", action="append", metavar="FIELD=COLUMN",
+                   help="force a field to a column (name or 0-based index)")
+    p.add_argument("--n-eff", type=float, default=None,
+                   help="constant effective N for every row")
+    p.add_argument("--n-cases", type=float, default=None)
+    p.add_argument("--n-controls", type=float, default=None)
+
+
+def _add_qc_options(p):
+    p.add_argument("--no-qc", action="store_true", help="skip file-level QC")
+    p.add_argument("--min-n-ratio", type=float, default=0.7)
+    p.add_argument("--min-maf", type=float, default=0.01)
+    p.add_argument("--min-info", type=float, default=0.7)
+    p.add_argument("--max-chisq", type=float, default=None)
+    p.add_argument("--keep-duplicates", action="store_true")
+    p.add_argument("--status-out", default=None,
+                   help="per-input-row status table (TSV, .gz accepted)")
+
+
+def _ld_default(name):
+    from . import ldcheck
+    return getattr(ldcheck, name)
+
+
+def build_parser():
+    ap = argparse.ArgumentParser(
+        prog="allelign",
+        description="Read, align and QC GWAS summary statistics and PGS weights.")
+    ap.add_argument("--version", action="version", version=f"allelign {__version__}")
+    sub = ap.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("inspect", help="show the detected column mapping")
+    _add_read_options(p)
+    p.set_defaults(func=cmd_inspect)
+
+    p = sub.add_parser("clean", help="parse, QC and write the canonical table")
+    _add_read_options(p)
+    _add_qc_options(p)
+    p.add_argument("-o", "--out", required=True)
+    p.set_defaults(func=cmd_clean)
+
+    p = sub.add_parser("align", help="parse, QC and align to a .bim/.pvar")
+    _add_read_options(p)
+    _add_qc_options(p)
+    p.add_argument("--reference", required=True, help=".bim or .pvar file")
+    p.add_argument("-o", "--out", required=True)
+    p.add_argument("--keep-ambiguous", action="store_true",
+                   help="keep strand-ambiguous (A/T, C/G) variants")
+    p.add_argument("--reanchor-on-identifier", action="store_true",
+                   help="take coordinates from the reference's rsIDs")
+    p.add_argument("--sumstats-build", default=None)
+    p.add_argument("--reference-build", default=None)
+    g = p.add_argument_group(
+        "LD-consistency screen",
+        "drop variants whose z-score disagrees with its neighbours' given the "
+        "reference LD. A reference of a few hundred samples flags more "
+        "variants than one of thousands; see docs/guide.md.")
+    g.add_argument("--ld-screen", action="store_true",
+                   help="screen with LD from the --reference .bed")
+    g.add_argument("--ld-keep", default=None, metavar="FILE",
+                   help="reference samples to use for LD (FID IID or IID per "
+                        "line), e.g. the one ancestry matching the GWAS")
+    g.add_argument("--ld-block-size", type=int, default=2000,
+                   help="maximum variants per LD block (default 2000)")
+    g.add_argument("--ld-rounds", type=int, default=_ld_default("DEFAULT_ROUNDS"))
+    g.add_argument("--ld-threshold", type=float,
+                   default=_ld_default("DEFAULT_THRESHOLD"),
+                   help="chi-square cut for an outlier")
+    g.add_argument("--seed", type=int, default=0)
+    p.set_defaults(func=cmd_align)
+
+    p = sub.add_parser("pgs-export",
+                       help="ldpred3 weights -> PGS Catalog scoring file")
+    p.add_argument("weights")
+    p.add_argument("-o", "--out", required=True)
+    p.add_argument("--genome-build", required=True, choices=("GRCh37", "GRCh38"))
+    p.add_argument("--pgs-id", default=None)
+    p.add_argument("--trait", default=None)
+    p.add_argument("--sd-source", choices=("empirical", "hwe"), default=None)
+    p.set_defaults(func=cmd_pgs_export)
+
+    p = sub.add_parser(
+        "download", help="fetch published sumstats or a PGS score by reference",
+        description="Resolve a source reference (GWAS Catalog GCST accession, "
+                    "FINNGEN:R11:I9_AF, COVIDHGI:R7:C2, GBMI:ASTHMA:EUR, "
+                    "EQTL:QTS000001:QTD000001:ENSG00000008128 or a PGS id) "
+                    "and download it with a <out>.meta.json provenance "
+                    "sidecar.")
+    p.add_argument("ref")
+    p.add_argument("-o", "--out", required=True)
+    p.add_argument("--build", choices=("GRCh37", "GRCh38"), default=None,
+                   help="preferred harmonised build for a PGS score "
+                        "(default GRCh37, then GRCh38, then the submitted "
+                        "file)")
+    p.add_argument("--keep-ids", default=None, metavar="FILE",
+                   help="rsID list, .bim or .pvar: stream only matching rows "
+                        "(comma-joined rsids match on any part)")
+    p.add_argument("--no-meta", action="store_true",
+                   help="do not write the <out>.meta.json sidecar")
+    p.add_argument("--dry-run", action="store_true",
+                   help="resolve and print the plan without downloading")
+    p.set_defaults(func=cmd_download)
+    return ap
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except (ValueError, OSError) as error:
+        print(f"allelign: error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())