jupytermind 0.3.0

package/src/ai_genomics_scientist/differential_expression.py

@@ -0,0 +1,147 @@
+"""Differential expression heuristic module (DES-AGENOM-060 / REQ-AGENOM-060)."""
+
+from __future__ import annotations
+
+from numbers import Integral
+
+import numpy
+from scipy import stats
+
+from ai_genomics_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "differential-expression"
+
+
+def _is_non_negative_integer(value: object) -> bool:
+    return isinstance(value, Integral) and not isinstance(value, bool) and value >= 0
+
+
+def _differential_expression_validator(params: dict) -> dict:
+    """DES-AGENOM-002 registered atomic validator for this module."""
+    counts = params.get("counts")
+    sample_groups = params.get("sample_groups")
+
+    if not isinstance(counts, dict) or not counts:
+        return fail("counts", "must be a non-empty dict of gene IDs to count lists")
+    if not isinstance(sample_groups, list) or not sample_groups:
+        return fail("sample_groups", "must be a non-empty list of group labels")
+    if not all(isinstance(gene, str) for gene in counts):
+        return fail("counts", "must have gene-ID strings as keys")
+    if not all(isinstance(label, str) for label in sample_groups):
+        return fail("sample_groups", "must contain only string group labels")
+
+    distinct_labels = sorted(set(sample_groups))
+    if len(distinct_labels) != 2:
+        return fail("sample_groups", "must contain exactly 2 distinct group labels")
+    if any(sample_groups.count(label) < 2 for label in distinct_labels):
+        return fail(
+            "sample_groups",
+            "each of the exactly 2 groups must have at least 2 replicate samples",
+        )
+
+    num_samples = len(sample_groups)
+    for values in counts.values():
+        if not isinstance(values, list) or len(values) != num_samples:
+            return fail("counts", "each gene's count list length must equal len(sample_groups)")
+
+    invalid_genes = [
+        gene
+        for gene, values in counts.items()
+        if not all(_is_non_negative_integer(value) for value in values)
+    ]
+    if invalid_genes:
+        listed = ", ".join(f'"{gene}"' for gene in invalid_genes)
+        return fail(
+            "counts", f"must contain only non-negative integers (invalid gene(s): {listed})"
+        )
+
+    has_reference_gene = any(all(value > 0 for value in values) for values in counts.values())
+    if not has_reference_gene:
+        return fail(
+            "counts",
+            "must contain at least one gene with positive counts in every sample to compute size factors",
+        )
+
+    return ok()
+
+
+register_validator(_MODULE_NAME, _differential_expression_validator)
+
+
+def _median_of_ratios_size_factors(
+    gene_ids: list[str], counts: dict, num_samples: int
+) -> numpy.ndarray:
+    """Classic median-of-ratios size factors, excluding any gene with a zero count."""
+    reference_rows = [
+        counts[gene_id] for gene_id in gene_ids if all(value > 0 for value in counts[gene_id])
+    ]
+    reference_matrix = numpy.array(reference_rows, dtype=float)
+    geometric_means = numpy.exp(numpy.mean(numpy.log(reference_matrix), axis=1))
+    ratios = reference_matrix / geometric_means[:, None]
+    return numpy.median(ratios, axis=0)
+
+
+def _benjamini_hochberg(p_values: numpy.ndarray) -> numpy.ndarray:
+    """Pure-numpy Benjamini-Hochberg step-up correction."""
+    num_tests = len(p_values)
+    order = numpy.argsort(p_values)
+    ranked = p_values[order]
+    raw = ranked * num_tests / (numpy.arange(num_tests) + 1)
+    monotone = numpy.minimum.accumulate(raw[::-1])[::-1]
+    adjusted = numpy.empty(num_tests)
+    adjusted[order] = numpy.clip(monotone, 0.0, 1.0)
+    return adjusted
+
+
+# @id CODE-AGENOM-060
+# @implements REQ-AGENOM-060
+# @design DES-AGENOM-060
+def run_differential_expression(counts: dict, sample_groups: list) -> list[dict]:
+    """Compute median-of-ratios normalized differential expression results."""
+    gene_ids = list(counts.keys())
+    num_samples = len(sample_groups)
+    size_factors = _median_of_ratios_size_factors(gene_ids, counts, num_samples)
+
+    group1_label, group2_label = sorted(set(sample_groups))
+    group1_idx = [i for i, label in enumerate(sample_groups) if label == group1_label]
+    group2_idx = [i for i, label in enumerate(sample_groups) if label == group2_label]
+
+    results = []
+    p_values = []
+    base_means = []
+    log2_fold_changes = []
+    for gene_id in gene_ids:
+        raw = numpy.array(counts[gene_id], dtype=float)
+        normalized = raw / size_factors
+        base_mean = float(normalized.mean())
+        mean_group1 = normalized[group1_idx].mean()
+        mean_group2 = normalized[group2_idx].mean()
+        log2_fold_change = float(numpy.log2((mean_group2 + 1) / (mean_group1 + 1)))
+
+        log_normalized = numpy.log2(normalized + 1)
+        log_group1 = log_normalized[group1_idx]
+        log_group2 = log_normalized[group2_idx]
+        if numpy.var(log_group1) == 0 and numpy.var(log_group2) == 0:
+            p_value = 1.0
+        else:
+            _, p_value = stats.ttest_ind(log_group1, log_group2, equal_var=False)
+            p_value = float(p_value)
+
+        base_means.append(base_mean)
+        log2_fold_changes.append(log2_fold_change)
+        p_values.append(p_value)
+
+    padj = _benjamini_hochberg(numpy.array(p_values))
+
+    for index, gene_id in enumerate(gene_ids):
+        results.append(
+            {
+                "gene_id": gene_id,
+                "base_mean": base_means[index],
+                "log2_fold_change": log2_fold_changes[index],
+                "p_value": p_values[index],
+                "padj": float(padj[index]),
+            }
+        )
+
+    return sorted(results, key=lambda item: (item["padj"], item["gene_id"]))

package/src/ai_genomics_scientist/dispatch.py

@@ -0,0 +1,267 @@
+"""Method manifest & request dispatcher (DES-AGENOM-001 / REQ-AGENOM-001/002)."""
+
+from __future__ import annotations
+
+import importlib
+import json
+import unicodedata
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import numpy
+import scipy
+
+import ai_genomics_scientist.gene_set_enrichment as _gene_set_enrichment  # noqa: F401
+import ai_genomics_scientist.sequence_alignment as _sequence_alignment  # noqa: F401
+import ai_genomics_scientist.sequence_features as _sequence_features  # noqa: F401
+import ai_genomics_scientist.splice_site_scoring as _splice_site_scoring  # noqa: F401
+import ai_genomics_scientist.variant_effect as _variant_effect  # noqa: F401
+import ai_genomics_scientist.differential_expression as _differential_expression  # noqa: F401
+import ai_genomics_scientist.variant_pathogenicity as _variant_pathogenicity  # noqa: F401
+from ai_data_scientist.language_router import detect_language as _detect_language
+from ai_genomics_scientist.evidence import record_run
+from ai_genomics_scientist.validation import validate_parameters
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_MANIFEST_PATH = REPO_ROOT / ".github" / "skills" / "ai-genomics-scientist" / "manifest.json"
+_PER_ITEM_VALIDATED_MODULES = frozenset({"sequence-features"})
+_PER_ITEM_BATCH_PARAM_NAMES = {"sequence-features": "sequences"}
+_RUN_MODULE_PATHS = {
+    "sequence-features": "ai_genomics_scientist.sequence_features",
+    "variant-effect-annotation": "ai_genomics_scientist.variant_effect",
+    "splice-site-strength": "ai_genomics_scientist.splice_site_scoring",
+    "gene-set-enrichment": "ai_genomics_scientist.gene_set_enrichment",
+    "pairwise-sequence-alignment": "ai_genomics_scientist.sequence_alignment",
+    "differential-expression": "ai_genomics_scientist.differential_expression",
+    "variant-pathogenicity": "ai_genomics_scientist.variant_pathogenicity",
+}
+_RUN_FUNCTION_NAMES = {
+    "sequence-features": "run_sequence_features",
+    "variant-effect-annotation": "run_variant_effect",
+    "splice-site-strength": "run_splice_site_scoring",
+    "gene-set-enrichment": "run_gene_set_enrichment",
+    "pairwise-sequence-alignment": "run_sequence_alignment",
+    "differential-expression": "run_differential_expression",
+    "variant-pathogenicity": "run_variant_pathogenicity",
+}
+
+
+def load_manifest(manifest_path: Path | None = None) -> dict:
+    """Load the static method-name-to-module manifest."""
+    path = manifest_path or DEFAULT_MANIFEST_PATH
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _normalize_text(text: str) -> str:
+    return unicodedata.normalize("NFKC", text).casefold()
+
+
+def _matched_methods(request_text: str, manifest: dict) -> list[str]:
+    normalized_request = _normalize_text(request_text)
+    matched: list[str] = []
+    for method, entry in manifest.items():
+        names = entry.get("names", {})
+        candidates = list(names.get("en", [])) + list(names.get("ja", []))
+        if any(_normalize_text(candidate) in normalized_request for candidate in candidates):
+            matched.append(method)
+    return matched
+
+
+def extract_params(request_text: str | Mapping[str, Any]) -> dict | None:
+    """Extract exactly one balanced top-level JSON object from ``request_text``."""
+    if isinstance(request_text, Mapping):
+        return dict(request_text)
+    start = request_text.find("{")
+    if start == -1:
+        return None
+    depth = 0
+    for index in range(start, len(request_text)):
+        char = request_text[index]
+        if char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                candidate = request_text[start : index + 1]
+                try:
+                    parsed = json.loads(candidate)
+                except json.JSONDecodeError:
+                    return None
+                return parsed if isinstance(parsed, dict) else None
+    return None
+
+
+def _resolve_run_function(method: str):
+    module = importlib.import_module(_RUN_MODULE_PATHS[method])
+    return getattr(module, _RUN_FUNCTION_NAMES[method])
+
+
+def _no_params_outcome(language: str) -> dict:
+    constraint = (
+        "`request_text` に埋め込まれた `JSON` オブジェクトとして抽出可能でなければなりません"
+        if language == "ja"
+        else "must be extractable as a JSON object embedded in request_text"
+    )
+    return {
+        "ok": False,
+        "parameter": "params",
+        "constraint": constraint,
+        "language": language,
+    }
+
+
+def _handle_module(
+    method: str, request_text: str, language: str, params: dict[str, Any] | None = None
+) -> dict:
+    resolved_params = params if params is not None else extract_params(request_text)
+    if resolved_params is None:
+        return _no_params_outcome(language)
+
+    if method not in _PER_ITEM_VALIDATED_MODULES:
+        validation = validate_parameters(method, resolved_params)
+        if not validation["ok"]:
+            return {
+                "ok": False,
+                "parameter": validation["parameter"],
+                "constraint": validation["constraint"],
+                "language": language,
+            }
+    else:
+        # The per-item-validated module still needs its own batch container
+        # (``sequences``) checked for basic shape before iterating it: a
+        # missing key or a non-list value (e.g. a bare string, which Python
+        # would otherwise iterate character-by-character) must be rejected
+        # the same way an atomic module rejects a malformed parameter,
+        # rather than crashing or silently producing bogus per-item results.
+        batch_param_name = _PER_ITEM_BATCH_PARAM_NAMES[method]
+        batch_value = resolved_params.get(batch_param_name)
+        if not isinstance(batch_value, list):
+            return {
+                "ok": False,
+                "parameter": batch_param_name,
+                "constraint": "must be a list",
+                "language": language,
+            }
+
+    result = _resolve_run_function(method)(**resolved_params)
+    run_record = record_run(
+        module_name=method,
+        params=resolved_params,
+        result=result,
+        numpy_version=numpy.__version__,
+        scipy_version=scipy.__version__,
+    )
+    return {"ok": True, "run_record": run_record}
+
+
+# @id CODE-AGENOM-011
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_sequence_features(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the sequence-features module."""
+    return _handle_module("sequence-features", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-021
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_variant_effect_annotation(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the variant-effect-annotation module."""
+    return _handle_module("variant-effect-annotation", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-031
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_splice_site_strength(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the splice-site-strength module."""
+    return _handle_module("splice-site-strength", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-041
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_gene_set_enrichment(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the gene-set-enrichment module."""
+    return _handle_module("gene-set-enrichment", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-051
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_pairwise_sequence_alignment(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the pairwise-sequence-alignment module."""
+    return _handle_module("pairwise-sequence-alignment", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-061
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_differential_expression(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the differential-expression module."""
+    return _handle_module("differential-expression", request_text, language, params or None)
+
+
+# @id CODE-AGENOM-071
+# @implements REQ-AGENOM-002 REQ-AGENOM-004
+# @design DES-AGENOM-001
+def handle_variant_pathogenicity(request_text: str, language: str, **params) -> dict:
+    """Handler wrapper for the variant-pathogenicity module."""
+    return _handle_module("variant-pathogenicity", request_text, language, params or None)
+
+
+def _render_clarification(candidates: list[str], language: str) -> str:
+    names = "、".join(candidates) if language == "ja" else ", ".join(candidates)
+    if language == "ja":
+        return f"{names} のどちらを意図していますか。明確にしてください。"
+    return f"Did you mean {names}? Please clarify which method you want."
+
+
+def _render_rejection(language: str) -> str:
+    if language == "ja":
+        return "対応する手法が要求から認識されませんでした。"
+    return "No supported method was recognized in your request."
+
+
+# @id CODE-AGENOM-006
+# @implements REQ-AGENOM-001 REQ-AGENOM-002
+# @design DES-AGENOM-001
+def dispatch(
+    request_text: str,
+    language: str | None = None,
+    manifest_path: Path | None = None,
+) -> dict:
+    """Classify ``request_text`` and dispatch to exactly one matched module."""
+    if not isinstance(request_text, str):
+        raise ValueError("request_text: must be a str")
+    if language is not None and language not in {"en", "ja"}:
+        raise ValueError("language: must be 'en' or 'ja' when explicitly supplied")
+
+    detected_language = language or _detect_language(request_text)
+    manifest = load_manifest(manifest_path)
+    matched = _matched_methods(request_text, manifest)
+
+    if len(matched) == 1:
+        method = matched[0]
+        entry = manifest[method]
+        handler_module = importlib.import_module(entry["modulePath"])
+        handler = getattr(handler_module, entry["functionName"])
+        return {
+            "outcome": "dispatch",
+            "module": method,
+            "language": detected_language,
+            "handler_result": handler(request_text, detected_language),
+        }
+    if len(matched) > 1:
+        return {
+            "outcome": "clarification",
+            "candidates": matched,
+            "language": detected_language,
+            "clarification_question": _render_clarification(matched, detected_language),
+        }
+    return {
+        "outcome": "rejected",
+        "language": detected_language,
+        "rejected_method": _render_rejection(detected_language),
+    }

package/src/ai_genomics_scientist/evidence.py

@@ -0,0 +1,45 @@
+"""Run evidence recorder (DES-AGENOM-003 / REQ-AGENOM-004)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy
+
+SCHEMA_VERSION = 1
+
+
+def _json_safe_value(value: Any) -> Any:
+    if value is None or isinstance(value, (str, bool, int, float)):
+        return value
+    if isinstance(value, numpy.generic):
+        return _json_safe_value(value.item())
+    if isinstance(value, dict):
+        return {key: _json_safe_value(nested) for key, nested in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe_value(item) for item in value]
+    raise TypeError(f"unsupported non-JSON-safe value: {type(value).__name__}")
+
+
+# @id CODE-AGENOM-001
+# @implements REQ-AGENOM-004
+# @design DES-AGENOM-003
+def record_run(
+    module_name: str,
+    params: dict[str, Any],
+    result: Any,
+    *,
+    numpy_version: str,
+    scipy_version: str,
+) -> dict:
+    """Build a RunRecord with exactly metadata, parameters, and result."""
+    return {
+        "metadata": {
+            "module": module_name,
+            "schema_version": SCHEMA_VERSION,
+            "numpy_version": numpy_version,
+            "scipy_version": scipy_version,
+        },
+        "parameters": _json_safe_value(dict(params)),
+        "result": _json_safe_value(result),
+    }

package/src/ai_genomics_scientist/gene_set_enrichment.py

@@ -0,0 +1,76 @@
+"""Gene-set enrichment heuristic module (DES-AGENOM-040 / REQ-AGENOM-040)."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+from scipy.stats import hypergeom
+
+from ai_genomics_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "gene-set-enrichment"
+_REPO_DATA_PATH = Path(__file__).resolve().parent / "data" / "sample_gene_sets.csv"
+_BACKGROUND_SIZE = 50
+_GENE_UNIVERSE = {f"GENE{index:02d}" for index in range(1, _BACKGROUND_SIZE + 1)}
+
+
+def _load_gene_sets() -> list[dict[str, object]]:
+    with _REPO_DATA_PATH.open(encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        return [
+            {"pathway": row["pathway"], "genes": row["genes"].split(";")}
+            for row in reader
+            if row["pathway"] and row["genes"]
+        ]
+
+
+def _gene_set_enrichment_validator(params: dict) -> dict:
+    """DES-AGENOM-002 registered atomic validator for this module."""
+    query_genes = params.get("query_genes")
+    if not isinstance(query_genes, list):
+        return fail("query_genes", "must be a list")
+    if not query_genes:
+        return fail("query_genes", "must be non-empty")
+    invalid_genes = [gene for gene in query_genes if not isinstance(gene, str)]
+    if invalid_genes:
+        listed = ", ".join(f'"{gene}"' for gene in invalid_genes)
+        return fail("query_genes", f"contains invalid gene(s): {listed}")
+    if len(set(query_genes)) != len(query_genes):
+        return fail("query_genes", "must be deduplicated")
+
+    invalid_genes = [gene for gene in query_genes if gene not in _GENE_UNIVERSE]
+    if invalid_genes:
+        listed = ", ".join(f'"{gene}"' for gene in invalid_genes)
+        return fail("query_genes", f"contains invalid gene(s): {listed}")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _gene_set_enrichment_validator)
+
+
+# @id CODE-AGENOM-040
+# @implements REQ-AGENOM-040
+# @design DES-AGENOM-040
+def run_gene_set_enrichment(query_genes: list[str]) -> list[dict]:
+    """Compute hypergeometric toy-pathway enrichment for validated ``query_genes``."""
+    query_gene_set = set(query_genes)
+    query_size = len(query_genes)
+    results = []
+
+    for entry in _load_gene_sets():
+        pathway = entry["pathway"]
+        pathway_genes = set(entry["genes"])
+        overlap = len(query_gene_set & pathway_genes)
+        pathway_size = len(pathway_genes)
+        p_value = float(hypergeom.sf(overlap - 1, _BACKGROUND_SIZE, pathway_size, query_size))
+        results.append(
+            {
+                "pathway": pathway,
+                "overlap": overlap,
+                "pathway_size": pathway_size,
+                "p_value": p_value,
+            }
+        )
+
+    return sorted(results, key=lambda item: (item["p_value"], item["pathway"]))

package/src/ai_genomics_scientist/sequence_alignment.py

@@ -0,0 +1,97 @@
+"""Pairwise sequence alignment module (DES-AGENOM-050 / REQ-AGENOM-050)."""
+
+from __future__ import annotations
+
+from ai_genomics_scientist.validation import fail, ok, register_validator
+
+_MODULE_NAME = "pairwise-sequence-alignment"
+_DNA_BASES = frozenset({"A", "C", "G", "T"})
+_MATCH_SCORE = 1
+_MISMATCH_SCORE = -1
+_GAP_SCORE = -2
+
+
+def _is_dna_string(value: object) -> bool:
+    return isinstance(value, str) and value.isupper() and value and set(value).issubset(_DNA_BASES)
+
+
+def _sequence_alignment_validator(params: dict) -> dict:
+    """DES-AGENOM-002 registered atomic validator for this module."""
+    seq1 = params.get("seq1")
+    seq2 = params.get("seq2")
+    if not _is_dna_string(seq1):
+        return fail("seq1", "must be a non-empty uppercase DNA string over {A,C,G,T}")
+    if not _is_dna_string(seq2):
+        return fail("seq2", "must be a non-empty uppercase DNA string over {A,C,G,T}")
+    return ok()
+
+
+register_validator(_MODULE_NAME, _sequence_alignment_validator)
+
+
+# @id CODE-AGENOM-050
+# @implements REQ-AGENOM-050
+# @design DES-AGENOM-050
+def run_sequence_alignment(seq1: str, seq2: str) -> dict:
+    """Compute the fixed-score Needleman-Wunsch global alignment."""
+    rows = len(seq1) + 1
+    cols = len(seq2) + 1
+    scores = [[0] * cols for _ in range(rows)]
+    traceback = [[""] * cols for _ in range(rows)]
+
+    for row in range(1, rows):
+        scores[row][0] = row * _GAP_SCORE
+        traceback[row][0] = "up"
+    for col in range(1, cols):
+        scores[0][col] = col * _GAP_SCORE
+        traceback[0][col] = "left"
+
+    for row in range(1, rows):
+        for col in range(1, cols):
+            match_score = _MATCH_SCORE if seq1[row - 1] == seq2[col - 1] else _MISMATCH_SCORE
+            diagonal = scores[row - 1][col - 1] + match_score
+            up = scores[row - 1][col] + _GAP_SCORE
+            left = scores[row][col - 1] + _GAP_SCORE
+            best = max(diagonal, up, left)
+            scores[row][col] = best
+            if diagonal == best:
+                traceback[row][col] = "diag"
+            elif up == best:
+                traceback[row][col] = "up"
+            else:
+                traceback[row][col] = "left"
+
+    aligned_seq1: list[str] = []
+    aligned_seq2: list[str] = []
+    row = len(seq1)
+    col = len(seq2)
+    while row > 0 or col > 0:
+        move = traceback[row][col]
+        if move == "diag":
+            aligned_seq1.append(seq1[row - 1])
+            aligned_seq2.append(seq2[col - 1])
+            row -= 1
+            col -= 1
+        elif move == "up":
+            aligned_seq1.append(seq1[row - 1])
+            aligned_seq2.append("-")
+            row -= 1
+        else:
+            aligned_seq1.append("-")
+            aligned_seq2.append(seq2[col - 1])
+            col -= 1
+
+    aligned1 = "".join(reversed(aligned_seq1))
+    aligned2 = "".join(reversed(aligned_seq2))
+    matches = sum(
+        1
+        for base1, base2 in zip(aligned1, aligned2, strict=True)
+        if base1 == base2 and base1 != "-" and base2 != "-"
+    )
+    identity = matches / len(aligned1) if aligned1 else 0.0
+    return {
+        "aligned_seq1": aligned1,
+        "aligned_seq2": aligned2,
+        "score": scores[-1][-1],
+        "identity": identity,
+    }