varcode 7.2.0__tar.gz → 7.3.0__tar.gz

{varcode-7.2.0/varcode.egg-info → varcode-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: varcode
-Version: 7.2.0
+Version: 7.3.0
 Summary: Variant annotation in Python
 Author-email: Alex Rubinsteyn <alex.rubinsteyn@unc.edu>
 Project-URL: Homepage, https://github.com/openvax/varcode

{varcode-7.2.0 → varcode-7.3.0}/tests/test_effect_hypotheses.py

@@ -181,3 +181,23 @@ def test_ordering_uses_ordinal_rank_when_scores_are_uncalibrated():
 
     assert ordered[0].effect is low_priority
     assert ordered[0].probability is None
+
+
+def test_ordering_prefers_fewer_cis_variants_after_rank_and_priority():
+    baseline = product("ABCDEFG")
+    outcomes = (
+        ClassifiedOutcome(
+            EffectHypothesis(
+                phase=(("g", "cis"),), enumeration_index=0),
+            effect("cis"), baseline, product("ABCDEX"), 3),
+        ClassifiedOutcome(
+            EffectHypothesis(
+                phase=(("g", "trans"),), enumeration_index=1),
+            effect("reference-like"), baseline, product("ABCDEY"), 3),
+    )
+    candidates = merge_classified_outcomes(outcomes)
+
+    ordered = order_realized_candidates(candidates, lambda value: 1)
+
+    assert [type(candidate.effect).__name__ for candidate in ordered] == [
+        "reference-like", "cis"]

varcode-7.3.0/tests/test_realized_effects.py

@@ -0,0 +1,262 @@
+"""End-to-end tests for the opt-in realized effect engine."""
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import (
+    Completeness,
+    GermlineContext,
+    StructuralVariant,
+    Variant,
+    get_annotator,
+    predict_realized_effect,
+)
+from varcode.effects.effect_classes import (
+    Deletion,
+    GeneFusion,
+    Insertion,
+    Substitution,
+    Unresolved,
+)
+
+from .test_splice_graph import (
+    LongIntronTranscript,
+    Transcript,
+    deletion,
+    long_provider,
+    point,
+    provider,
+)
+
+
+ensembl_grch38 = cached_release(81)
+CFTR_TRANSCRIPT_ID = "ENST00000003084"
+
+
+def test_realized_annotator_is_registered_but_not_default():
+    annotator = get_annotator("realized")
+
+    assert annotator.name == "realized"
+    assert get_annotator("fast").name == "fast"
+
+
+def test_weak_exonic_variant_keeps_normal_coding_effect_first():
+    transcript = Transcript()
+    variant = point(9, "A", "G")
+
+    result = predict_realized_effect(
+        (variant,), transcript, sequence_provider=provider())
+
+    assert type(result) is Substitution
+    assert result.aa_ref == "Q"
+    assert result.aa_alt == "R"
+    assert all(rank == 0 for rank in result.mechanism_rank)
+    assert result.probability is None
+
+
+def test_strong_donor_variant_returns_ordinary_deletion_as_top_effect():
+    transcript = Transcript()
+    variant = point(11, "G", "A")
+
+    result = predict_realized_effect(
+        (variant,), transcript, sequence_provider=provider())
+
+    assert type(result) is Deletion
+    assert result.aa_ref == "Q"
+    assert [
+        type(candidate.effect).__name__ for candidate in result.candidates
+    ] == ["Deletion", "FrameShift", "Unresolved", "Intronic"]
+    unresolved = [
+        candidate.effect for candidate in result.candidates
+        if isinstance(candidate.effect, Unresolved)]
+    assert [effect.mechanism for effect in unresolved] == ["cryptic"]
+
+
+def test_same_mutant_with_different_phase_baselines_does_not_merge():
+    transcript = Transcript()
+    somatic = point(11, "G", "A")
+    germline = point(9, "A", "G")
+
+    result = predict_realized_effect(
+        (somatic,), transcript, germline_variants=(germline,),
+        sequence_provider=provider())
+
+    deletion_candidates = [
+        candidate for candidate in result.candidates
+        if type(candidate.effect) is Deletion]
+    assert len(deletion_candidates) == 2
+    assert {
+        candidate.outcomes[0].baseline.protein_sequence
+        for candidate in deletion_candidates
+    } == {"MQA", "MRA"}
+    assert {
+        candidate.outcomes[0].mutant.protein_sequence
+        for candidate in deletion_candidates
+    } == {"MA"}
+
+
+def test_sv_deletion_does_not_merge_away_patient_specific_baseline():
+    transcript = Transcript()
+    somatic = deletion(8, 10)
+    germline = point(9, "A", "G")
+
+    result = predict_realized_effect(
+        (somatic,), transcript, germline_variants=(germline,),
+        sequence_provider=provider())
+
+    assert type(result) is Deletion
+    deletion_candidates = [
+        candidate for candidate in result.candidates
+        if type(candidate.effect) is Deletion]
+    assert len(deletion_candidates) == 2
+    assert {
+        candidate.outcomes[0].baseline.protein_sequence
+        for candidate in deletion_candidates
+    } == {"MQA", "MRA"}
+
+
+def test_multiple_somatic_variants_are_realized_on_one_product():
+    transcript = Transcript()
+    variants = (point(8, "C", "A"), point(9, "A", "G"))
+
+    result = predict_realized_effect(
+        variants, transcript, sequence_provider=provider())
+
+    assert type(result) is Substitution
+    assert result.aa_ref == "Q"
+    assert result.aa_alt == "R"
+    assert result.variants == variants
+
+
+def test_combined_phase_and_splice_hypotheses_obey_global_cap():
+    transcript = Transcript()
+    somatic = point(11, "G", "A")
+    germline = point(9, "A", "G")
+
+    with pytest.raises(ValueError, match="Combined phase/splice"):
+        predict_realized_effect(
+            (somatic,), transcript, germline_variants=(germline,),
+            sequence_provider=provider(), max_hypotheses=7)
+
+
+def test_real_cftr_missense_matches_existing_varcode_result():
+    transcript = ensembl_grch38.transcript_by_id(CFTR_TRANSCRIPT_ID)
+    variant = Variant("7", 117531100, "T", "A", ensembl_grch38)
+
+    result = predict_realized_effect((variant,), transcript)
+
+    assert type(result) is Substitution
+    assert result.short_description == "p.L159M"
+    assert len(result.candidates) == 1
+
+
+def test_effects_dispatches_realized_annotator_with_germline_context():
+    somatic = Variant("7", 117531100, "T", "A", ensembl_grch38)
+    germline = Variant("7", 117531101, "T", "C", ensembl_grch38)
+    context = GermlineContext.from_variants(
+        [germline], reference_name="GRCh38")
+
+    effects = somatic.effects(annotator="realized", germline=context)
+    result = next(
+        effect for effect in effects
+        if effect.transcript.id == CFTR_TRANSCRIPT_ID)
+
+    assert type(result) is Substitution
+    assert len(result.candidates) == 2
+    assert {
+        candidate.outcomes[0].baseline.protein_sequence[158]
+        for candidate in result.candidates
+    } == {"L", "S"}
+
+
+def test_realized_dispatch_preserves_sparse_germline_uncertainty_flag():
+    somatic = Variant("7", 117531100, "T", "A", ensembl_grch38)
+    distant = Variant("7", 117587799, "C", "T", ensembl_grch38)
+    context = GermlineContext.from_variants(
+        [distant], reference_name="GRCh38",
+        completeness=Completeness.SPARSE)
+
+    effects = somatic.effects(annotator="realized", germline=context)
+    result = next(
+        effect for effect in effects
+        if effect.transcript.id == CFTR_TRANSCRIPT_ID)
+
+    assert result.germline_unknown is True
+
+
+def test_real_cftr_donor_plus_one_enumerates_splice_mechanisms():
+    transcript = ensembl_grch38.transcript_by_id(CFTR_TRANSCRIPT_ID)
+    variant = Variant("7", 117531115, "G", "A", ensembl_grch38)
+
+    result = predict_realized_effect((variant,), transcript)
+
+    assert type(result) is Deletion
+    assert [
+        candidate.effect.mechanism
+        for candidate in result.candidates
+        if isinstance(candidate.effect, Unresolved)
+    ] == ["intron_retention", "cryptic"]
+    assert result.probability is None
+
+
+@pytest.mark.parametrize(
+    "sv_type,expected_class",
+    [("DEL", Deletion), ("DUP", Insertion)])
+def test_real_cftr_whole_exon_sv_is_classified_from_realized_product(
+        sv_type, expected_class):
+    transcript = ensembl_grch38.transcript_by_id(CFTR_TRANSCRIPT_ID)
+    exon = transcript.exons[4]
+    variant = StructuralVariant(
+        contig="7",
+        start=exon.start - 300,
+        end=exon.end + 300,
+        sv_type=sv_type,
+        genome=ensembl_grch38)
+
+    result = predict_realized_effect((variant,), transcript)
+
+    assert type(result) is expected_class
+    assert len(result.candidates) == 1
+
+
+@pytest.mark.parametrize(
+    "reverse,position,ref,alt",
+    [(False, 23, "G", "A"), (True, 178, "C", "T")])
+def test_cryptic_donor_is_realized_on_mutated_haplotype_both_strands(
+        reverse, position, ref, alt):
+    transcript = LongIntronTranscript(reverse=reverse)
+    variant = point(position, ref, alt)
+
+    result = predict_realized_effect(
+        (variant,), transcript, sequence_provider=long_provider(reverse))
+
+    cryptic = next(
+        candidate for candidate in result.candidates
+        if candidate.ordinal_key == (2,))
+    assert not isinstance(cryptic.effect, Unresolved)
+    evidence = cryptic.outcomes[0].mutant.evidence
+    resolved = evidence["resolved_splice_choices"]
+    assert len(resolved) == 1
+    assert resolved[0][1] == "cryptic"
+    assert resolved[0][3] > 0
+
+
+def test_realized_annotator_routes_bnd_through_verified_fusion_builder():
+    genome = cached_release(95)
+    otx1 = genome.transcript_by_id("ENST00000282549")
+    variant = StructuralVariant(
+        contig="2",
+        start=63_053_516,
+        sv_type="BND",
+        alt="N]2:25955847]",
+        mate_contig="2",
+        mate_start=25_955_847,
+        mate_orientation="]]",
+        genome=genome)
+
+    result = predict_realized_effect((variant,), otx1)
+
+    assert isinstance(result, GeneFusion)
+    assert result.partner_transcript.id == "ENST00000264712"
+    assert result.mutant_protein_sequence == (
+        "MMSYLKQPPYGMNGLGLAGPAMDLLHPSVGYPETS")

varcode-7.3.0/tests/test_splice_graph.py

@@ -0,0 +1,257 @@
+"""Tests for splice-site detection on realized forward/reverse layouts."""
+
+from types import SimpleNamespace
+
+import pytest
+
+from varcode.genomic_layout import GenomicLayout
+from varcode.nucleotides import reverse_complement
+from varcode.splice_graph import (
+    disrupted_splice_sites,
+    enumerate_layout_splice_plans,
+)
+from varcode.transcript_layout import build_exon_runs, realize_exon_path
+
+
+FORWARD = "ATGGTAGCAAGTAGGCTGTAGTAG"
+
+
+def _long_forward_sequence():
+    bases = list("A" * 200)
+    for start, sequence in (
+            (1, "ATG"), (4, "GT"),
+            (18, "AG"), (20, "CAA"), (23, "GT"),
+            (29, "CAGGTAAGT"),
+            (118, "AG"), (120, "GCT"), (123, "GT"),
+            (138, "AG"), (140, "TAG")):
+        bases[start - 1:start - 1 + len(sequence)] = sequence
+    return "".join(bases)
+
+
+LONG_FORWARD = _long_forward_sequence()
+
+
+class Exon:
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+
+class Transcript:
+    contig = "x"
+    start = 1
+    end = 24
+    is_protein_coding = True
+    complete = True
+    protein_sequence = "MQA"
+    stop_codon_spliced_offsets = (9, 10, 11)
+    id = "synthetic-splice"
+    name = "SYN-001"
+
+    def __init__(self, reverse=False):
+        self.gene = SimpleNamespace(id="synthetic-gene", name="SYN")
+        self.on_backward_strand = reverse
+        intervals = ((1, 3), (8, 10), (15, 17), (22, 24))
+        if reverse:
+            intervals = tuple(
+                (25 - end, 25 - start)
+                for start, end in reversed(intervals))
+            self.start_codon_positions = (22, 23, 24)
+        else:
+            self.start_codon_positions = (1, 2, 3)
+        self.start_codon_spliced_offsets = (0, 1, 2)
+        self.exons = tuple(Exon(*interval) for interval in intervals)
+
+    def spliced_offset(self, position):
+        offset = 0
+        exons = sorted(
+            self.exons, key=lambda exon: exon.start,
+            reverse=self.on_backward_strand)
+        for exon in exons:
+            if exon.start <= position <= exon.end:
+                if self.on_backward_strand:
+                    return offset + exon.end - position
+                return offset + position - exon.start
+            offset += exon.end - exon.start + 1
+        raise ValueError(position)
+
+
+class LongIntronTranscript(Transcript):
+    end = 142
+    id = "synthetic-long-intron"
+
+    def __init__(self, reverse=False):
+        self.gene = SimpleNamespace(id="synthetic-gene", name="SYN")
+        self.on_backward_strand = reverse
+        intervals = ((1, 3), (20, 22), (120, 122), (140, 142))
+        if reverse:
+            intervals = tuple(
+                (201 - end, 201 - start)
+                for start, end in reversed(intervals))
+            self.start_codon_positions = (198, 199, 200)
+        else:
+            self.start_codon_positions = (1, 2, 3)
+        self.start = min(start for start, _ in intervals)
+        self.end = max(end for _, end in intervals)
+        self.start_codon_spliced_offsets = (0, 1, 2)
+        self.exons = tuple(Exon(*interval) for interval in intervals)
+
+
+def long_provider(reverse=False):
+    chromosome = reverse_complement(LONG_FORWARD) if reverse else LONG_FORWARD
+
+    def get_sequence(contig, start, end):
+        assert contig == "x"
+        sequence = chromosome[start - 1:end]
+        return sequence + "A" * (end - start + 1 - len(sequence))
+
+    return get_sequence
+
+
+def provider(reverse=False):
+    chromosome = reverse_complement(FORWARD) if reverse else FORWARD
+
+    def get_sequence(contig, start, end):
+        assert contig == "x"
+        return chromosome[start - 1:end]
+
+    return get_sequence
+
+
+def point(start, ref, alt):
+    return SimpleNamespace(
+        contig="x", trimmed_base1_start=start,
+        trimmed_base1_end=start + len(ref) - 1,
+        trimmed_ref=ref, trimmed_alt=alt, is_structural=False)
+
+
+def deletion(start, end):
+    return SimpleNamespace(
+        contig="x", start=start, end=end,
+        affected_start=start, affected_end=end,
+        sv_type="DEL", alt_assembly=None, is_structural=True)
+
+
+def statuses_for(variant=None, reverse=False, with_sequence=True):
+    transcript = Transcript(reverse)
+    layout = GenomicLayout.from_transcript(
+        transcript,
+        flank=0,
+        sequence_provider=provider(reverse) if with_sequence else None)
+    if variant is not None:
+        layout = layout.apply_point_variant(
+            variant, validate_reference=with_sequence)
+    runs = build_exon_runs(transcript, layout)
+    return disrupted_splice_sites(transcript, layout, runs)
+
+
+@pytest.mark.parametrize("reverse", [False, True])
+def test_reference_splice_sites_are_intact(reverse):
+    assert statuses_for(reverse=reverse) == ()
+
+
+def test_donor_canonical_and_weak_windows_are_distinct():
+    strong = statuses_for(point(11, "G", "A"))
+    weak_intronic = statuses_for(point(14, "G", "A"))
+    weak_exonic = statuses_for(point(10, "A", "C"))
+
+    assert [(s.key.side, s.key.exon_number, s.strength) for s in strong] == [
+        ("donor", 2, "lost")]
+    donor = next(
+        status for status in weak_intronic
+        if status.key.side == "donor" and status.key.exon_number == 2)
+    assert donor.strength == "weak_intronic"
+    assert weak_exonic[0].strength == "weak_exonic"
+
+
+def test_reverse_strand_donor_uses_transcript_direction():
+    # Forward position 11 maps to reverse-complement position 14.
+    statuses = statuses_for(point(14, "C", "T"), reverse=True)
+
+    assert [(s.key.side, s.key.exon_number, s.strength) for s in statuses] == [
+        ("donor", 2, "lost")]
+
+
+def test_tier_zero_detects_explicit_canonical_site_edit_without_fasta():
+    statuses = statuses_for(
+        point(11, "G", "A"), with_sequence=False)
+
+    assert statuses[0].strength == "lost"
+
+
+def test_exon_truncation_is_a_lost_splice_site():
+    transcript = Transcript()
+    layout = GenomicLayout.from_transcript(
+        transcript, flank=0, sequence_provider=provider())
+    layout = layout.apply_structural_variant(deletion(10, 14))
+
+    statuses = disrupted_splice_sites(
+        transcript, layout, build_exon_runs(transcript, layout))
+
+    assert any(
+        status.key.side == "donor"
+        and status.key.exon_number == 2
+        and status.strength == "lost"
+        for status in statuses)
+
+
+def test_strong_site_options_are_ordinal_not_probabilities():
+    transcript = Transcript()
+    layout = GenomicLayout.from_transcript(
+        transcript, flank=0, sequence_provider=provider())
+    layout = layout.apply_point_variant(point(11, "G", "A"))
+
+    plans = enumerate_layout_splice_plans(transcript, layout)
+    mechanisms = [
+        tuple(option.mechanism for _, option in plan.choices)
+        for plan in plans]
+
+    assert mechanisms == [
+        ("exon_skip",),
+        ("intron_retention",),
+        ("cryptic",),
+        ("normal",),
+    ]
+    assert all(plan.probability is None for plan in plans)
+    skipped = realize_exon_path(
+        transcript, layout, kept_run_keys=plans[0].kept_runs)
+    assert skipped.cdna_sequence == "ATGGCTTAG"
+
+
+def test_two_sites_on_skipped_exon_do_not_form_impossible_cartesian_pair():
+    transcript = Transcript()
+    layout = GenomicLayout.from_transcript(
+        transcript, flank=0, sequence_provider=provider())
+    # Destroy exon 2's acceptor and donor.
+    layout = layout.apply_variants((
+        point(6, "A", "C"),
+        point(11, "G", "A"),
+    ))
+
+    plans = enumerate_layout_splice_plans(transcript, layout)
+
+    assert plans
+    assert all(not (
+        len(plan.choices) == 2
+        and all(option.mechanism == "exon_skip"
+                for _, option in plan.choices))
+        for plan in plans)
+
+
+def test_retained_intron_cannot_coexist_with_skipped_downstream_exon():
+    transcript = Transcript()
+    layout = GenomicLayout.from_transcript(
+        transcript, flank=0, sequence_provider=provider())
+    # Destroy the donors of exon 2 and exon 3. Retaining intron 2 requires
+    # exon 3, so it cannot coexist with exon 3 skipping.
+    layout = layout.apply_variants((
+        point(11, "G", "A"),
+        point(18, "G", "A"),
+    ))
+
+    plans = enumerate_layout_splice_plans(transcript, layout)
+
+    assert all(not (
+        dict((key.exon_number, option.mechanism) for key, option in plan.choices)
+        == {2: "intron_retention", 3: "exon_skip"})
+        for plan in plans)