varcode 9.2.2__tar.gz → 9.2.4__tar.gz

{varcode-9.2.2/varcode.egg-info → varcode-9.2.4}/PKG-INFO

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

varcode-9.2.4/tests/test_bnd_retained_segments.py

@@ -0,0 +1,111 @@
+"""A BND fallback describes only its retained reference fragment (#447)."""
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import StructuralVariant, parse_symbolic_alt
+from varcode.effects import TranslocationToIntergenic
+from varcode.effects.structural import _build_translocation_mutant_transcript
+
+
+@pytest.fixture(params=["ENST00000003084", "ENST00000357654"])
+def transcript(request):
+    return cached_release(81).transcript_by_id(request.param)
+
+
+def expected_offsets(transcript, position, side):
+    """Independent per-base oracle in transcript order, including the anchor."""
+    positions = [p for exon in transcript.exons
+                 for p in (range(exon.start, exon.end + 1) if transcript.strand == "+"
+                           else range(exon.end, exon.start - 1, -1))]
+    kept = [i for i, p in enumerate(positions)
+            if (p <= position if side == "left" else p >= position)]
+    return min(kept), max(kept) + 1
+
+
+@pytest.mark.parametrize("alt,side", [
+    ("N[22:15500000[", "left"), ("N]22:15500000]", "left"),
+    ("[22:15500000[N", "right"), ("]22:15500000]N", "right"),
+    ("ACGT.", "left"), (".ACGT", "right"),
+])
+@pytest.mark.parametrize("location", ["exonic", "exon_start", "exon_end", "intronic"])
+def test_both_strands_and_local_sides(transcript, alt, side, location):
+    # An interior exon also permits meaningful suffix/prefix comparisons.
+    exon = transcript.exons[2]
+    if location == "exonic":
+        position = (exon.start + exon.end) // 2
+    elif location == "exon_start":
+        position = exon.start
+    elif location == "exon_end":
+        position = exon.end
+    else:
+        other = transcript.exons[3]
+        position = ((exon.end + other.start) // 2 if transcript.strand == "+"
+                    else (other.end + exon.start) // 2)
+    sv = parse_symbolic_alt(transcript.contig, position, "N", alt,
+                            genome=transcript.genome)
+    effect = sv.effect_on_transcript(transcript)
+    assert isinstance(effect, TranslocationToIntergenic)
+    mt = effect.mutant_transcript
+    assert mt is not None
+    (segment,) = mt.reference_segments
+    assert segment.source is transcript
+    assert (segment.start, segment.end) == expected_offsets(transcript, position, side)
+    assert segment.strand == "+"  # source is already oriented transcript cDNA
+    five_prime = (side == "left") == (transcript.strand == "+")
+    assert segment.label == ("translocation_5p" if five_prime else "translocation_3p")
+    assert segment.length < len(transcript.sequence)
+    assert mt.cdna_sequence is None
+    assert mt.mutant_protein_sequence is None
+    assert mt.evidence["sequence_status"] == "retained_reference_fragment"
+
+
+def test_cftr_regression_keeps_51_bases_not_entire_transcript():
+    tx = cached_release(81).transcript_by_id("ENST00000003084")
+    sv = parse_symbolic_alt("7", tx.exons[0].start + 50, "N", "N]22:15500000]",
+                            genome=tx.genome)
+    mt = sv.effect_on_transcript(tx).mutant_transcript
+    (segment,) = mt.reference_segments
+    assert (segment.start, segment.end) == (0, 51)
+    assert segment.source.sequence[segment.start:segment.end] == tx.sequence[:51]
+
+
+@pytest.mark.parametrize("alt", [None, "<BND>", "N[?:?[", "N[22:15500000]", ".", "N.N"])
+def test_unknown_local_orientation_is_unresolved(transcript, alt):
+    sv = StructuralVariant(transcript.contig, transcript.exons[0].start + 5,
+                           "BND", alt=alt, genome=transcript.genome)
+    assert sv.effect_on_transcript(transcript).mutant_transcript is None
+
+
+@pytest.mark.parametrize("orientation", ["[[", "]]"])
+def test_mate_orientation_does_not_determine_local_side(transcript, orientation):
+    sv = StructuralVariant(transcript.contig, transcript.exons[0].start + 5,
+                           "BND", mate_contig="22", mate_start=15_500_000,
+                           mate_orientation=orientation, genome=transcript.genome)
+    with pytest.warns(UserWarning, match="can't read the breakend orientation"):
+        effect = sv.effect_on_transcript(transcript)
+    assert isinstance(effect, TranslocationToIntergenic)
+    assert effect.mutant_transcript is None
+
+
+@pytest.mark.parametrize("location", ["before", "after", "wrong_contig"])
+def test_unrelated_transcript_does_not_supply_a_segment(transcript, location):
+    position = {"before": transcript.start - 1, "after": transcript.end + 1,
+                "wrong_contig": transcript.start + 5}[location]
+    contig = "1" if location == "wrong_contig" else transcript.contig
+    sv = StructuralVariant(contig, position, "BND", alt="N.", genome=transcript.genome)
+    assert _build_translocation_mutant_transcript(sv, transcript) is None
+
+
+@pytest.mark.parametrize("alt", ["N]22:15500000]", "]22:15500000]N", "N.", ".N", "<BND>"])
+def test_supplied_assembly_is_unchanged(transcript, alt):
+    assembly = "ATGGCTTAA"
+    sv = StructuralVariant(transcript.contig, transcript.exons[0].start + 5,
+                           "BND", alt=alt, alt_assembly=assembly, genome=transcript.genome)
+    mt = sv.effect_on_transcript(transcript).mutant_transcript
+    assert mt.cdna_sequence == assembly
+    assert mt.mutant_protein_sequence is None
+    assert mt.evidence == {"source": "alt_assembly"}
+    (segment,) = mt.reference_segments
+    assert segment.source.sequence == assembly
+    assert (segment.start, segment.end, segment.label) == (0, len(assembly), "alt_assembly")

varcode-9.2.4/tests/test_nonlocal_sv_transcripts.py

@@ -0,0 +1,83 @@
+"""A partial overlap cannot establish a local DUP/INV transcript (#405)."""
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import StructuralVariant, parse_symbolic_alt
+from varcode.effects import Inversion, LargeDuplication
+from varcode.effects import structural
+
+
+@pytest.fixture(params=["ENST00000003084", "ENST00000357654"])
+def transcript(request):
+    return cached_release(81).transcript_by_id(request.param)
+
+
+@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, "_enumerate_and_attach_cryptics", lambda *args: None)
+    monkeypatch.setattr(structural, "_enumerate_and_attach_splice_outcomes", lambda *args: None)
+
+
+def make_sv(transcript, kind, outside, symbolic=False, assembly=None):
+    start, end = transcript.start + 50, transcript.end - 50
+    if outside in ("left", "both"):
+        start = transcript.start - 100
+    if outside in ("right", "both"):
+        end = transcript.end + 100
+    if symbolic:
+        return parse_symbolic_alt(
+            transcript.contig, start, "N", "<%s>" % kind,
+            info={"END": end}, genome=transcript.genome)
+    return StructuralVariant(
+        transcript.contig, start, kind, end=end,
+        genome=transcript.genome, alt_assembly=assembly)
+
+
+@pytest.mark.parametrize("kind,cls", [("DUP", LargeDuplication), ("INV", Inversion)])
+@pytest.mark.parametrize("outside", ["left", "right", "both"])
+@pytest.mark.parametrize("symbolic", [False, True])
+def test_nonlocal_event_keeps_type_without_inventing_transcript(
+        transcript, kind, cls, outside, symbolic):
+    sv = make_sv(transcript, kind, outside, symbolic)
+    effect = sv.effect_on_transcript(transcript)
+    assert isinstance(effect, cls)
+    assert effect.mutant_transcript is None
+    assert all(c.effect.mutant_transcript is None for c in effect.candidates)
+
+
+@pytest.mark.parametrize("kind", ["DUP", "INV"])
+@pytest.mark.parametrize("outside", ["left", "right", "both"])
+def test_nonlocal_event_preserves_supplied_assembly(transcript, kind, outside):
+    assembly = "ATG" + "GCT" * 10 + "TAA"
+    sv = make_sv(transcript, kind, outside, assembly=assembly)
+    effect = sv.effect_on_transcript(transcript)
+    assert effect.mutant_transcript.cdna_sequence == assembly
+
+
+@pytest.mark.parametrize("kind", ["DUP", "INV"])
+def test_wholly_internal_event_retains_local_model(transcript, kind):
+    sv = make_sv(transcript, kind, outside=None)
+    effect = sv.effect_on_transcript(transcript)
+    assert effect.mutant_transcript is not None
+    if kind == "DUP":
+        assert len(effect.mutant_transcript.cdna_sequence) > len(transcript.sequence)
+    else:
+        assert any(s.strand == "-" for s in effect.mutant_transcript.reference_segments)
+
+
+@pytest.mark.parametrize("transcript_id", ["ENST00000439541", "ENST00000550411"])
+@pytest.mark.parametrize("kind", ["DUP", "INV"])
+def test_gene_containment_does_not_establish_short_isoform_structure(transcript_id, kind):
+    # CBX5's long isoform spans both ends, but these short isoforms do not.
+    genome = cached_release(95)
+    tx = genome.transcript_by_id(transcript_id)
+    sv = StructuralVariant("12", 54_259_010, kind, end=54_262_307, genome=genome)
+    ends = [end for junction in sv.junctions for end in junction]
+    assert all(structural._contains(tx.gene, end) for end in ends)
+    assert any(not structural._contains(tx, end) for end in ends)
+    effect = sv.effect_on_transcript(tx)
+    assert isinstance(effect, (LargeDuplication, Inversion))
+    assert effect.mutant_transcript is None

{varcode-9.2.2 → varcode-9.2.4}/tests/test_osteosarc_fusions.py

@@ -48,7 +48,7 @@ from varcode import StructuralVariant, FastEffectAnnotator, load_vcf
 from varcode.effects.structural import (
     _build_fusion_mutant_transcript,
 )
-from varcode.effects import GeneFusion, Intronic
+from varcode.effects import GeneFusion, Intronic, Inversion, LargeDuplication
 from varcode.transforms import pair_breakends
 
 from .data import data_path
@@ -267,6 +267,10 @@ def test_esvee_vcf_otx1_kif3c_inversion_is_fusion_on_both_partners():
             assert fusion.three_prime_transcript.id == kif3c.id
             assert fusion.mutant_transcript.mutant_protein_sequence == (
                 "MMSYLKQPPYGMNGLGLAGPAMDLLHPSVGYPETS")
+            if sv.sv_type == "INV":
+                (span,) = [c.effect for c in fusion.candidates
+                           if isinstance(c.effect, Inversion)]
+                assert span.mutant_transcript is None
 
 
 def test_esvee_vcf_cpeb2_fam193a_duplication_is_fusion():
@@ -290,6 +294,10 @@ def test_esvee_vcf_cpeb2_fam193a_duplication_is_fusion():
     assert isinstance(on_fam193a, GeneFusion)
     assert on_fam193a.three_prime_transcript.id == fam193a.id
     assert on_fam193a.five_prime_transcript.gene_name == "CPEB2"
+    for fusion in (on_cpeb2, on_fam193a):
+        (span,) = [c.effect for c in fusion.candidates
+                   if isinstance(c.effect, LargeDuplication)]
+        assert span.mutant_transcript is None
 
 
 def test_esvee_vcf_sema6a_parm1_fusion_from_either_record():

{varcode-9.2.2 → varcode-9.2.4}/tests/test_symbolic_sv_padding.py

@@ -37,7 +37,7 @@ def test_no_nonempty_span_cannot_delete_or_copy_the_anchor(kind, info):
 def test_exact_mutant_cdna_on_both_strands(kind, builder, reverse):
     sequence = "ACGTTGCAAGCTTAGGCTAC"
     tx = SimpleNamespace(exons=[SimpleNamespace(start=100, end=119)],
-                         start=100, end=119, sequence=sequence,
+                         contig="1", start=100, end=119, sequence=sequence,
                          on_backward_strand=reverse)
     sv = parse_symbolic_alt("1", 109, "G", "<%s>" % kind, info={"END": 114})
     a, b = (5, 10) if reverse else (10, 15)

{varcode-9.2.2 → varcode-9.2.4}/varcode/effects/structural.py

@@ -35,7 +35,7 @@ from .effect_helpers import exon_length
 from ..mutant_transcript import MutantTranscript, ReferenceSegment
 # Existing assembled-SV pickles use this private module path.
 from ..mutant_transcript import _AssembledAllele  # noqa: F401
-from ..sv_allele_parser import breakend_sides
+from ..sv_allele_parser import breakend_sides, _breakend_local_side
 
 
 # --------------------------------------------------------------------
@@ -126,9 +126,15 @@ def _cdna_ranges_kept_after_deletion(variant, transcript):
 
 
 def _cdna_ranges_within_sv(variant, transcript):
-    """cDNA ranges that fall INSIDE the SV span (used for DUP to
-    derive the duplicated body and for INV to derive the flipped
-    middle)."""
+    """Body ranges for a local DUP/INV model, or [] if not local.
+
+    Clipping a cross-boundary event to this transcript invents a local
+    rearrangement (#405). Every junction end must be in this transcript,
+    not merely in its gene. Fusion and supplied-assembly paths are separate.
+    """
+    if any(not _contains(transcript, end)
+           for junction in variant.junctions for end in junction):
+        return []
     sv_start, sv_end = _affected_span(variant)
     inside = []
     reverse = transcript.on_backward_strand
@@ -495,23 +501,29 @@ def _build_fusion_mutant_transcript(
 
 
 def _build_translocation_mutant_transcript(variant, transcript):
-    """Build a :class:`MutantTranscript` for a BND classified as
-    :class:`TranslocationToIntergenic`.
+    """Describe only the retained local reference fragment of a BND.
 
-    One segment covering the (this-side) transcript up to the
-    breakpoint. Intergenic space beyond the breakpoint isn't
-    representable as a transcript source; #338 and #341 extend this
-    with caller-supplied genomic intervals / long-read assemblies.
+    The other side and full mutant cDNA/protein remain unknown. Without
+    local orientation or a breakpoint on this transcript, no fragment can
+    be established. Supplied assemblies are handled by the caller.
     """
+    side = _breakend_local_side(variant.symbolic_alt)
+    if (side is None or str(variant.contig) != str(transcript.contig)
+            or not transcript.start <= variant.start <= transcript.end):
+        return None
+    keep_five_prime = _retains_five_prime_end(transcript, side)
+    cut = _cdna_cut(transcript, variant.start, keep_five_prime)
     full_len = len(str(transcript.sequence))
+    start, end = (0, cut) if keep_five_prime else (cut, full_len)
     segments = (
         ReferenceSegment(
-            source=transcript, start=0, end=full_len,
-            strand="+", label="translocation_5p"),)
+            source=transcript, start=start, end=end, strand="+",
+            label="translocation_5p" if keep_five_prime else "translocation_3p"),)
     return MutantTranscript(
         reference_transcript=transcript,
         reference_segments=segments,
         cdna_sequence=None,
+        evidence={"sequence_status": "retained_reference_fragment"},
         annotator_name="structural_variant")
 
 

{varcode-9.2.2 → varcode-9.2.4}/varcode/mutant_transcript.py

@@ -232,7 +232,10 @@ class MutantTranscript(DataclassSerializable):
     strand segments), produce the mutant cDNA. ``None`` for the
     point-variant shape; a fusion's segments would be
     ``(5p_partner_segment, 3p_partner_segment)``. Coordinates are
-    in each segment's own reference system."""
+    in each segment's own reference system. A partial structural model may
+    describe only a retained reference fragment: its producer identifies this
+    in ``evidence`` and leaves the full ``cdna_sequence`` unknown. Concatenating
+    those partial segments does not establish a full allele."""
 
     cdna_sequence: Optional[str] = None
     """The mutated spliced mRNA, when computed. ``None`` if the

{varcode-9.2.2 → varcode-9.2.4}/varcode/sv_allele_parser.py

@@ -78,6 +78,17 @@ def breakend_sides(alt):
     return this_side, mate_side
 
 
+def _breakend_local_side(alt):
+    """The retained local side, including single breakends with no mate."""
+    sides = breakend_sides(alt)
+    if sides is not None:
+        return sides[0]
+    single = _SINGLE_BREAKEND_RE.match(alt or "")
+    if single is not None:
+        return "right" if single.group("joined_before") else "left"
+    return None
+
+
 def _extract_info(info, key):
     """Pull an INFO field value, handling list-of-ints from CIPOS /
     CIEND and plain ints/strings otherwise. Returns ``None`` if

varcode-9.2.4/varcode/version.py

@@ -0,0 +1 @@
+__version__ = "9.2.4"

{varcode-9.2.2 → varcode-9.2.4/varcode.egg-info}/PKG-INFO

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

{varcode-9.2.2 → varcode-9.2.4}/varcode.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ requirements.txt
 tests/test_annotator_divergence_scenarios.py
 tests/test_annotator_parity_adversarial.py
 tests/test_annotators.py
+tests/test_bnd_retained_segments.py
 tests/test_cli_effects.py
 tests/test_cli_genes.py
 tests/test_cli_without_pkg_resources.py
@@ -45,6 +46,7 @@ tests/test_mouse.py
 tests/test_mutant_transcript.py
 tests/test_mutate.py
 tests/test_no_duplicate_variants.py
+tests/test_nonlocal_sv_transcripts.py
 tests/test_osteosarc_fusions.py
 tests/test_partial_annotators.py
 tests/test_premature_stop_short_description.py

varcode-9.2.2/varcode/version.py

@@ -1 +0,0 @@
-__version__ = "9.2.2"