varcode 9.2.7__tar.gz → 9.3.0__tar.gz

{varcode-9.2.7/varcode.egg-info → varcode-9.3.0}/PKG-INFO

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

{varcode-9.2.7 → varcode-9.3.0}/tests/test_documentation_examples.py

@@ -69,6 +69,14 @@ def test_documentation_first_steps(path, count, input_directory):
                    for effect in namespace["effects"])
 
 
+def test_documentation_sv_filtering(input_directory):
+    namespace = _run(_blocks("docs/structural_variants.md")[:2])
+    assert len(namespace["retained"]) > 0
+    assert len(namespace["resolved_changes"]) > 0
+    assert all(effect.modifies_protein_sequence is True
+               for effect in namespace["resolved_changes"])
+
+
 def test_documentation_germline_scenarios():
     namespace = _run(_blocks(
         "docs/phasing.md", "## Two variants in one codon")[:4])
@@ -103,6 +111,19 @@ def test_documentation_germline_with_vcf_phase(input_directory):
     assert cftr[0].short_description == "p.S159T"
 
 
+def test_documentation_fusion_protein_candidates(capsys):
+    genome = cached_release(95)
+    transcript = genome.transcript_by_id("ENST00000538197")
+    variant = StructuralVariant(
+        "4", 15012987, "BND", alt="N[4:2664478[",
+        mate_contig="4", mate_start=2664478, genome=genome)
+    namespace = {"effect": variant.effect_on_transcript(transcript)}
+    _run(_blocks("docs/structural_variants.md", "## Fusion protein candidates")[:1], namespace)
+    output = capsys.readouterr().out
+    assert "ENST00000324666" in output
+    assert "ENST00000637812" in output
+
+
 def test_documentation_effect_families_keep_all_classes():
     source = ast.parse((ROOT / "varcode/effects/effect_classes.py").read_text())
     classes = {node.name for node in source.body if isinstance(node, ast.ClassDef)}

varcode-9.3.0/tests/test_fusion_partner_candidates.py

@@ -0,0 +1,184 @@
+"""Fusion proteins must not depend on discarding all but the first isoform."""
+
+from types import SimpleNamespace
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import EffectCandidate, StructuralVariant
+from varcode.effects import GeneFusion, LargeDeletion, TranslocationToIntergenic
+from varcode.effects import structural
+
+
+@pytest.fixture
+def fusion_case(monkeypatch):
+    genome = cached_release(95)
+    transcript = genome.transcript_by_id("ENST00000538197")  # CPEB2, forward
+    variant = StructuralVariant(
+        "4", 15012987, "BND", alt="N[4:2664478[",
+        mate_contig="4", mate_start=2664478, genome=genome)
+    # These tests isolate junction/isoform enumeration. Dedicated existing
+    # tests cover the splice and cryptic layers added after it.
+    monkeypatch.setattr(structural, "_enumerate_and_attach_cryptics", lambda *args: None)
+    monkeypatch.setattr(structural, "_enumerate_and_attach_splice_outcomes", lambda *args: None)
+    return genome, transcript, variant
+
+
+def _fusions(effect):
+    return [candidate.effect for candidate in effect.candidates
+            if isinstance(candidate.effect, GeneFusion)]
+
+
+def test_audited_cpeb2_fam193a_proteins_are_both_candidates(fusion_case):
+    genome, transcript, variant = fusion_case
+    effect = variant.effect_on_transcript(transcript)
+    candidates = _fusions(effect)
+    expected = [t.id for t in genome.transcripts_at_locus("4", 2664478, 2664478)
+                if t.is_protein_coding and t.gene_name == "FAM193A" and t.strand == "+"]
+    assert [c.partner_transcript.id for c in candidates] == expected
+    assert len(candidates) == 7
+    assert candidates[0] is effect  # existing primary remains compatible
+    proteins = {c.partner_transcript.id: c.mutant_protein_sequence for c in candidates}
+    assert len(proteins["ENST00000324666"]) == 1541
+    assert len(proteins["ENST00000637812"]) == 1500
+    assert proteins["ENST00000324666"] != proteins["ENST00000637812"]
+    partner = genome.transcript_by_id("ENST00000637812")
+    assert proteins[partner.id] == transcript.protein_sequence[:678] + partner.protein_sequence[693:]
+    for candidate in candidates:
+        assert candidate.transcript is transcript
+        assert candidate.five_prime_transcript is transcript
+        assert candidate.three_prime_transcript is candidate.partner_transcript
+        model = candidate.mutant_transcript
+        assert model.cdna_sequence == "".join(
+            segment.source.sequence[segment.start:segment.end]
+            for segment in model.reference_segments)
+
+
+def test_same_transcript_pair_has_same_protein_from_either_end(fusion_case):
+    genome, transcript, variant = fusion_case
+    partner = genome.transcript_by_id("ENST00000637812")
+    mate = StructuralVariant(
+        "4", 2664478, "BND", alt="]4:15012987]N",
+        mate_contig="4", mate_start=15012987, genome=genome)
+    from_five = next(c for c in _fusions(variant.effect_on_transcript(transcript))
+                     if c.partner_transcript.id == partner.id)
+    from_three = next(c for c in _fusions(mate.effect_on_transcript(partner))
+                      if c.partner_transcript.id == transcript.id)
+    assert from_five.mutant_protein_sequence == from_three.mutant_protein_sequence
+    assert from_three.five_prime_transcript.id == transcript.id
+    assert from_three.three_prime_transcript.id == partner.id
+
+
+class _Isoform:
+    """Reuse a reference transcript while varying only ID or available sequence."""
+    def __init__(self, transcript, name, sequence):
+        self._transcript = transcript
+        self.id = name
+        self.sequence = sequence
+
+    def __getattr__(self, name):
+        return getattr(self._transcript, name)
+
+
+def test_large_isoform_set_is_not_capped_or_merged_by_protein(fusion_case, monkeypatch):
+    genome, transcript, variant = fusion_case
+    partner = genome.transcript_by_id("ENST00000637812")
+    partners = [_Isoform(partner, "isoform_%03d" % i, partner.sequence) for i in range(257)]
+    monkeypatch.setattr(structural, "_coding_transcripts_at", lambda *args: partners)
+    candidates = _fusions(variant.effect_on_transcript(transcript))
+    assert [c.partner_transcript.id for c in candidates] == [p.id for p in partners]
+    assert len({c.mutant_protein_sequence for c in candidates}) == 1
+
+
+def test_duplicate_junction_and_partner_records_are_not_repeated(fusion_case, monkeypatch):
+    genome, transcript, variant = fusion_case
+    partner = genome.transcript_by_id("ENST00000637812")
+    monkeypatch.setattr(structural, "_coding_transcripts_at", lambda *args: [partner, partner])
+    duplicate = SimpleNamespace(junctions=variant.junctions * 2)
+    effect = structural._fusion_across_junction(duplicate, transcript, None)
+    assert len(_fusions(effect)) == 1
+
+
+@pytest.mark.parametrize("sequence", [None, ""])
+def test_missing_partner_sequence_keeps_an_unresolved_candidate(fusion_case, monkeypatch, sequence):
+    genome, transcript, variant = fusion_case
+    partner = genome.transcript_by_id("ENST00000637812")
+    missing = _Isoform(partner, "missing_sequence", sequence)
+    monkeypatch.setattr(structural, "_coding_transcripts_at", lambda *args: [partner, missing])
+    candidates = _fusions(variant.effect_on_transcript(transcript))
+    assert len(candidates) == 2
+    assert candidates[0].mutant_protein_sequence is not None
+    assert candidates[1].partner_transcript is missing
+    assert candidates[1].mutant_transcript is None
+    assert candidates[1].mutant_protein_sequence is None
+
+
+def test_supplied_assembly_and_external_candidates_are_preserved(fusion_case):
+    genome, transcript, variant = fusion_case
+    variant.alt_assembly = "ATG" + "GCC" * 20 + "TAA"
+    effect = variant.effect_on_transcript(transcript)
+    candidates = _fusions(effect)
+    assert len(candidates) == 7
+    assert all(c.mutant_transcript.cdna_sequence == variant.alt_assembly for c in candidates)
+    assert all(c.mutant_transcript.evidence == {"source": "alt_assembly"} for c in candidates)
+    observed = EffectCandidate(candidates[-1], source="rna", evidence={"read_count": 4})
+    effect._extra_candidates = (observed,)
+    assert effect.candidates[-1] is observed
+    assert len(effect.candidates) == 8
+
+
+def test_opposite_strand_partner_isoforms_are_all_kept(monkeypatch):
+    genome = cached_release(81)
+    transcript = genome.transcript_by_id("ENST00000003084")  # CFTR, +
+    variant = StructuralVariant(
+        "7", 117485000, "BND", alt="N]17:43120000]",
+        mate_contig="17", mate_start=43120000, genome=genome)
+    monkeypatch.setattr(structural, "_enumerate_and_attach_cryptics", lambda *args: None)
+    effect = variant.effect_on_transcript(transcript)
+    expected = {t.id for t in genome.transcripts_at_locus("17", 43120000, 43120000)
+                if t.is_protein_coding and t.strand == "-"}
+    assert {c.partner_transcript.id for c in _fusions(effect)} == expected
+    assert len(expected) > 1
+
+
+def test_same_role_join_still_has_no_fusion_candidates(fusion_case):
+    genome, transcript, _ = fusion_case
+    variant = StructuralVariant(
+        "4", 15012987, "BND", alt="N]4:2664478]",
+        mate_contig="4", mate_start=2664478, genome=genome)
+    effect = variant.effect_on_transcript(transcript)
+    assert isinstance(effect, TranslocationToIntergenic)
+    assert not _fusions(effect)
+
+
+def test_span_effect_is_retained_after_all_fusion_partners(fusion_case):
+    genome, _, _ = fusion_case
+    tmprss2 = max((t for t in genome.genes_by_name("TMPRSS2")[0].transcripts if t.is_protein_coding),
+                 key=lambda t: len(t.sequence or ""))
+    erg = max((t for t in genome.genes_by_name("ERG")[0].transcripts if t.is_protein_coding),
+              key=lambda t: len(t.sequence or ""))
+    def midpoint(transcript, exon):
+        left, right = transcript.exons[exon - 1:exon + 1]
+        return (min(left.end, right.end) + max(left.start, right.start)) // 2
+    variant = StructuralVariant("21", midpoint(erg, 3), "DEL",
+                                end=midpoint(tmprss2, 2) - 1, genome=genome)
+    effect = variant.effect_on_transcript(tmprss2)
+    assert len(_fusions(effect)) > 1
+    assert isinstance(effect.candidates[-1].effect, LargeDeletion)
+    assert effect.candidates[-1].effect.affected_exons
+
+
+def test_inversion_keeps_both_junction_directions_with_local_five_prime_first(fusion_case):
+    genome, _, _ = fusion_case
+    transcript = genome.transcript_by_id("ENST00000003084")  # CFTR, +
+    partner_gene = genome.genes_by_name("CTTNBP2")[0]  # downstream, -
+    far = (max(partner_gene.start, transcript.gene.end + 1) + partner_gene.end) // 2
+    variant = StructuralVariant("7", 117485000, "INV", end=far, genome=genome)
+    effect = variant.effect_on_transcript(transcript)
+    candidates = _fusions(effect)
+    assert effect.five_prime_transcript.id == transcript.id
+    directions = {(c.five_prime_transcript.gene_name, c.three_prime_transcript.gene_name)
+                  for c in candidates}
+    assert directions == {("CFTR", "CTTNBP2"), ("CTTNBP2", "CFTR")}
+    keys = [(c.five_prime_transcript.id, c.three_prime_transcript.id) for c in candidates]
+    assert len(keys) == len(set(keys))

{varcode-9.2.7 → varcode-9.3.0}/tests/test_nonlocal_sv_transcripts.py

@@ -16,7 +16,7 @@ def transcript(request):
 @pytest.fixture(autouse=True)
 def no_optional_candidates(monkeypatch):
     # Isolate the span fallback; fusion preservation also has real esvee tests.
-    monkeypatch.setattr(structural, "_fusion_partner", lambda *args: None)
+    monkeypatch.setattr(structural, "_fusion_partners", lambda *args: ())
     monkeypatch.setattr(structural, "_enumerate_and_attach_cryptics", lambda *args: None)
     monkeypatch.setattr(structural, "_enumerate_and_attach_splice_outcomes", lambda *args: None)
 

varcode-9.3.0/tests/test_sv_sequence_changes.py

@@ -0,0 +1,296 @@
+"""SV predictions must survive filtering without calling unknowns unchanged."""
+
+from dataclasses import replace
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import (
+    EffectCandidate, MutantTranscript, ReferenceSegment, StructuralVariant,
+    make_fusion_outcome,
+)
+from varcode.effects import (
+    CrypticExonCandidate, EffectCollection, GeneFusion, LargeDeletion,
+    StructuralVariantEffect, TranslocationToIntergenic, Unresolved,
+)
+from varcode.effects import structural
+
+
+@pytest.fixture
+def cftr():
+    return cached_release(81).transcript_by_id("ENST00000003084")
+
+
+@pytest.fixture
+def isolate_span(monkeypatch):
+    monkeypatch.setattr(structural, "_fusion_partners", lambda *args: ())
+    monkeypatch.setattr(structural, "_enumerate_and_attach_cryptics", lambda *args: None)
+    monkeypatch.setattr(structural, "_enumerate_and_attach_splice_outcomes", lambda *args: None)
+
+
+def _effect(transcript, cdna=None, protein=None, segments=None, evidence=None):
+    variant = StructuralVariant(transcript.contig, transcript.start, "BND",
+                                genome=transcript.genome)
+    model = MutantTranscript(
+        reference_transcript=transcript, reference_segments=segments,
+        cdna_sequence=cdna, mutant_protein_sequence=protein, evidence=evidence)
+    return StructuralVariantEffect(variant, transcript, mutant_transcript=model)
+
+
+def _identity_segments(transcript):
+    return (ReferenceSegment(transcript, 0, len(transcript.sequence)),)
+
+
+def test_seven_audited_fusion_proteins_survive_filter():
+    genome = cached_release(95)
+    transcript = genome.transcript_by_id("ENST00000538197")
+    variant = StructuralVariant("4", 15012987, "BND", alt="N[4:2664478[",
+                                mate_contig="4", mate_start=2664478, genome=genome)
+    effect = variant.effect_on_transcript(transcript)
+    fusions = [c.effect for c in effect.candidates if isinstance(c.effect, GeneFusion)]
+    assert len(fusions) == 7
+    assert all(f.mutant_protein_sequence != transcript.protein_sequence for f in fusions)
+    assert all(f.modifies_protein_sequence is True for f in fusions)
+    assert all(f.modifies_coding_sequence is True for f in fusions)
+    assert len(EffectCollection(fusions).drop_silent_and_noncoding()) == 7
+    assert list(EffectCollection([effect]).drop_silent_and_noncoding()) == [effect]
+
+
+@pytest.mark.parametrize("transcript_id", ["ENST00000003084", "ENST00000357654"])
+@pytest.mark.parametrize("region", ["coding", "start", "whole", "5utr", "3utr"])
+def test_deletion_flags_on_both_strands(transcript_id, region, isolate_span):
+    transcript = cached_release(81).transcript_by_id(transcript_id)
+    exons = transcript.exons
+    if region == "whole":
+        start, end = transcript.start, transcript.end
+    elif region == "coding":
+        start, end = exons[4].start, exons[4].end
+    elif region == "start":
+        start, end = min(transcript.start_codon_positions), max(transcript.start_codon_positions)
+    else:
+        exon = exons[0] if region == "5utr" else exons[-1]
+        at_low_end = (region == "5utr") == (transcript.strand == "+")
+        start, end = ((exon.start, exon.start + 9) if at_low_end
+                      else (exon.end - 9, exon.end))
+    variant = StructuralVariant(transcript.contig, start, "DEL", end=end,
+                                genome=transcript.genome)
+    effect = variant.effect_on_transcript(transcript)
+    assert isinstance(effect, LargeDeletion)
+    expected = region in ("coding", "start", "whole")
+    assert effect.modifies_coding_sequence is expected
+    assert effect.modifies_protein_sequence is expected
+    assert len(EffectCollection([effect]).drop_silent_and_noncoding()) == int(expected)
+
+
+@pytest.mark.parametrize("change", ["none", "utr", "synonymous", "missense", "stop"])
+def test_cds_and_protein_are_distinct_comparisons(cftr, change):
+    cdna = cftr.sequence
+    start = min(cftr.start_codon_spliced_offsets)
+    if change == "utr":
+        cdna = ("A" if cdna[0] != "A" else "C") + cdna[1:]
+    elif change == "synonymous":
+        # A GCT alanine codon changed to GCC.
+        pos = next(i for i in range(start + 3, start + 300, 3) if cdna[i:i+3] == "GCT")
+        cdna = cdna[:pos] + "GCC" + cdna[pos+3:]
+    elif change == "missense":
+        cdna = cdna[:start+3] + "TGG" + cdna[start+6:]
+    elif change == "stop":
+        pos = min(cftr.stop_codon_spliced_offsets)
+        cdna = cdna[:pos] + "TAA" + cdna[pos+3:]
+    effect = _effect(cftr, cdna=cdna, segments=_identity_segments(cftr))
+    assert effect.modifies_coding_sequence is (change in ("synonymous", "missense", "stop"))
+    assert effect.modifies_protein_sequence is (change == "missense")
+
+
+@pytest.mark.parametrize("kind", ["DUP", "INV", "BND"])
+def test_unresolved_models_are_not_silent(cftr, kind, isolate_span):
+    variant = StructuralVariant(cftr.contig, cftr.start - 100, kind,
+                                end=cftr.end - 50, genome=cftr.genome)
+    if kind == "BND":
+        effect = TranslocationToIntergenic(variant, cftr)
+    else:
+        effect = variant.effect_on_transcript(cftr)
+    assert effect.modifies_coding_sequence is None
+    assert effect.modifies_protein_sequence is None
+    collection = EffectCollection([effect], annotator="fast", annotator_version="test")
+    retained = collection.drop_silent_and_noncoding()
+    assert list(retained) == [effect]
+    assert retained.annotator == "fast"
+    assert retained.annotator_version == "test"
+    assert len(collection.drop_silent_and_noncoding(keep_unresolved=False)) == 0
+
+
+def test_partial_fragment_and_unmapped_assembly_are_unknown(cftr):
+    partial = _effect(cftr, segments=(ReferenceSegment(cftr, 0, 500),))
+    assembly = _effect(cftr, cdna=cftr.sequence)
+    for effect in (partial, assembly):
+        assert effect.modifies_protein_sequence is None
+        assert effect.modifies_coding_sequence is None
+
+
+@pytest.mark.parametrize("primary_status", [False, None])
+def test_later_changed_candidate_controls_flags_and_filter(cftr, primary_status):
+    primary = _effect(cftr, protein=cftr.protein_sequence if primary_status is False else None)
+    changed = _effect(cftr, protein=cftr.protein_sequence + "A")
+    primary._extra_candidates = (EffectCandidate(changed, source="rna", evidence={"reads": 3}),)
+    before = primary.candidates
+    assert primary.modifies_coding_sequence is True
+    assert primary.modifies_protein_sequence is True
+    assert list(EffectCollection([primary]).drop_silent_and_noncoding(False)) == [primary]
+    assert primary.candidates == before
+    assert primary.candidates[1].evidence == {"reads": 3}
+    # Self references and back edges must not recurse indefinitely.
+    changed._attach_primary_effects([primary])
+    assert primary.modifies_protein_sequence is True
+
+
+def test_unchanged_plus_unknown_is_unknown(cftr):
+    unchanged = _effect(cftr, protein=cftr.protein_sequence)
+    unknown = _effect(cftr)
+    unchanged._attach_primary_effects([unknown])
+    assert unchanged.modifies_protein_sequence is None
+    assert len(EffectCollection([unchanged]).drop_silent_and_noncoding()) == 1
+    assert len(EffectCollection([unchanged]).drop_silent_and_noncoding(False)) == 0
+
+
+def test_explicit_protein_without_cds_does_not_prove_cds_unchanged(cftr):
+    effect = _effect(cftr, protein=cftr.protein_sequence)
+    assert effect.modifies_protein_sequence is False
+    assert effect.modifies_coding_sequence is None
+    assert len(EffectCollection([effect]).drop_silent_and_noncoding()) == 0
+    effect.mutant_transcript = replace(effect.mutant_transcript, mutant_protein_sequence="")
+    assert effect.modifies_protein_sequence is True
+
+
+def test_local_duplication_is_changed(cftr, isolate_span):
+    exon = cftr.exons[4]
+    variant = StructuralVariant(cftr.contig, exon.start, "DUP", end=exon.end,
+                                genome=cftr.genome)
+    effect = variant.effect_on_transcript(cftr)
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is True
+
+
+def test_replacement_primary_effects_do_not_include_local_unknown(cftr):
+    wrapper = _effect(cftr)
+    unchanged = _effect(cftr, protein=cftr.protein_sequence)
+    wrapper._primary_effects = (unchanged,)
+    assert wrapper.modifies_protein_sequence is False
+    assert len(EffectCollection([wrapper]).drop_silent_and_noncoding()) == 0
+
+
+@pytest.mark.parametrize("synonymous", [False, True])
+def test_imported_rna_has_explicit_cds_boundaries(cftr, synonymous):
+    variant = StructuralVariant(cftr.contig, cftr.start, "BND", genome=cftr.genome)
+    start = min(cftr.start_codon_spliced_offsets)
+    cdna = cftr.sequence
+    if synonymous:
+        pos = next(i for i in range(start + 3, start + 300, 3) if cdna[i:i+3] == "GCT")
+        cdna = cdna[:pos] + "GCC" + cdna[pos+3:]
+    candidate = make_fusion_outcome(
+        variant, cftr, sequence=cdna, cds_start=start,
+        transcript_model_id="observed-model")
+    assert candidate.effect.modifies_coding_sequence is synonymous
+    assert candidate.effect.modifies_protein_sequence is False
+    assert candidate.evidence["protein_status"] == "predicted_from_observed_rna"
+
+
+def test_fusion_after_stop_is_unchanged_for_five_prime_partner(cftr):
+    partner = cached_release(81).transcript_by_id("ENST00000357654")
+    model = structural._build_fusion_mutant_transcript(
+        cftr, cftr, cftr.end - 10, partner, partner.end - 10)
+    assert model.mutant_protein_sequence == cftr.protein_sequence
+    variant = StructuralVariant(cftr.contig, cftr.end - 10, "BND", genome=cftr.genome)
+    effect = GeneFusion(variant, cftr, partner, mutant_transcript=model)
+    assert effect.modifies_coding_sequence is False
+    assert effect.modifies_protein_sequence is False
+    assert len(EffectCollection([effect]).drop_silent_and_noncoding()) == 0
+    # On the opposite end, compare the same allele with that transcript's
+    # reference, but still use the 5' partner's annotated start for the CDS.
+    other = GeneFusion(variant, partner, cftr, mutant_transcript=model,
+                       five_prime_transcript=cftr, three_prime_transcript=partner)
+    assert other.modifies_coding_sequence is True
+    assert other.modifies_protein_sequence is True
+
+
+@pytest.mark.parametrize("region", ["5utr", "3utr"])
+def test_local_utr_duplication_does_not_change_cds(cftr, region, isolate_span):
+    start = cftr.start + 10 if region == "5utr" else cftr.end - 20
+    variant = StructuralVariant(cftr.contig, start, "DUP", end=start + 5,
+                                genome=cftr.genome)
+    effect = variant.effect_on_transcript(cftr)
+    assert effect.modifies_coding_sequence is False
+    assert effect.modifies_protein_sequence is False
+
+
+def test_mitochondrial_translation_uses_correct_table():
+    transcript = cached_release(81).transcript_by_id("ENST00000361624")
+    effect = _effect(transcript, cdna=transcript.sequence,
+                     segments=_identity_segments(transcript))
+    assert effect.modifies_coding_sequence is False
+    assert effect.modifies_protein_sequence is False
+
+
+def test_ambiguous_coding_sequence_remains_unknown(cftr):
+    start = min(cftr.start_codon_spliced_offsets)
+    cdna = cftr.sequence[:start+6] + "N" + cftr.sequence[start+7:]
+    effect = _effect(cftr, cdna=cdna, segments=_identity_segments(cftr))
+    assert effect.modifies_coding_sequence is None
+    assert effect.modifies_protein_sequence is None
+
+
+def test_split_start_codon_and_deleted_start_base(cftr):
+    start = min(cftr.start_codon_spliced_offsets)
+    segments = (ReferenceSegment(cftr, 0, start + 1),
+                ReferenceSegment(cftr, start + 1, len(cftr.sequence)))
+    effect = _effect(cftr, cdna=cftr.sequence, segments=segments)
+    assert effect.modifies_protein_sequence is False
+    cut_segments = (segments[0], replace(segments[1], start=start + 2))
+    cut_cdna = cftr.sequence[:start+1] + cftr.sequence[start+2:]
+    cut = _effect(cftr, cdna=cut_cdna, segments=cut_segments)
+    # Do not translate from one retained base of a destroyed initiator.
+    assert cut.modifies_protein_sequence is None
+
+
+def test_unresolved_and_cryptic_alternatives_are_not_known_unchanged(cftr):
+    primary = _effect(cftr, protein=cftr.protein_sequence)
+    unknown = Unresolved(primary.variant, cftr, mechanism="missing_sequence")
+    cryptic = CrypticExonCandidate(primary.variant, cftr.contig, cftr.start, cftr.start + 20)
+    for alternative in (unknown, cryptic):
+        assert alternative.modifies_coding_sequence is None
+        assert alternative.modifies_protein_sequence is None
+        primary._extra_candidates = (EffectCandidate(alternative, source="test"),)
+        assert primary.modifies_protein_sequence is None
+        assert len(EffectCollection([primary]).drop_silent_and_noncoding()) == 1
+        assert len(EffectCollection([primary]).drop_silent_and_noncoding(False)) == 0
+
+
+def test_annotation_without_start_codon_remains_unresolved(cftr, monkeypatch):
+    exon = cftr.exons[4]
+    variant = StructuralVariant(cftr.contig, exon.start, "DEL", end=exon.end,
+                                genome=cftr.genome)
+    monkeypatch.setattr(type(cftr), "contains_start_codon", property(lambda self: False))
+    effect = LargeDeletion(variant, cftr, affected_exons=[exon])
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is None
+
+
+def test_annotation_without_cds_features_is_unknown(cftr, monkeypatch):
+    def missing_cds(self):
+        raise ValueError("No CDS features")
+
+    monkeypatch.setattr(type(cftr), "coding_sequence_position_ranges", property(missing_cds))
+    variant = StructuralVariant(cftr.contig, cftr.start, "DEL", end=cftr.end,
+                                genome=cftr.genome)
+    effect = LargeDeletion(variant, cftr, affected_exons=cftr.exons)
+    assert effect.modifies_coding_sequence is None
+    assert effect.modifies_protein_sequence is None
+
+
+def test_empty_and_cyclic_candidate_sets_are_unknown(cftr):
+    first, second = _effect(cftr), _effect(cftr)
+    first._primary_effects = ()
+    assert first.modifies_protein_sequence is None
+    first._primary_effects = (second,)
+    second._primary_effects = (first,)
+    assert first.modifies_protein_sequence is None

{varcode-9.2.7 → varcode-9.3.0}/varcode/effects/effect_classes.py

@@ -306,6 +306,9 @@ class Unresolved(TranscriptMutationEffect):
     unresolved does not mean the variant is harmless.
     """
 
+    modifies_coding_sequence = None
+    modifies_protein_sequence = None
+
     def __init__(self, variant, transcript, mechanism, reason=None):
         TranscriptMutationEffect.__init__(self, variant, transcript)
         self.mechanism = mechanism
@@ -1424,6 +1427,25 @@ class StructuralVariantEffect(TranscriptMutationEffect, MultiOutcomeEffect):
         return getattr(
             self.mutant_transcript, "mutant_protein_sequence", None)
 
+    @property
+    def modifies_coding_sequence(self):
+        """True if any candidate changes CDS, None if unresolved, else False.
+
+        Protein equality alone does not establish coding-sequence equality.
+        """
+        from .sequence_change import modification_status
+        return modification_status(self, "modifies_coding_sequence")
+
+    @property
+    def modifies_protein_sequence(self):
+        """True if any candidate changes protein, None if unresolved, else False.
+
+        A set with an unchanged primary and a changed alternative returns True.
+        False requires every candidate to be known unchanged; None is not silent.
+        """
+        from .sequence_change import modification_status
+        return modification_status(self, "modifies_protein_sequence")
+
     @property
     def candidates(self):
         """Unified :class:`~varcode.EffectCandidate` view over primary
@@ -1549,6 +1571,12 @@ class GeneFusion(StructuralVariantEffect):
     produce it, and so do deletions, duplications and inversions with
     one end in each gene.
 
+    The default annotator retains every compatible annotated partner isoform
+    and junction in :attr:`candidates`, with no count cap. The first is the
+    historical primary; producer order is not a probability ranking. Distinct
+    transcript pairs remain separate even when their proteins match. Missing
+    sequence leaves that candidate's transcript/protein unresolved.
+
     ``transcript`` is the transcript being annotated and
     ``partner_transcript`` the other one; ``five_prime_transcript``
     and ``three_prime_transcript`` say which is which (by default
@@ -1611,6 +1639,8 @@ class CrypticExonCandidate(MutationEffect):
     """
 
     short_description = "sv-cryptic-exon-candidate"
+    modifies_coding_sequence = None
+    modifies_protein_sequence = None
 
     def __init__(
             self, variant, contig, interval_start, interval_end,

{varcode-9.2.7 → varcode-9.3.0}/varcode/effects/effect_collection.py

@@ -220,11 +220,25 @@ class EffectCollection(Collection):
         return self.filter(
             lambda effect: effect_priority(effect) >= min_priority)
 
-    def drop_silent_and_noncoding(self):
+    def drop_silent_and_noncoding(self, keep_unresolved=True):
         """
-        Create a new EffectCollection containing only non-silent coding effects
+        Keep effects with a protein-changing candidate or unresolved SV outcome.
+
+        Parameters
+        ----------
+        keep_unresolved : bool
+            Keep effects whose protein-change status is None (default True).
+            False requires a positive prediction of protein change. Candidate
+            sets are retained intact if any alternative qualifies; their order
+            and provenance are unchanged.
         """
-        return self.filter(lambda effect: effect.modifies_protein_sequence)
+        from .sequence_change import modification_status
+
+        def retain(effect):
+            status = modification_status(effect, "modifies_protein_sequence")
+            return status is True or (keep_unresolved and status is None)
+
+        return self.filter(retain)
 
     def detailed_string(self):
         """