tview 0.1.dev4__py3-none-any.whl

tview/__init__.py

@@ -0,0 +1,27 @@
+"""tview — Publication-quality alignment viewer."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+from tview.tview import (
+    Panel,
+    fasta_panel,
+    bam_panel,
+    read_fasta,
+    render_panels,
+    NT_COLORS,
+    AA_COLORS,
+)
+
+try:
+    __version__ = version("tview")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+__all__ = [
+    "Panel",
+    "fasta_panel",
+    "bam_panel",
+    "read_fasta",
+    "render_panels",
+    "NT_COLORS",
+    "AA_COLORS",
+]

tview/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.dev4'
+__version_tuple__ = version_tuple = (0, 1, 'dev4')
+
+__commit_id__ = commit_id = None

tview/cli.py

@@ -0,0 +1,61 @@
+"""Click CLI for tview."""
+
+import sys
+
+import click
+
+from tview.tview import bam_panel, fasta_panel, render_panels
+
+
+def _expand_stdin(paths: list[str]) -> list[str]:
+    """If paths is ['-'], read file paths from stdin (one per line)."""
+    if paths and len(paths) == 1 and paths[0] == "-":
+        return [line.strip() for line in sys.stdin if line.strip()]
+    return list(paths)
+
+
+@click.command(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    epilog="Use '-' to read file paths from stdin, e.g.:\n\n"
+           "  find . -name '*.fasta' | tview --fasta - --palette aa -o out.png",
+)
+@click.option("--bam", multiple=True, help="BAM file(s) — each becomes a panel. Use '-' for stdin.")
+@click.option("--ref", type=click.Path(exists=True), help="Reference FASTA (required for BAM mode).")
+@click.option("--region", help="Genomic region chr:start-end (required for BAM mode).")
+@click.option("--fasta", multiple=True, help="Aligned FASTA file(s) — each becomes a panel. Use '-' for stdin.")
+@click.option("--columns", help="Column range for FASTA, 1-based inclusive (e.g. 1-120).")
+@click.option("-o", "--output", default="alignment.png", show_default=True, help="Output image path.")
+@click.option("--palette", type=click.Choice(["nt", "aa"]), default="nt", show_default=True, help="Color palette.")
+@click.option("--dpi", type=int, default=300, show_default=True, help="Image resolution.")
+@click.option("--fontsize", type=int, default=7, show_default=True, help="Base font size in points.")
+@click.option("--cell", type=float, default=0.14, show_default=True, help="Cell size in inches.")
+def main(bam, ref, region, fasta, columns, output, palette, dpi, fontsize, cell):
+    """Publication-quality alignment viewer (BAM or FASTA).
+
+    Supports BAM files (with reference FASTA), pre-aligned FASTA (e.g. MAFFT
+    output), and stacking multiple inputs into a single figure.
+    """
+    bam_paths = _expand_stdin(list(bam))
+    fasta_paths = _expand_stdin(list(fasta))
+
+    if not bam_paths and not fasta_paths:
+        raise click.UsageError("Provide --bam and/or --fasta")
+
+    panels = []
+
+    if bam_paths:
+        if not ref or not region:
+            raise click.UsageError("--ref and --region are required for BAM input")
+        for bam_path in bam_paths:
+            panels.append(bam_panel(bam_path, ref, region))
+
+    if fasta_paths:
+        col_start, col_end = None, None
+        if columns:
+            parts = columns.replace(",", "").split("-")
+            col_start = int(parts[0])
+            col_end = int(parts[1]) if len(parts) > 1 else None
+        for fasta_path in fasta_paths:
+            panels.append(fasta_panel(fasta_path, col_start, col_end))
+
+    render_panels(panels, output, fontsize=fontsize, dpi=dpi, palette=palette, cell=cell)

tview/tview.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+tview_image.py — Publication-quality alignment viewer.
+
+Supports BAM files (with ref FASTA) and pre-aligned FASTA (e.g. MAFFT output).
+Multiple inputs can be stacked vertically in a single figure.
+
+Usage:
+  # Single BAM
+  python tview_image.py --bam sample.bam --ref ref.fa --region chr1:1-50 -o out.png
+
+  # Stacked BAMs (shared ref + region)
+  python tview_image.py --bam a.bam b.bam --ref ref.fa --region chr1:1-50 -o out.png
+
+  # Aligned FASTA (first sequence = reference)
+  python tview_image.py --fasta aligned.fasta -o out.png --palette aa
+
+  # Stacked FASTAs
+  python tview_image.py --fasta group1.fasta group2.fasta -o out.png --palette aa
+
+  # FASTA with column range (1-based, inclusive)
+  python tview_image.py --fasta aligned.fasta --columns 1-120 -o out.png
+
+  # Mix BAM and FASTA panels
+  python tview_image.py --bam a.bam --ref ref.fa --region chr1:1-50 --fasta aln.fasta -o out.png
+"""
+
+from __future__ import annotations
+
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.font_manager as fm
+
+# ── Color schemes ─────────────────────────────────────────────────
+NT_COLORS = {
+    "A": "#4CAF50", "C": "#2196F3", "G": "#FF9800", "T": "#F44336",
+    "N": "#9E9E9E", "-": "#9E9E9E",
+}
+AA_COLORS = {
+    "A": "#2196F3", "V": "#2196F3", "L": "#2196F3", "I": "#2196F3",
+    "M": "#2196F3", "F": "#2196F3", "W": "#2196F3", "P": "#2196F3",
+    "K": "#F44336", "R": "#F44336", "H": "#F44336",
+    "D": "#E040FB", "E": "#E040FB",
+    "S": "#4CAF50", "T": "#4CAF50", "N": "#4CAF50", "Q": "#4CAF50",
+    "G": "#FF9800", "C": "#FF9800", "Y": "#FF9800",
+    "*": "#9E9E9E", "-": "#9E9E9E", "X": "#9E9E9E",
+}
+MISMATCH_BG = "#FFEB3B55"
+INS_BG      = "#CE93D833"
+GAP_COLOR   = "#9E9E9E"
+FWD_ALPHA   = 1.0
+REV_ALPHA   = 0.55
+SEPARATOR_COLOR = "#BDBDBD"
+
+
+# ═════════════════════════════════════════════════════════════════
+#  Data structures — each input becomes a Panel
+# ═════════════════════════════════════════════════════════════════
+class Panel:
+    """One horizontal alignment block: a reference row + read/sequence rows."""
+    def __init__(self, label, ref_row, seq_rows, total_cols, col_labels,
+                 ins_columns=None):
+        self.label     = label          # panel title
+        self.ref_row   = ref_row        # list[str] length = total_cols
+        self.seq_rows  = seq_rows       # list[(name, list[str], is_reverse)]
+        self.total_cols = total_cols
+        self.col_labels = col_labels    # list[(col_idx, label_str)] for x-ticks
+        self.ins_columns = ins_columns or set()  # set of col indices that are insertion cols
+
+
+# ═════════════════════════════════════════════════════════════════
+#  FASTA panel builder
+# ═════════════════════════════════════════════════════════════════
+def read_fasta(path):
+    """Parse FASTA → list[(name, sequence)]."""
+    seqs = []
+    name, buf = None, []
+    for line in open(path):
+        if line.startswith(">"):
+            if name is not None:
+                seqs.append((name, "".join(buf)))
+            name = line[1:].strip()
+            buf = []
+        else:
+            buf.append(line.strip())
+    if name is not None:
+        seqs.append((name, "".join(buf)))
+    return seqs
+
+
+def fasta_panel(path, col_start=None, col_end=None) -> Panel:
+    """
+    Build a Panel from an aligned FASTA. First sequence = reference.
+    col_start / col_end are 1-based inclusive column indices into the
+    alignment (after MAFFT gaps).
+    """
+    seqs = read_fasta(path)
+    if not seqs:
+        raise ValueError(f"No sequences in {path}")
+
+    ref_name, ref_seq = seqs[0]
+
+    # Slice columns if requested (1-based inclusive)
+    if col_start is not None or col_end is not None:
+        cs = (col_start or 1) - 1
+        ce = col_end or len(ref_seq)
+        ref_seq = ref_seq[cs:ce]
+        seqs = [(n, s[cs:ce]) for n, s in seqs]
+    else:
+        cs = 0
+
+    aln_len = len(ref_seq)
+    ref_row = list(ref_seq.upper())
+
+    seq_rows = []
+    for name, seq in seqs[1:]:
+        row = list(seq.upper()[:aln_len])
+        # Pad if shorter
+        row += ["-"] * (aln_len - len(row))
+        seq_rows.append((name, row, False))
+
+    # Column labels: 1-based position in the reference (skip gap columns)
+    # Count non-gap ref positions for labeling
+    col_labels = []
+    ref_pos = 0
+    for i, base in enumerate(ref_row):
+        if base != "-":
+            ref_pos += 1
+            if ref_pos == 1 or ref_pos % 10 == 0:
+                col_labels.append((i, str(ref_pos)))
+
+    label = Path(path).stem
+    return Panel(label, ref_row, seq_rows, aln_len, col_labels)
+
+
+# ═════════════════════════════════════════════════════════════════
+#  BAM panel builder
+# ═════════════════════════════════════════════════════════════════
+def build_read_row(read, ref_start, ref_end):
+    aligned = {}
+    inserts = defaultdict(list)
+    qpos, rpos = 0, read.reference_start
+    for op, length in read.cigartuples:
+        if op in (0, 7, 8):
+            for _ in range(length):
+                if ref_start <= rpos < ref_end:
+                    aligned[rpos] = read.query_sequence[qpos].upper()
+                qpos += 1; rpos += 1
+        elif op == 1:
+            anchor = rpos - 1
+            if ref_start <= anchor < ref_end:
+                for j in range(length):
+                    inserts[anchor].append(read.query_sequence[qpos + j].upper())
+            qpos += length
+        elif op == 2:
+            for _ in range(length):
+                if ref_start <= rpos < ref_end:
+                    aligned[rpos] = "-"
+                rpos += 1
+        elif op == 3:
+            rpos += length
+        elif op == 4:
+            qpos += length
+    return aligned, inserts
+
+
+def bam_panel(bam_path, ref_path, region) -> Panel:
+    import pysam
+
+    chrom, rest = region.split(":")
+    start, end = [int(x) for x in rest.replace(",", "").split("-")]
+
+    fasta = pysam.FastaFile(ref_path)
+    ref_seq = fasta.fetch(chrom, start, end).upper()
+    fasta.close()
+
+    samfile = pysam.AlignmentFile(bam_path, "rb")
+    reads = [r for r in samfile.fetch(chrom, start, end)
+             if not r.is_unmapped and r.cigartuples]
+    samfile.close()
+    reads.sort(key=lambda r: (r.reference_start, r.is_reverse))
+
+    # Find max insertion at each ref position
+    max_ins = defaultdict(int)
+    read_data = []
+    for read in reads:
+        aligned, inserts = build_read_row(read, start, end)
+        read_data.append((read, aligned, inserts))
+        for rpos, bases in inserts.items():
+            max_ins[rpos] = max(max_ins[rpos], len(bases))
+
+    # Build column map
+    col_map = {}
+    ins_col_set = set()
+    col = 0
+    for rpos in range(start, end):
+        col_map[rpos] = col
+        col += 1
+        n_ins = max_ins.get(rpos, 0)
+        for j in range(n_ins):
+            ins_col_set.add(col + j)
+        col += n_ins
+    total_cols = col
+
+    # Build ref row with '-' in insertion columns
+    ref_row = []
+    for rpos in range(start, end):
+        ref_row.append(ref_seq[rpos - start])
+        for _ in range(max_ins.get(rpos, 0)):
+            ref_row.append("-")
+
+    # Build sequence rows
+    seq_rows = []
+    for read, aligned, inserts in read_data:
+        row = [" "] * total_cols
+        for rpos in range(start, end):
+            c = col_map[rpos]
+            if rpos in aligned:
+                row[c] = aligned[rpos]
+            if rpos in aligned or rpos in inserts:
+                n_ins = max_ins.get(rpos, 0)
+                read_ins = inserts.get(rpos, [])
+                for j in range(n_ins):
+                    if j < len(read_ins):
+                        row[c + 1 + j] = read_ins[j]
+                    else:
+                        row[c + 1 + j] = "-"
+        seq_rows.append((read.query_name, row, read.is_reverse))
+
+    # Column labels: 1-based relative, ticks at 1, 10, 20…
+    ref_width = end - start
+    tick_1based = [1] + list(range(10, ref_width + 1, 10))
+    col_labels = [(col_map[start + p - 1], str(p))
+                  for p in tick_1based if (start + p - 1) < end]
+
+    label = Path(bam_path).stem
+    return Panel(label, ref_row, seq_rows, total_cols, col_labels, ins_col_set)
+
+
+# ═════════════════════════════════════════════════════════════════
+#  Renderer
+# ═════════════════════════════════════════════════════════════════
+def render_panels(panels, out_path="alignment.png", fontsize=7, dpi=300,
+                  palette="nt", cell=0.14):
+    colors = AA_COLORS if palette == "aa" else NT_COLORS
+    mono = fm.FontProperties(family="monospace", size=fontsize)
+    mono_sm = fm.FontProperties(family="monospace", size=fontsize - 1)
+    sans_sm = {"fontsize": fontsize - 1, "fontfamily": "sans-serif"}
+
+    # Compute total height: for each panel, 1 ref row + N seq rows + 0.6 separator
+    max_cols = max(p.total_cols for p in panels)
+    total_rows = 0
+    panel_y_offsets = []
+    for i, p in enumerate(panels):
+        panel_y_offsets.append(total_rows)
+        total_rows += 1 + len(p.seq_rows)  # ref + seqs
+        if i < len(panels) - 1:
+            total_rows += 1  # separator gap
+
+    fig_w = max(4, max_cols * cell + 0.5)
+    fig_h = max(1.0, total_rows * cell + 0.6)
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h))
+    ax.set_xlim(-0.5, max_cols - 0.5)
+    ax.set_ylim(total_rows - 0.5, -0.5)
+    ax.set_aspect("equal")
+
+    for pi, panel in enumerate(panels):
+        y0 = panel_y_offsets[pi]
+
+        # ── Shade insertion columns ───────────────────────────────
+        n_panel_rows = 1 + len(panel.seq_rows)
+        for ic in panel.ins_columns:
+            ax.add_patch(plt.Rectangle(
+                (ic - 0.5, y0 - 0.5), 1, n_panel_rows,
+                facecolor=INS_BG, edgecolor="none", zorder=0))
+
+        # ── Reference row ─────────────────────────────────────────
+        for c, base in enumerate(panel.ref_row):
+            clr = GAP_COLOR if base == "-" else colors.get(base, "#9E9E9E")
+            ax.text(c, y0, base, ha="center", va="center",
+                    fontproperties=mono, color=clr, fontweight="bold")
+
+        # ── Sequence rows ─────────────────────────────────────────
+        for ri, (name, row, is_rev) in enumerate(panel.seq_rows):
+            y = y0 + 1 + ri
+            alpha = REV_ALPHA if is_rev else FWD_ALPHA
+            strand_char = "," if is_rev else "."
+
+            for c, base in enumerate(row):
+                if base == " ":
+                    continue
+                ref_base = panel.ref_row[c] if c < len(panel.ref_row) else "-"
+
+                if base == "-":
+                    ax.text(c, y, "-", ha="center", va="center",
+                            fontproperties=mono, color=GAP_COLOR, alpha=alpha)
+                elif base == ref_base:
+                    ax.text(c, y, strand_char, ha="center", va="center",
+                            fontproperties=mono_sm, color="#BDBDBD", alpha=alpha)
+                else:
+                    ax.add_patch(plt.Rectangle((c - 0.5, y - 0.5), 1, 1,
+                                               facecolor=MISMATCH_BG,
+                                               edgecolor="none"))
+                    display = base.lower() if is_rev else base
+                    ax.text(c, y, display, ha="center", va="center",
+                            fontproperties=mono,
+                            color=colors.get(base, "#000000"),
+                            fontweight="bold", alpha=alpha)
+
+        # ── Panel label (left side) ───────────────────────────────
+        if len(panels) > 1:
+            ax.text(-1.5, y0 + n_panel_rows / 2 - 0.5, panel.label,
+                    ha="right", va="center", fontsize=fontsize,
+                    fontfamily="sans-serif", fontstyle="italic",
+                    color="#616161")
+
+        # ── Separator line between panels ─────────────────────────
+        if pi < len(panels) - 1:
+            sep_y = y0 + n_panel_rows + 0.0
+            ax.axhline(y=sep_y, color=SEPARATOR_COLOR, lw=0.5, ls="-",
+                       xmin=0, xmax=1)
+
+    # ── X-axis from first panel, placed on top ────────────────────
+    ax.xaxis.set_label_position("top")
+    ax.xaxis.tick_top()
+    first = panels[0]
+    tick_idx = [ci for ci, _ in first.col_labels]
+    tick_lbl = [lb for _, lb in first.col_labels]
+    ax.set_xticks(tick_idx)
+    ax.set_xticklabels(tick_lbl, rotation=0, ha="center", **sans_sm)
+    ax.set_yticks([])
+    ax.tick_params(axis="x", length=0, pad=2)
+    ax.tick_params(axis="y", length=0)
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+
+    plt.subplots_adjust(left=0.01, right=0.99, top=0.92, bottom=0.01)
+    plt.savefig(out_path, dpi=dpi, bbox_inches="tight", pad_inches=0.05,
+                facecolor="white", transparent=False)
+    plt.close()
+    print(f"Saved: {out_path} ({dpi} dpi, {len(panels)} panel(s), "
+          f"{max_cols} cols)")
+
+
+if __name__ == "__main__":
+    from tview.cli import main
+    main()

tview-0.1.dev4.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: tview
+Version: 0.1.dev4
+Summary: Publication-quality alignment viewer for nucleotide and amino acid sequences
+Author-email: Troy Sincomb <troysincomb@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MurrellGroup/tview
+Project-URL: Repository, https://github.com/MurrellGroup/tview
+Project-URL: Issues, https://github.com/MurrellGroup/tview/issues
+Keywords: bioinformatics,alignment,samtools,tview,visualization,BAM,FASTA
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: click>=8.0
+Requires-Dist: pysam>=0.20; sys_platform != "win32"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: hypothesis>=6.0; extra == "dev"
+Dynamic: license-file
+
+# tview
+
+Publication-quality alignment viewer for nucleotide and amino acid sequences. A lightweight alternative to `samtools tview` that produces clean, stable image output.
+
+Supports **BAM files** (with reference FASTA), **pre-aligned FASTA** (e.g. MAFFT output), and **stacking** multiple inputs into a single figure.
+
+![BAM with indels](examples/indel_alignment.png)
+*BAM mode — SNP (yellow), 3bp deletion, 2bp insertion (purple columns), reverse-strand insertion*
+
+![FASTA amino acid alignment](examples/fasta_env_1-120.png)
+*FASTA mode — HIV Env protein alignment (HxB2 reference), amino acid palette*
+
+![Stacked BAMs](examples/stacked_bam.png)
+*Stacked mode — two BAM files sharing a reference and region*
+
+---
+
+## Installation
+
+```bash
+pip install tview
+```
+
+Installs `matplotlib`, `click`, and `pysam`.
+
+---
+
+## Quick Start
+
+### BAM file
+
+```bash
+tview \
+  --bam aligned.bam \
+  --ref reference.fa \
+  --region chr1:100-200 \
+  -o alignment.png
+```
+
+### Aligned FASTA (e.g. MAFFT output)
+
+The first sequence in the file is treated as the reference.
+
+```bash
+tview \
+  --fasta env_protein_aligned.fasta \
+  --palette aa \
+  -o env_alignment.png
+```
+
+### Subset columns from a FASTA alignment
+
+Use `--columns` with 1-based inclusive range to window into long alignments.
+
+```bash
+tview \
+  --fasta aligned.fasta \
+  --columns 1-120 \
+  --palette aa \
+  -o first_120_cols.png
+```
+
+---
+
+## Stacking Multiple Panels
+
+Each input file becomes a vertically stacked panel separated by a thin line. Panels are labeled on the left with the filename stem.
+
+### Multiple BAMs (shared reference and region)
+
+```bash
+tview \
+  --bam sample1.bam --bam sample2.bam --bam sample3.bam \
+  --ref reference.fa \
+  --region chr1:100-200 \
+  -o stacked.png
+```
+
+### Multiple FASTAs
+
+```bash
+tview \
+  --fasta group1_aligned.fasta --fasta group2_aligned.fasta \
+  --palette aa \
+  --columns 1-120 \
+  -o comparison.png
+```
+
+### Mix BAM and FASTA panels
+
+`--ref` and `--region` apply only to BAM panels; `--columns` applies only to FASTA panels.
+
+```bash
+tview \
+  --bam reads.bam \
+  --ref reference.fa \
+  --region chr1:100-200 \
+  --fasta protein_aligned.fasta \
+  --columns 1-120 \
+  -o mixed.png
+```
+
+BAM panels are rendered first (top), FASTA panels below.
+
+---
+
+## Piping from stdin
+
+Pass `-` to read file paths from stdin (one per line). Each path becomes its own panel.
+
+```bash
+# find → stacked panels
+find ./alignments -name "*.fasta" -type f | \
+  tview --fasta - --palette aa --columns 1-120 -o all.png
+
+# ls with pattern
+ls samples/*.bam | \
+  tview --bam - --ref ref.fa --region chr1:100-200 -o all_samples.png
+
+# single file via echo
+echo "my_alignment.fasta" | \
+  tview --fasta - --palette aa -o out.png
+```
+
+---
+
+## Python API
+
+The core functions are available as a Python library:
+
+```python
+from tview import fasta_panel, bam_panel, render_panels
+
+# FASTA alignment
+panel = fasta_panel("aligned.fasta", col_start=1, col_end=120)
+render_panels([panel], "output.png", palette="aa")
+
+# BAM alignment
+panel = bam_panel("sample.bam", "reference.fa", "chr1:100-200")
+render_panels([panel], "output.png")
+
+# Stack multiple panels
+panels = [
+    bam_panel("sample1.bam", "ref.fa", "chr1:100-200"),
+    bam_panel("sample2.bam", "ref.fa", "chr1:100-200"),
+]
+render_panels(panels, "stacked.png", dpi=300, fontsize=7, cell=0.14)
+```
+
+---
+
+## Visual Conventions
+
+| Element | Symbol | Style |
+|---------|--------|-------|
+| Match (forward) | `.` | light grey |
+| Match (reverse) | `,` | light grey, reduced opacity |
+| Mismatch | `A` `T` etc. | colored, yellow highlight, bold |
+| Mismatch (reverse) | `a` `t` etc. | lowercase, colored, yellow highlight |
+| Deletion | `-` | grey dash |
+| Insertion | colored bases | purple column shading |
+| Gap (ref in insertion col) | `-` | grey dash |
+| Gap (FASTA alignment) | `-` | grey dash |
+
+---
+
+## Color Palettes
+
+### `--palette nt` (default) — Nucleotides
+
+| Base | Color |
+|------|-------|
+| A | green `#4CAF50` |
+| C | blue `#2196F3` |
+| G | orange `#FF9800` |
+| T | red `#F44336` |
+
+### `--palette aa` — Amino Acids (Clustal-inspired)
+
+| Group | Residues | Color |
+|-------|----------|-------|
+| Hydrophobic | A V L I M F W P | blue `#2196F3` |
+| Positive charge | K R H | red `#F44336` |
+| Negative charge | D E | magenta `#E040FB` |
+| Polar uncharged | S T N Q | green `#4CAF50` |
+| Special | G C Y | orange `#FF9800` |
+
+---
+
+## Full Argument Reference
+
+```
+Usage: tview [OPTIONS]
+
+  Publication-quality alignment viewer (BAM or FASTA).
+
+Options:
+  --bam TEXT              BAM file(s) — each becomes a panel. Use '-' for stdin.
+  --ref PATH              Reference FASTA (required for BAM mode).
+  --region TEXT            Genomic region chr:start-end (required for BAM mode).
+  --fasta TEXT             Aligned FASTA file(s) — each becomes a panel. Use '-' for stdin.
+  --columns TEXT           Column range for FASTA, 1-based inclusive (e.g. 1-120).
+  -o, --output TEXT        Output image path.  [default: alignment.png]
+  --palette [nt|aa]        Color palette.  [default: nt]
+  --dpi INTEGER            Image resolution.  [default: 300]
+  --fontsize INTEGER       Base font size in points.  [default: 7]
+  --cell FLOAT             Cell size in inches.  [default: 0.14]
+  -h, --help               Show this message and exit.
+```
+
+| Argument | Description | Default |
+|----------|-------------|---------|
+| `--bam` | BAM file(s), each becomes a panel. Use `-` for stdin. | — |
+| `--ref` | Reference FASTA (required for BAM mode) | — |
+| `--region` | Genomic region `chr:start-end` (required for BAM) | — |
+| `--fasta` | Aligned FASTA file(s), each becomes a panel. Use `-` for stdin. | — |
+| `--columns` | Column range for FASTA, 1-based inclusive (e.g. `1-120`) | full alignment |
+| `-o, --output` | Output image path | `alignment.png` |
+| `--palette` | Color palette: `nt` or `aa` | `nt` |
+| `--dpi` | Image resolution | `300` |
+| `--fontsize` | Base font size in points | `7` |
+| `--cell` | Cell size in inches (controls spacing) | `0.14` |
+
+---
+
+## Tips for Publication Figures
+
+- Use `--dpi 300` (default) for print, `--dpi 150` for drafts.
+- Use `--cell 0.10` for denser layouts with many sequences, `--cell 0.18` for fewer.
+- Use `--fontsize 5` or `6` when displaying wide alignments (>100 columns).
+- The output format is determined by the file extension: `.png`, `.pdf`, `.svg` all work.
+- For Nature-style figures, `.pdf` or `.svg` output preserves vector text.
+
+```bash
+# Vector output for publication
+tview \
+  --fasta aligned.fasta \
+  --palette aa \
+  --columns 1-120 \
+  --cell 0.12 \
+  --fontsize 6 \
+  -o figure_2a.pdf
+```
+
+---
+
+## FASTA Input Format
+
+The FASTA input must be **pre-aligned** (e.g. by MAFFT, MUSCLE, Clustal). The first sequence is used as the reference for comparison. Gap characters (`-`) in the alignment are preserved and rendered as grey dashes.
+
+```
+>HxB2_reference
+MRVK---EKYQHLWRWGWRWGTMLLGMLMICS...
+>sample_001
+MRVKGIRKNAQHL----WRGGTLLLGMLMICS...
+>sample_002
+--------------------------MLMICS...
+```
+
+The x-axis labels count non-gap positions in the reference sequence (1, 10, 20, ...), so position numbers always correspond to the reference residue numbering regardless of gap columns.

tview-0.1.dev4.dist-info/RECORD

@@ -0,0 +1,10 @@
+tview/__init__.py,sha256=m12Gy5pG-H4LN7v6-NqJztUCNos3IB9SPGDG7xphDZU,485
+tview/_version.py,sha256=CCBWn0dt9vGR2xCuvN0-pJiL_EfW8sCq3mWcvm7dyfA,712
+tview/cli.py,sha256=B5vFIHqvA6E9-P1_gjyHQVN_SfDdGC95mrhOrH2gwDE,2792
+tview/tview.py,sha256=cY4PTjrg_FJDwmwVx_R7ZCWOa3XCIvgMY4iNwAOZ-6I,14511
+tview-0.1.dev4.dist-info/licenses/LICENSE,sha256=PRvBVRcqmEyg2k5TekU4LBP_BQTdVALzv5F12ofRXbE,1069
+tview-0.1.dev4.dist-info/METADATA,sha256=NG0vZCYVU14vA4VJpW6zVJzOqjaLXmzEuT68D0mEHh0,8610
+tview-0.1.dev4.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+tview-0.1.dev4.dist-info/entry_points.txt,sha256=HhRjQleNNn0kcsGQlz4SJKCDUdleTr1TYZGO4VGNnj0,41
+tview-0.1.dev4.dist-info/top_level.txt,sha256=hgiJ_IUu49L4gILDZLAQB0d2APmCCSGsLfGoganQZ4Y,6
+tview-0.1.dev4.dist-info/RECORD,,

tview-0.1.dev4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tview-0.1.dev4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tview = tview.cli:main

tview-0.1.dev4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Troy Sincomb
+
+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.

tview-0.1.dev4.dist-info/top_level.txt

@@ -0,0 +1 @@
+tview