varcode 9.2.0__tar.gz → 9.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: varcode
-Version: 9.2.0
+Version: 9.2.2
 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/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.2/tests/test_symbolic_sv_padding.py

@@ -0,0 +1,81 @@
+"""Symbolic POS is retained; only POS+1..END changes (#404, VCF 4.3)."""
+
+from types import SimpleNamespace
+
+import pytest
+from pyensembl import cached_release
+
+from varcode import StructuralVariant, parse_symbolic_alt, load_vcf
+from varcode.effects.structural import (
+    _build_deletion_mutant_transcript, _build_duplication_mutant_transcript,
+    _build_inversion_mutant_transcript,
+)
+from varcode.nucleotides import reverse_complement
+
+
+@pytest.mark.parametrize("kind", ["DEL", "DUP", "INV", "CNV", "CN0", "CN3"])
+def test_parsed_span_excludes_padding_but_keeps_record_coordinates(kind):
+    sv = parse_symbolic_alt("1", 100, "T", "<%s>" % kind, info={"END": 105})
+    assert (sv.start, sv.end) == (100, 105)
+    assert (sv.affected_start, sv.affected_end, sv.length) == (101, 105, 5)
+    assert StructuralVariant.from_json(sv.to_json()) == sv
+
+
+@pytest.mark.parametrize("kind", ["DEL", "DUP", "INV", "CNV"])
+@pytest.mark.parametrize("info", [{}, {"END": 100}, {"END": 99}])
+def test_no_nonempty_span_cannot_delete_or_copy_the_anchor(kind, info):
+    with pytest.raises(ValueError, match="END greater than POS"):
+        parse_symbolic_alt("1", 100, "T", "<%s>" % kind, info=info)
+
+
+@pytest.mark.parametrize("reverse", [False, True])
+@pytest.mark.parametrize("kind,builder", [
+    ("DEL", _build_deletion_mutant_transcript),
+    ("DUP", _build_duplication_mutant_transcript),
+    ("INV", _build_inversion_mutant_transcript),
+])
+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,
+                         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)
+    if kind == "DEL":
+        expected = sequence[:a] + sequence[b:]
+    elif kind == "DUP":
+        expected = sequence[:b] + sequence[a:b] + sequence[b:]
+    else:
+        expected = sequence[:a] + reverse_complement(sequence[a:b]) + sequence[b:]
+    model = builder(sv, tx)
+    if kind == "INV":
+        # This builder preserves the layout but intentionally defers sequence.
+        observed = "".join(reverse_complement(sequence[s.start:s.end])
+                           if s.strand == "-" else sequence[s.start:s.end]
+                           for s in model.reference_segments)
+        assert observed == expected
+    else:
+        assert model.cdna_sequence == expected
+
+
+def test_vcf_deletion_does_not_remove_cftr_exon_terminal_anchor(tmp_path):
+    genome = cached_release(81)
+    tx = genome.transcript_by_id("ENST00000003084")
+    first, second = tx.exons[:2]
+    path = tmp_path / "anchor.vcf"
+    path.write_text(
+        "##fileformat=VCFv4.3\n"
+        "##INFO=<ID=END,Number=1,Type=Integer,Description=\"End\">\n"
+        "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\n"
+        "7\t%d\t.\tT\t<DEL>\t.\tPASS\tEND=%d\n" % (first.end, second.end))
+    (sv,) = load_vcf(str(path), genome=genome, parse_structural_variants=True)
+    effect = sv.effect_on_transcript(tx)
+    assert first not in effect.affected_exons
+    assert second in effect.affected_exons
+    a, b = first.end - first.start + 1, second.end - second.start + 1
+    assert effect.mutant_transcript.cdna_sequence == tx.sequence[:a] + tx.sequence[a+b:]
+
+
+def test_direct_constructor_span_defaults_remain_explicit():
+    sv = StructuralVariant("1", 100, "DEL", end=105)
+    assert (sv.affected_start, sv.affected_end, sv.length) == (100, 105, 6)

{varcode-9.2.0 → varcode-9.2.2}/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.0 → varcode-9.2.2}/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.0 → varcode-9.2.2}/varcode/structural_variant.py

@@ -179,8 +179,8 @@ class StructuralVariant(Variant):
 
     The SV position model:
 
-    * :attr:`start` — 1-based start of the affected region
-      (matches VCF POS).
+    * :attr:`start` — 1-based event/record position (matches VCF POS).
+      For parsed symbolic spans this is the retained padding base.
     * :attr:`end` — 1-based *inclusive* end. For a DEL/DUP/INV/CNV
       this is the SV endpoint on the same contig. For an INS it
       equals start (insertions are zero-width in reference coords).
@@ -188,8 +188,8 @@ class StructuralVariant(Variant):
       :attr:`mate_contig` / :attr:`mate_start`.
     * :attr:`affected_start` / :attr:`affected_end` — inclusive bases
       changed by a span event. These normally equal ``start`` / ``end``;
-      paired breakend events use them to exclude retained VCF padding
-      bases from exon and mutant-sequence annotation.
+      parsed symbolic spans and paired breakend events use them to exclude
+      retained VCF padding bases from exon and mutant-sequence annotation.
 
     Parameters
     ----------
@@ -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.0 → varcode-9.2.2}/varcode/sv_allele_parser.py

@@ -198,10 +198,20 @@ def parse_symbolic_alt(
         if copy_number is not None:
             sv_info["copy_number"] = copy_number
 
+        # VCF symbolic POS is the retained padding base before the event.
+        # Keep record/junction coordinates unchanged; span consumers already
+        # use affected_start/end for paired breakends (#404).
+        affected_start = None
+        if top in {"DEL", "DUP", "INV", "CNV"}:
+            if int(end) <= int(start):
+                raise ValueError("A symbolic %s requires END greater than POS" % top)
+            affected_start = int(start) + 1
+
         return StructuralVariant(
             contig=contig,
             start=int(start),
             end=int(end),
+            affected_start=affected_start,
             sv_type=top,
             alt=alt,
             ref=ref or "N",

{varcode-9.2.0 → varcode-9.2.2}/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.2/varcode/version.py

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

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

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

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

@@ -68,7 +68,9 @@ 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
 tests/test_transcript_layout.py
 tests/test_transcript_model.py

varcode-9.2.0/varcode/version.py

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