varcode 9.2.8__tar.gz → 9.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: varcode
-Version: 9.2.8
+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.8 → 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])

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.8 → 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
@@ -1617,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.8 → 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):
         """

varcode-9.3.0/varcode/effects/sequence_change.py

@@ -0,0 +1,142 @@
+"""Sequence-change flags for existing SV predictions, not a new SV model."""
+
+from .codon_tables import codon_table_for_transcript, translate_sequence
+
+
+def modification_status(effect, attribute):
+    """Any changed candidate wins; otherwise unknown wins over unchanged.
+
+    Walk by identity because SVs include themselves among their candidates.
+    Read their local status directly, avoiding recursive property calls.
+    """
+    from .effect_classes import MultiOutcomeEffect, StructuralVariantEffect
+
+    pending, seen = [effect], set()
+    unknown = False
+    evaluated = False
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        candidates = (current.candidates
+                      if isinstance(current, MultiOutcomeEffect) else ())
+        if isinstance(current, StructuralVariantEffect):
+            if any(candidate.effect is current for candidate in candidates):
+                evaluated = True
+                coding, protein = structural_sequence_changes(current)
+                status = protein if attribute == "modifies_protein_sequence" else coding
+            else:
+                # An explicit primary_effects tuple replaces the local result.
+                status = False if candidates else None
+        else:
+            evaluated = True
+            status = getattr(current, attribute)
+        if status is True:
+            return True
+        unknown |= status is None
+        pending.extend(candidate.effect for candidate in candidates)
+    return None if unknown or not evaluated else False
+
+
+def _retained_start(model, transcript):
+    """Map all three annotated start bases, including split segment boundaries."""
+    positions = [set(), set(), set()]
+    start = min(transcript.start_codon_spliced_offsets)
+    offset = 0
+    for segment in model.reference_segments or ():
+        if segment.source == transcript and segment.strand == "+":
+            for i in range(3):
+                if segment.start <= start + i < segment.end:
+                    positions[i].add(offset + start + i - segment.start)
+        offset += segment.length
+    return next((p for p in sorted(positions[0])
+                 if p + 1 in positions[1] and p + 2 in positions[2]), None)
+
+
+def _coding_sequence(model, initiator):
+    """Read a known ORF, or the retained reference ORF; never search for one.
+
+    Return None for unmapped assemblies, partial fragments, missing sequence,
+    overlaid edits whose coordinates haven't been mapped, or an incomplete ORF.
+    """
+    if model.cdna_sequence is None:
+        return None
+    evidence = model.evidence or {}
+    start, end = evidence.get("cds_start"), evidence.get("cds_end")
+    if start is None or end is None:
+        if not initiator.complete or model.edits:
+            return None
+        start = _retained_start(model, initiator)
+        end = None
+    if start is None:
+        return None
+    sequence = model.cdna_sequence[start:end].upper()
+    table = codon_table_for_transcript(initiator)
+    if sequence[:3] not in table.start_codons:
+        return None
+    for i in range(3, len(sequence) - 2, 3):
+        if sequence[i:i + 3] in table.stop_codons:
+            coding = sequence[:i + 3]
+            return coding if not set(coding) - set("ACGT") else None
+    return None
+
+
+def structural_sequence_changes(effect):
+    """Return local (coding, protein) changes as True / False / None.
+
+    Compare against the transcript being annotated, including on a fusion's
+    3' side. The 5' partner supplies the initiation site and translation table.
+    These are sequence predictions, not evidence of expression or translation.
+    """
+    from .effect_classes import LargeDeletion
+
+    transcript = effect.transcript
+    model = effect.mutant_transcript
+    coding_status = protein_status = None
+    if model is not None:
+        protein = model.mutant_protein_sequence
+        reference_protein = transcript.protein_sequence
+        if protein is not None and reference_protein is not None:
+            # An empty protein is a known absence, not missing data.
+            if "X" not in protein and "X" not in reference_protein:
+                protein_status = protein != reference_protein
+        initiator = getattr(effect, "five_prime_transcript", transcript)
+        coding = _coding_sequence(model, initiator)
+        if coding is not None:
+            reference_coding = transcript.coding_sequence
+            if reference_coding is not None:
+                coding_status = coding != reference_coding.upper()
+            if protein_status is None and reference_protein is not None:
+                # Initiator methionine also applies to alternative start codons.
+                protein = "M" + translate_sequence(
+                    coding[3:], codon_table=codon_table_for_transcript(initiator))
+                if "X" not in reference_protein:
+                    protein_status = protein != reference_protein
+
+    # A pure deletion can establish CDS/start loss without a translated model.
+    # Do not apply DNA-span inference to a supplied assembly or an RNA outcome.
+    if (isinstance(effect, LargeDeletion)
+            and not getattr(effect.variant, "alt_assembly", None)
+            and (model is None or model.annotator_name == "structural_variant")):
+        from .structural import _affected_span
+        start, end = _affected_span(effect.variant)
+        try:
+            coding_ranges = transcript.coding_sequence_position_ranges
+        except ValueError:
+            # A protein-coding biotype need not have annotated CDS features.
+            return coding_status, protein_status
+        coding_overlap = any(start <= hi and lo <= end
+                             for lo, hi in coding_ranges)
+        if coding_status is None:
+            coding_status = coding_overlap
+        if protein_status is None:
+            if not coding_overlap:
+                protein_status = False
+            elif (transcript.contains_start_codon
+                  and any(start <= pos <= end for pos in transcript.start_codon_positions)):
+                protein_status = True
+
+    if protein_status is True and coding_status is None:
+        coding_status = True
+    return coding_status, protein_status

varcode-9.3.0/varcode/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: varcode
-Version: 9.2.8
+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.8 → varcode-9.3.0}/varcode.egg-info/SOURCES.txt

@@ -72,6 +72,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_sequence_changes.py
 tests/test_sv_tabular_metadata.py
 tests/test_symbolic_alleles.py
 tests/test_symbolic_sv_padding.py
@@ -153,6 +154,7 @@ varcode/effects/effect_prediction_coding_frameshift.py
 varcode/effects/effect_prediction_coding_in_frame.py
 varcode/effects/fast_path.py
 varcode/effects/mutate.py
+varcode/effects/sequence_change.py
 varcode/effects/structural.py
 varcode/effects/transcript_helpers.py
 varcode/effects/translate.py

varcode-9.2.8/varcode/version.py

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