varcode 9.2.1__tar.gz → 9.2.3__tar.gz

{varcode-9.2.1/varcode.egg-info → varcode-9.2.3}/PKG-INFO

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

varcode-9.2.3/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.1 → varcode-9.2.3}/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.3/tests/test_sv_tabular_metadata.py

@@ -0,0 +1,69 @@
+"""Structural records must never masquerade as placeholder SNVs (#417)."""
+
+import pickle
+
+import pytest
+
+from varcode import StructuralVariant, Variant, VariantCollection
+from varcode.csv_helpers import STRUCTURAL_VARIANT_COLUMNS
+from varcode.effects import EffectCollection, Intergenic
+
+
+@pytest.mark.parametrize("ref", ["A", "C", "G", "T", "N"])
+@pytest.mark.parametrize("kind,alt", [
+    ("DEL", "<DEL>"), ("DUP", "<DUP>"), ("INV", "<INV>"),
+    ("CNV", "<CN3>"), ("INS", "<INS:ME:ALU>"),
+    ("BND", "G[2:200["), ("BND", ".ACGT"), ("INS", "ACGT"),
+])
+def test_actual_alleles_and_no_small_edit_flags(ref, kind, alt):
+    sv = StructuralVariant("1", 100, kind, end=200, ref=ref, alt=alt)
+    assert sv.start == sv.original_start == 100
+    assert sv.ref == sv.original_ref == ref
+    assert sv.alt == sv.original_alt == sv.symbolic_alt == alt
+    for name in ["is_snv", "is_indel", "is_insertion", "is_deletion",
+                 "is_transition", "is_transversion"]:
+        assert getattr(sv, name) is False
+    assert sv.is_structural
+    for restored in [StructuralVariant.from_json(sv.to_json()), pickle.loads(pickle.dumps(sv))]:
+        assert restored == sv
+        assert (restored.ref, restored.alt) == (ref, alt)
+
+
+def examples():
+    snv = Variant("1", 50, "C", "T")
+    sv = StructuralVariant("1", 100, "DEL", end=200, ref="T", affected_start=101,
+                           mate_contig="2", mate_start=300)
+    for variant in [snv, sv]:
+        variant._gene_names = []
+        variant._gene_ids = []
+    return snv, sv
+
+
+@pytest.mark.parametrize("effects", [False, True])
+def test_mixed_tables_retain_structural_coordinates(effects, tmp_path):
+    snv, sv = examples()
+    collection = (EffectCollection([Intergenic(snv), Intergenic(sv)], sort_key=False)
+                  if effects else VariantCollection([snv, sv]))
+    df = collection.to_dataframe()
+    assert list(df.columns) == list(collection._DATAFRAME_COLUMNS + STRUCTURAL_VARIANT_COLUMNS)
+    row = df.iloc[1]
+    assert (row["ref"], row["alt"], row["sv_type"]) == ("T", "<DEL>", "DEL")
+    assert (row["start"], row["end"], row["affected_start"], row["affected_end"]) == (100, 200, 101, 200)
+    assert (row["mate_contig"], row["mate_start"]) == ("2", 300)
+    if effects:
+        assert not row["is_snv"] and not row["is_transition"] and not row["is_transversion"]
+        assert df.iloc[0]["is_snv"] and df.iloc[0]["is_transition"]
+    path = tmp_path / "mixed.csv"
+    collection.to_csv(str(path))
+    with pytest.raises(ValueError, match="Structural rows cannot be reconstructed"):
+        type(collection).from_csv(str(path))
+
+
+@pytest.mark.parametrize("effects", [False, True])
+@pytest.mark.parametrize("empty", [False, True])
+def test_point_only_and_empty_schemas_unchanged(effects, empty):
+    snv, _ = examples()
+    variants = [] if empty else [snv]
+    collection = (EffectCollection([Intergenic(v) for v in variants]) if effects
+                  else VariantCollection(variants))
+    assert tuple(collection.to_dataframe().columns) == collection._DATAFRAME_COLUMNS

{varcode-9.2.1 → varcode-9.2.3}/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.1 → varcode-9.2.3}/varcode/csv_helpers.py

@@ -39,6 +39,18 @@ HEADER_PREFIX = "#"
 # openvax/varcode#274.
 CONTIG_COLUMN_ALIASES = ("contig", "chr")
 
+STRUCTURAL_VARIANT_COLUMNS = (
+    "sv_type", "end", "mate_contig", "mate_start", "affected_start", "affected_end",
+)
+
+
+def reject_structural_csv(df):
+    """CSV summaries do not encode enough state to restore structural effects."""
+    if "sv_type" in df and df["sv_type"].fillna("").ne("").any():
+        raise ValueError(
+            "Structural rows cannot be reconstructed from CSV summaries. "
+            "Retain the original VCF/JSON variants and RNA evidence instead.")
+
 
 def resolve_contig_column(columns):
     """Return the first of :data:`CONTIG_COLUMN_ALIASES` that appears in

{varcode-9.2.1 → varcode-9.2.3}/varcode/effects/effect_collection.py

@@ -17,7 +17,9 @@ from sercol import Collection
 
 from ..csv_helpers import (
     CONTIG_COLUMN_ALIASES,
+    STRUCTURAL_VARIANT_COLUMNS,
     read_metadata_header,
+    reject_structural_csv,
     resolve_contig_column,
     warn_on_version_drift,
     write_metadata_header,
@@ -344,6 +346,8 @@ class EffectCollection(Collection):
 
     def to_dataframe(self):
         """Build a dataframe from the effect collection."""
+        structural_columns = STRUCTURAL_VARIANT_COLUMNS if any(
+            getattr(e.variant, "is_structural", False) for e in self) else ()
         # list of properties to extract from Variant objects if they're
         # not None
         variant_properties = [
@@ -354,7 +358,7 @@ class EffectCollection(Collection):
             "is_snv",
             "is_transversion",
             "is_transition"
-        ]
+        ] + list(structural_columns)
 
         def row_from_effect(effect):
             row = OrderedDict()
@@ -375,7 +379,7 @@ class EffectCollection(Collection):
         # CSV round-trip doesn't have to special-case len == 0.
         return pd.DataFrame.from_records(
             [row_from_effect(effect) for effect in self],
-            columns=self._DATAFRAME_COLUMNS,
+            columns=self._DATAFRAME_COLUMNS + structural_columns,
         )
 
     def to_csv(self, path, include_header=True):
@@ -485,6 +489,7 @@ class EffectCollection(Collection):
         # dtype is a no-op for whichever column is absent.
         df = pd.read_csv(
             path, comment="#", dtype={"chr": str, "contig": str})
+        reject_structural_csv(df)
         contig_col = resolve_contig_column(df.columns)
         if contig_col is None:
             raise ValueError(

{varcode-9.2.1 → varcode-9.2.3}/varcode/effects/structural.py

@@ -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

{varcode-9.2.1 → varcode-9.2.3}/varcode/structural_variant.py

@@ -242,6 +242,15 @@ class StructuralVariant(Variant):
         event coordinates include a retained padding base.
     """
 
+    # These flags describe literal small edits, not event classes. Consumers
+    # must use is_structural/sv_type instead of interpreting symbolic alleles.
+    is_snv = False
+    is_indel = False
+    is_insertion = False
+    is_deletion = False
+    is_transition = False
+    is_transversion = False
+
     __slots__ = (
         "sv_type",
         "mate_contig",
@@ -288,14 +297,14 @@ class StructuralVariant(Variant):
 
         # Initialize the base Variant with a placeholder ref/alt so the
         # nucleotide-normalization path doesn't reject <DEL>-style
-        # symbolic alleles. The original symbolic ALT is preserved in
-        # ``_sv_alt``; :attr:`alt` returns it via a property override.
+        # symbolic alleles. Restore the actual record fields below; placeholder
+        # normalization must not leak into public alleles or exports (#417).
         Variant.__init__(
             self,
             contig=contig,
             start=start,
             ref=ref if ref else "N",
-            alt="A" if ref == "N" else "A",  # placeholder, overridden below
+            alt="A",
             genome=genome,
             ensembl=ensembl,
             allow_extended_nucleotides=True,
@@ -325,6 +334,9 @@ class StructuralVariant(Variant):
         # Preserve the original symbolic ALT string so round-tripping
         # and downstream consumers see what the VCF said.
         self._sv_alt = alt if alt is not None else "<%s>" % sv_type
+        self.ref = self.original_ref
+        self.alt = self.original_alt = self._sv_alt
+        self.start = self.original_start = int(start)
 
         # Caches, like Variant's overlapping-gene / transcript caches:
         # the junction list derived from the fields above, and results

{varcode-9.2.1 → varcode-9.2.3}/varcode/variant_collection.py

@@ -19,7 +19,9 @@ from .effects import EffectCollection
 from .common import memoize
 from .csv_helpers import (
     CONTIG_COLUMN_ALIASES,
+    STRUCTURAL_VARIANT_COLUMNS,
     read_metadata_header,
+    reject_structural_csv,
     resolve_contig_column,
     warn_on_version_drift,
     write_metadata_header,
@@ -434,8 +436,10 @@ class VariantCollection(Collection):
 
     def to_dataframe(self):
         """Build a DataFrame from this variant collection."""
+        structural_columns = STRUCTURAL_VARIANT_COLUMNS if any(
+            getattr(v, "is_structural", False) for v in self) else ()
         def row_from_variant(variant):
-            return OrderedDict([
+            row = OrderedDict([
                 ("chr", variant.contig),
                 ("start", variant.original_start),
                 ("ref", variant.original_ref),
@@ -443,11 +447,13 @@ class VariantCollection(Collection):
                 ("gene_name", ";".join(variant.gene_names)),
                 ("gene_id", ";".join(variant.gene_ids))
             ])
+            row.update((name, getattr(variant, name, None)) for name in structural_columns)
+            return row
         rows = [row_from_variant(v) for v in self]
         # Always return a DataFrame with the expected columns, even
         # when empty, so downstream code (CSV round-trip, joins) doesn't
         # have to special-case len == 0.
-        return pd.DataFrame.from_records(rows, columns=self._DATAFRAME_COLUMNS)
+        return pd.DataFrame.from_records(rows, columns=self._DATAFRAME_COLUMNS + structural_columns)
 
     def to_csv(self, path, include_header=True):
         """Write this collection to CSV.
@@ -541,6 +547,7 @@ class VariantCollection(Collection):
         # dtype is a no-op for whichever column is absent.
         df = pd.read_csv(
             path, comment="#", dtype={"chr": str, "contig": str})
+        reject_structural_csv(df)
         contig_col = resolve_contig_column(df.columns)
         if contig_col is None:
             raise ValueError(

varcode-9.2.3/varcode/version.py

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

{varcode-9.2.1 → varcode-9.2.3/varcode.egg-info}/PKG-INFO

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

{varcode-9.2.1 → varcode-9.2.3}/varcode.egg-info/SOURCES.txt

@@ -45,6 +45,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
@@ -68,6 +69,7 @@ tests/test_stop_codon_classification_bugs.py
 tests/test_string_helpers.py
 tests/test_structural_variant_annotator.py
 tests/test_structural_variants.py
+tests/test_sv_tabular_metadata.py
 tests/test_symbolic_alleles.py
 tests/test_symbolic_sv_padding.py
 tests/test_timings.py

varcode-9.2.1/varcode/version.py

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