njswalig 0.1.0__tar.gz

njswalig-0.1.0/.gitignore

@@ -0,0 +1 @@
+dist/

njswalig-0.1.0/LICENSE

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

njswalig-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: njswalig
+Version: 0.1.0
+Summary: Needleman-Wunsch and Smith-Waterman pairwise sequence alignment, with the DP table
+Project-URL: Homepage, https://github.com/jphil101/BioinfoPrep/tree/main/njswalig
+Project-URL: Source, https://github.com/jphil101/BioinfoPrep/tree/main/njswalig
+Project-URL: Issues, https://github.com/jphil101/BioinfoPrep/issues
+Author: jphil101
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bioinformatics,dynamic programming,needleman-wunsch,sequence alignment,smith-waterman
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: biopython; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# njswalig
+
+Needleman–Wunsch (global) and Smith–Waterman (local) pairwise sequence alignment in plain Python,
+with no dependencies. It prints the alignment and, if you ask, the filled-in dynamic-programming score
+table.
+
+```bash
+pip install njswalig
+```
+
+## Usage
+
+```python
+from njswalig import njalign      # Needleman-Wunsch (global)
+from njswalig import swalign      # Smith-Waterman (local)
+
+seqs = ["ATCG", "TTTA"]           # any number of sequences, any lengths
+scores = [2, -1, -2]              # [match, mismatch, gap] -- always this order
+
+alignment = njalign.sequences(seqs, scores)   # or njalign.sequence(...) -- same thing
+alignment.show()
+```
+
+```
+Needleman-Wunsch (global): Seq1 vs Seq2, score = -1
+Seq1  ATCG
+      .|..
+Seq2  TTTA
+```
+
+`|` marks a match, `.` a mismatch and a space a gap.
+
+### Smith–Waterman
+
+```python
+swalign.sequences(["TGTTACGG", "GGTTGACTA"], [3, -3, -2]).show()
+```
+
+```
+Smith-Waterman (local): Seq1 vs Seq2, score = 13
+Seq1  2 GTT-AC 6
+        ||| ||
+Seq2  2 GTTGAC 7
+```
+
+The numbers show where the aligned region starts and ends in each sequence (1-based).
+
+### More than two sequences
+
+Every pair is aligned. Sequences are named `Seq1`, `Seq2`, … in list order, or pass your own:
+
+```python
+njalign.sequences(["GATTACA", "GCATGCU", "GATCA"], [1, -1, -1], names=["a", "b", "c"]).show()
+```
+
+### The DP score table
+
+```python
+swalign.sequences(["ATCG", "TTTA"], [2, -1, -2]).show(matrix=True)
+```
+
+```
+  - T T T A
+- 0 0 0 0 0
+A 0 0 0 0 2
+T 0 2 2 2 0
+C 0 0 1 1 1
+G 0 0 0 0 0
+```
+
+### Using the results in code
+
+`sequences(...)` returns a list of pair alignments. Each has `score`, `aligned1`, `aligned2`,
+`match_line`, `name1`, `name2`, `seq1`, `seq2`, `matrix` (the DP table as a list of lists) and
+1-based `start1`, `end1`, `start2`, `end2`.
+
+```python
+best = njalign.sequences(["GATTACA", "GCATGCU"], [1, -1, -1])[0]
+print(best.score, best.aligned1, best.aligned2)     # 0 G-ATTACA GCA-TGCU
+```
+
+## Details
+
+- **Scoring** is linear: every gap position costs `gap`. `scores` must be a list of exactly three
+  numbers, `[match, mismatch, gap]`; anything else raises `ValueError`.
+- **Sequences** are stripped of surrounding spaces and upper-cased, so `"acgt "` equals `"ACGT"`.
+- **Ties:** when several alignments share the best score, one is returned. The traceback prefers a
+  diagonal step (match/mismatch), then a gap in the second sequence, then a gap in the first. Smith–Waterman
+  starts from the first highest cell, scanning row by row.
+- **No local match:** when nothing scores above 0, Smith–Waterman reports an empty alignment with score 0.
+
+## License
+
+MIT

njswalig-0.1.0/README.md

@@ -0,0 +1,94 @@
+# njswalig
+
+Needleman–Wunsch (global) and Smith–Waterman (local) pairwise sequence alignment in plain Python,
+with no dependencies. It prints the alignment and, if you ask, the filled-in dynamic-programming score
+table.
+
+```bash
+pip install njswalig
+```
+
+## Usage
+
+```python
+from njswalig import njalign      # Needleman-Wunsch (global)
+from njswalig import swalign      # Smith-Waterman (local)
+
+seqs = ["ATCG", "TTTA"]           # any number of sequences, any lengths
+scores = [2, -1, -2]              # [match, mismatch, gap] -- always this order
+
+alignment = njalign.sequences(seqs, scores)   # or njalign.sequence(...) -- same thing
+alignment.show()
+```
+
+```
+Needleman-Wunsch (global): Seq1 vs Seq2, score = -1
+Seq1  ATCG
+      .|..
+Seq2  TTTA
+```
+
+`|` marks a match, `.` a mismatch and a space a gap.
+
+### Smith–Waterman
+
+```python
+swalign.sequences(["TGTTACGG", "GGTTGACTA"], [3, -3, -2]).show()
+```
+
+```
+Smith-Waterman (local): Seq1 vs Seq2, score = 13
+Seq1  2 GTT-AC 6
+        ||| ||
+Seq2  2 GTTGAC 7
+```
+
+The numbers show where the aligned region starts and ends in each sequence (1-based).
+
+### More than two sequences
+
+Every pair is aligned. Sequences are named `Seq1`, `Seq2`, … in list order, or pass your own:
+
+```python
+njalign.sequences(["GATTACA", "GCATGCU", "GATCA"], [1, -1, -1], names=["a", "b", "c"]).show()
+```
+
+### The DP score table
+
+```python
+swalign.sequences(["ATCG", "TTTA"], [2, -1, -2]).show(matrix=True)
+```
+
+```
+  - T T T A
+- 0 0 0 0 0
+A 0 0 0 0 2
+T 0 2 2 2 0
+C 0 0 1 1 1
+G 0 0 0 0 0
+```
+
+### Using the results in code
+
+`sequences(...)` returns a list of pair alignments. Each has `score`, `aligned1`, `aligned2`,
+`match_line`, `name1`, `name2`, `seq1`, `seq2`, `matrix` (the DP table as a list of lists) and
+1-based `start1`, `end1`, `start2`, `end2`.
+
+```python
+best = njalign.sequences(["GATTACA", "GCATGCU"], [1, -1, -1])[0]
+print(best.score, best.aligned1, best.aligned2)     # 0 G-ATTACA GCA-TGCU
+```
+
+## Details
+
+- **Scoring** is linear: every gap position costs `gap`. `scores` must be a list of exactly three
+  numbers, `[match, mismatch, gap]`; anything else raises `ValueError`.
+- **Sequences** are stripped of surrounding spaces and upper-cased, so `"acgt "` equals `"ACGT"`.
+- **Ties:** when several alignments share the best score, one is returned. The traceback prefers a
+  diagonal step (match/mismatch), then a gap in the second sequence, then a gap in the first. Smith–Waterman
+  starts from the first highest cell, scanning row by row.
+- **No local match:** when nothing scores above 0, Smith–Waterman reports an empty alignment with score 0.
+
+## License
+
+MIT

njswalig-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "njswalig"
+dynamic = ["version"]
+description = "Needleman-Wunsch and Smith-Waterman pairwise sequence alignment, with the DP table"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+authors = [{ name = "jphil101" }]
+keywords = ["sequence alignment", "needleman-wunsch", "smith-waterman", "dynamic programming", "bioinformatics"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest", "biopython"]
+
+[project.urls]
+Homepage = "https://github.com/jphil101/BioinfoPrep/tree/main/njswalig"
+Source = "https://github.com/jphil101/BioinfoPrep/tree/main/njswalig"
+Issues = "https://github.com/jphil101/BioinfoPrep/issues"
+
+[tool.hatch.version]
+path = "src/njswalig/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE"]

njswalig-0.1.0/src/njswalig/__init__.py

@@ -0,0 +1,186 @@
+"""njswalig -- Needleman-Wunsch (global) and Smith-Waterman (local) pairwise alignment.
+
+    >>> from njswalig import njalign, swalign
+    >>> seqs = ["ATCG", "TTTA"]
+    >>> scores = [2, -1, -2]                 # [match, mismatch, gap]
+    >>> alignment = njalign.sequences(seqs, scores)
+    >>> alignment.show()
+    Needleman-Wunsch (global): Seq1 vs Seq2, score = -1
+    Seq1  ATCG
+          .|..
+    Seq2  TTTA
+
+Every pair of sequences in the list is aligned. ``sequence`` is the same as ``sequences``.
+Scoring is linear: each gap position costs ``gap``.
+"""
+
+from itertools import combinations
+
+__all__ = ["njalign", "swalign", "Aligner", "Alignments", "PairAlignment"]
+__version__ = "0.1.0"
+
+_MODES = {"global": "Needleman-Wunsch (global)", "local": "Smith-Waterman (local)"}
+
+
+class PairAlignment:
+    """The best alignment of one pair of sequences.
+
+    Attributes: ``name1``, ``name2``, ``seq1``, ``seq2``, ``aligned1``, ``aligned2`` (with ``-``
+    for gaps), ``score``, ``mode`` ("global"/"local"), ``matrix`` (the filled DP score table,
+    ``len(seq1)+1`` rows by ``len(seq2)+1`` columns), and 1-based ``start1``/``end1``,
+    ``start2``/``end2`` giving the aligned region of each sequence.
+    """
+
+    def __init__(self, mode, name1, name2, seq1, seq2, aligned1, aligned2, score, matrix, start, end):
+        self.mode, self.name1, self.name2, self.seq1, self.seq2 = mode, name1, name2, seq1, seq2
+        self.aligned1, self.aligned2, self.score, self.matrix = aligned1, aligned2, score, matrix
+        self.start1, self.start2 = start[0] + 1, start[1] + 1
+        self.end1, self.end2 = end
+
+    @property
+    def match_line(self):
+        """``|`` match, ``.`` mismatch, space for a gap."""
+        return "".join(" " if "-" in (x, y) else "|" if x == y else "." for x, y in zip(self.aligned1, self.aligned2))
+
+    def __str__(self):
+        lines = [f"{_MODES[self.mode]}: {self.name1} vs {self.name2}, score = {_num(self.score)}"]
+        if not self.aligned1:
+            return lines[0] + "\n(no positive-scoring local alignment)"
+        w = max(len(self.name1), len(self.name2))
+        if self.mode == "global":
+            lines += [f"{self.name1:<{w}}  {self.aligned1}",
+                      f"{'':<{w}}  {self.match_line}",
+                      f"{self.name2:<{w}}  {self.aligned2}"]
+        else:                                          # local: show where the region sits in each sequence
+            p = len(str(max(self.start1, self.start2)))
+            lines += [f"{self.name1:<{w}}  {self.start1:>{p}} {self.aligned1} {self.end1}",
+                      f"{'':<{w}}  {'':>{p}} {self.match_line}",
+                      f"{self.name2:<{w}}  {self.start2:>{p}} {self.aligned2} {self.end2}"]
+        return "\n".join(lines)
+
+    def matrix_str(self):
+        """The DP score table with sequence letters along the edges."""
+        cells = [[_num(v) for v in row] for row in self.matrix]
+        w = max(len(c) for row in cells for c in row)
+        head = "  " + " ".join(f"{c:>{w}}" for c in "-" + self.seq2)
+        return "\n".join([head] + [f"{r} " + " ".join(f"{c:>{w}}" for c in row)
+                                   for r, row in zip("-" + self.seq1, cells)])
+
+    def show(self, matrix=False):
+        """Print the alignment (and the DP score table if ``matrix=True``)."""
+        print(self)
+        if matrix:
+            print(self.matrix_str())
+
+    def __repr__(self):
+        return f"<PairAlignment {self.mode} {self.name1} vs {self.name2} score={_num(self.score)}>"
+
+
+class Alignments(list):
+    """A list of :class:`PairAlignment`, one per pair of input sequences."""
+
+    def show(self, matrix=False):
+        """Print every alignment (and DP score tables if ``matrix=True``), separated by blank lines."""
+        for i, pair in enumerate(self):
+            if i:
+                print()
+            pair.show(matrix=matrix)
+
+    def __str__(self):
+        return "\n\n".join(map(str, self))
+
+
+class Aligner:
+    """``Aligner("global")`` is Needleman-Wunsch; ``Aligner("local")`` is Smith-Waterman."""
+
+    def __init__(self, mode):
+        if mode not in _MODES:
+            raise ValueError(f"mode must be 'global' or 'local', got {mode!r}")
+        self.mode = mode
+
+    def sequences(self, seqs, scores, names=None):
+        """Align every pair in ``seqs`` using ``scores = [match, mismatch, gap]``.
+
+        Sequences are upper-cased and stripped of surrounding whitespace. Names default to
+        Seq1, Seq2, ... in list order. Returns :class:`Alignments` (call ``.show()`` to print).
+        """
+        seqs, names = _check_seqs(seqs, names)
+        match, mismatch, gap = _check_scores(scores)
+        return Alignments(_align(self.mode, names[i], names[j], seqs[i], seqs[j], match, mismatch, gap)
+                          for i, j in combinations(range(len(seqs)), 2))
+
+    sequence = sequences                               # same thing, either name works
+
+    def __repr__(self):
+        return f"<Aligner {_MODES[self.mode]}>"
+
+
+njalign = Aligner("global")
+swalign = Aligner("local")
+
+
+def _align(mode, name1, name2, a, b, match, mismatch, gap):
+    local = mode == "local"
+    n, m = len(a), len(b)
+    S = [[0] * (m + 1) for _ in range(n + 1)]
+    if not local:                                      # global: leading gaps cost gap each
+        for i in range(1, n + 1):
+            S[i][0] = i * gap
+        for j in range(1, m + 1):
+            S[0][j] = j * gap
+
+    def pair_score(i, j):
+        return match if a[i - 1] == b[j - 1] else mismatch
+
+    best = (0, 0, 0)                                   # local: (score, i, j) of the highest cell
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            v = max(S[i - 1][j - 1] + pair_score(i, j), S[i - 1][j] + gap, S[i][j - 1] + gap)
+            if local:
+                v = max(v, 0)
+                if v > best[0]:
+                    best = (v, i, j)
+            S[i][j] = v
+
+    i, j = (best[1], best[2]) if local else (n, m)
+    end, score = (i, j), (best[0] if local else S[n][m])
+    out1, out2 = [], []
+    while i > 0 or j > 0:                              # traceback, preferring diagonal, then up, then left
+        if local and S[i][j] == 0:
+            break
+        if i > 0 and j > 0 and _same(S[i][j], S[i - 1][j - 1] + pair_score(i, j)):
+            out1.append(a[i - 1]); out2.append(b[j - 1]); i -= 1; j -= 1
+        elif i > 0 and _same(S[i][j], S[i - 1][j] + gap):
+            out1.append(a[i - 1]); out2.append("-"); i -= 1
+        else:
+            out1.append("-"); out2.append(b[j - 1]); j -= 1
+    return PairAlignment(mode, name1, name2, a, b, "".join(reversed(out1)), "".join(reversed(out2)),
+                         score, S, (i, j), end)
+
+
+def _same(x, y):
+    return abs(x - y) < 1e-9
+
+
+def _num(x):
+    return str(int(x)) if float(x).is_integer() else f"{x:g}"
+
+
+def _check_scores(scores):
+    ok = (isinstance(scores, (list, tuple)) and len(scores) == 3
+          and all(isinstance(x, (int, float)) and not isinstance(x, bool) for x in scores))
+    if not ok:
+        raise ValueError(f"scores must be [match, mismatch, gap], e.g. [2, -1, -2]; got {scores!r}")
+    return scores
+
+
+def _check_seqs(seqs, names):
+    if isinstance(seqs, str) or not isinstance(seqs, (list, tuple)) or not all(isinstance(s, str) for s in seqs):
+        raise ValueError("seqs must be a list of sequences (strings), e.g. ['ATCG', 'TTTA']")
+    if len(seqs) < 2:
+        raise ValueError("need at least 2 sequences to align")
+    seqs = [s.strip().upper() for s in seqs]
+    names = list(names) if names is not None else [f"Seq{i + 1}" for i in range(len(seqs))]
+    if len(names) != len(seqs) or len(set(names)) != len(names):
+        raise ValueError(f"need {len(seqs)} unique names, got {names!r}")
+    return seqs, names

njswalig-0.1.0/tests/test_njswalig.py

@@ -0,0 +1,137 @@
+import random
+from itertools import combinations
+
+import pytest
+from Bio.Align import PairwiseAligner
+
+from njswalig import Aligner, Alignments, PairAlignment, njalign, swalign
+
+
+def biopython_score(a, b, scores, mode):
+    match, mismatch, gap = scores
+    return PairwiseAligner(mode=mode, match_score=match, mismatch_score=mismatch, gap_score=gap).score(a, b)
+
+
+def rescore(x, y, scores):
+    match, mismatch, gap = scores
+    return sum(gap if "-" in (p, q) else match if p == q else mismatch for p, q in zip(x, y))
+
+
+random.seed(1)
+CASES = [("".join(random.choices("ACGT", k=random.randint(1, 12))), "".join(random.choices("ACGT", k=random.randint(1, 12))),
+          [random.randint(1, 4), random.randint(-4, 0), random.randint(-4, -1)]) for _ in range(150)]
+
+
+# --- the usage from the brief ------------------------------------------------------------------------
+
+def test_brief_usage(capsys):
+    seqs = ["ATCG", "TTTA"]
+    scores = [2, -1, -2]
+    njalign.sequences(seqs, scores).show()
+    option1 = capsys.readouterr().out
+    njalign.sequence(seqs, scores).show()
+    option2 = capsys.readouterr().out
+    assert option1 == option2 == (
+        "Needleman-Wunsch (global): Seq1 vs Seq2, score = -1\n"
+        "Seq1  ATCG\n"
+        "      .|..\n"
+        "Seq2  TTTA\n")
+
+
+def test_sequence_is_sequences():
+    assert Aligner.sequence is Aligner.sequences
+
+
+# --- correctness ---------------------------------------------------------------------------------------
+
+@pytest.mark.parametrize("a,b,scores", CASES)
+def test_needleman_wunsch_matches_biopython(a, b, scores):
+    (pair,) = njalign.sequences([a, b], scores)
+    assert pair.score == biopython_score(a, b, scores, "global")
+    assert pair.aligned1.replace("-", "") == a and pair.aligned2.replace("-", "") == b   # whole sequences
+    assert rescore(pair.aligned1, pair.aligned2, scores) == pair.score                    # alignment earns its score
+    assert pair.matrix[-1][-1] == pair.score
+
+
+@pytest.mark.parametrize("a,b,scores", CASES)
+def test_smith_waterman_matches_biopython(a, b, scores):
+    (pair,) = swalign.sequences([a, b], scores)
+    assert pair.score == max(0, biopython_score(a, b, scores, "local"))
+    assert pair.score == max(map(max, pair.matrix))
+    if pair.score:
+        assert a[pair.start1 - 1:pair.end1] == pair.aligned1.replace("-", "")            # region positions are right
+        assert b[pair.start2 - 1:pair.end2] == pair.aligned2.replace("-", "")
+        assert rescore(pair.aligned1, pair.aligned2, scores) == pair.score
+    else:
+        assert pair.aligned1 == pair.aligned2 == ""
+
+
+def test_wikipedia_needleman_wunsch():
+    (pair,) = njalign.sequences(["GATTACA", "GCATGCU"], [1, -1, -1])
+    assert pair.score == 0
+
+
+def test_wikipedia_smith_waterman():
+    (pair,) = swalign.sequences(["TGTTACGG", "GGTTGACTA"], [3, -3, -2])
+    assert (pair.aligned1, pair.aligned2, pair.score) == ("GTT-AC", "GTTGAC", 13)
+    assert (pair.start1, pair.end1, pair.start2, pair.end2) == (2, 6, 2, 7)
+
+
+def test_global_dp_table_edges():
+    (pair,) = njalign.sequences(["AC", "GTA"], [1, -1, -2])
+    assert [row[0] for row in pair.matrix] == [0, -2, -4]
+    assert pair.matrix[0] == [0, -2, -4, -6]
+
+
+def test_float_scores():
+    (pair,) = njalign.sequences(["ACGT", "AGT"], [1.5, -0.5, -1.25])
+    assert pair.score == pytest.approx(biopython_score("ACGT", "AGT", [1.5, -0.5, -1.25], "global"))
+
+
+# --- many sequences ------------------------------------------------------------------------------------
+
+@pytest.mark.parametrize("aligner", [njalign, swalign])
+def test_every_pair_aligned(aligner):
+    seqs = ["ACGT", "ACGA", "TCGA", "GGGT"]
+    result = aligner.sequences(seqs, [2, -1, -2])
+    assert isinstance(result, Alignments) and all(isinstance(p, PairAlignment) for p in result)
+    assert [(p.name1, p.name2) for p in result] == [(f"Seq{i + 1}", f"Seq{j + 1}") for i, j in combinations(range(4), 2)]
+
+
+def test_custom_names_and_cleanup():
+    (pair,) = njalign.sequences(["  acgt ", "ACGA"], [1, -1, -1], names=["human", "mouse"])
+    assert (pair.name1, pair.name2, pair.seq1) == ("human", "mouse", "ACGT")
+
+
+def test_show_all_pairs_and_matrix(capsys):
+    swalign.sequences(["ACG", "CG", "AG"], [2, -1, -2]).show(matrix=True)
+    out = capsys.readouterr().out
+    assert out.count("Smith-Waterman (local)") == 3
+    assert "  - C G" in out                            # DP table header
+
+
+def test_no_local_alignment_message(capsys):
+    swalign.sequences(["AAAA", "TTTT"], [1, -1, -1]).show()
+    assert "no positive-scoring local alignment" in capsys.readouterr().out
+
+
+# --- input checking ------------------------------------------------------------------------------------
+
+@pytest.mark.parametrize("scores", [[2, -1], [2, -1, -2, 0], "2 -1 -2", [2, "-1", -2], [True, -1, -2], None])
+def test_scores_format_strictly_enforced(scores):
+    with pytest.raises(ValueError, match=r"\[match, mismatch, gap\]"):
+        njalign.sequences(["AC", "AG"], scores)
+
+
+@pytest.mark.parametrize("seqs,msg", [("ACGT", "list of sequences"), (["ACGT"], "at least 2"),
+                                      ([], "at least 2"), (["AC", 5], "list of sequences")])
+def test_bad_sequences(seqs, msg):
+    with pytest.raises(ValueError, match=msg):
+        swalign.sequences(seqs, [1, -1, -1])
+
+
+def test_bad_names_and_mode():
+    with pytest.raises(ValueError, match="unique names"):
+        njalign.sequences(["AC", "AG"], [1, -1, -1], names=["x", "x"])
+    with pytest.raises(ValueError, match="global' or 'local"):
+        Aligner("semi")