varcode 9.3.1__tar.gz → 9.3.2__tar.gz

{varcode-9.3.1/varcode.egg-info → varcode-9.3.2}/PKG-INFO

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

{varcode-9.3.1 → varcode-9.3.2}/tests/test_sv_sequence_changes.py

@@ -14,6 +14,7 @@ from varcode.effects import (
     StructuralVariantEffect, TranslocationToIntergenic, Unresolved,
 )
 from varcode.effects import structural
+from varcode.effects.codon_tables import codon_table_for_transcript
 
 
 @pytest.fixture
@@ -128,6 +129,214 @@ def test_partial_fragment_and_unmapped_assembly_are_unknown(cftr):
         assert effect.modifies_coding_sequence is None
 
 
+@pytest.mark.parametrize("completeness", [
+    "partial_start", "partial_end", "partial_both", "unknown", None,
+])
+@pytest.mark.parametrize("protein", ["reference_fragment", "different", ""])
+def test_unmapped_partial_proteins_do_not_establish_a_change(cftr, completeness, protein):
+    if protein == "reference_fragment":
+        protein = cftr.protein_sequence[:100]
+    effect = _effect(cftr)
+    effect.mutant_transcript = MutantTranscript.from_sequence(
+        cftr.sequence[:432], reference_transcript=cftr,
+        mutant_protein_sequence=protein,
+        evidence={"protein_completeness": completeness})
+    assert effect.modifies_protein_sequence is None
+    assert effect.modifies_coding_sequence is None
+    assert list(EffectCollection([effect]).drop_silent_and_noncoding()) == [effect]
+    assert len(EffectCollection([effect]).drop_silent_and_noncoding(False)) == 0
+    assert effect.mutant_protein_sequence == protein
+
+
+@pytest.mark.parametrize("completeness", ["partial_start", "partial_end", "partial_both"])
+def test_partial_label_prevents_complete_orf_fallback(cftr, completeness):
+    # A complete-looking ORF must not override the producer's explicit partial
+    # interpretation (e.g. an internal alternative start in an observed fragment).
+    effect = _effect(cftr, cdna=cftr.sequence, segments=_identity_segments(cftr),
+                     evidence={"protein_completeness": completeness})
+    assert effect.modifies_protein_sequence is None
+    assert effect.modifies_coding_sequence is None
+    evidence = dict(effect.mutant_transcript.evidence,
+                    cds_start=min(cftr.start_codon_spliced_offsets),
+                    cds_end=max(cftr.stop_codon_spliced_offsets) + 1)
+    effect.mutant_transcript = replace(effect.mutant_transcript, evidence=evidence)
+    assert effect.modifies_protein_sequence is None
+    assert effect.modifies_coding_sequence is None
+
+
+def _mapped_partial(transcript, completeness, change="none"):
+    """An observed CDS fragment mapped onto its reference, one codon changed.
+
+    Flags compare observed codons, so no protein is supplied.
+    """
+    table = codon_table_for_transcript(transcript)
+    start = min(transcript.start_codon_spliced_offsets)
+    stop = max(transcript.stop_codon_spliced_offsets) + 1
+    left = start if completeness == "partial_end" else start + 300
+    right = stop if completeness == "partial_start" else left + 300
+    cdna = transcript.sequence[left:right]
+    if change == "stop_loss":
+        pos, codon = len(cdna) - 3, "TGG"
+    else:
+        pos = next(i for i in range(3, len(cdna), 3)
+                   if table.forward_table.get(cdna[i:i + 3], "M") not in "MW")
+        original = cdna[pos:pos + 3]
+        synonyms = [c for c, aa in sorted(table.forward_table.items())
+                    if aa == table.forward_table[original] and c != original]
+        codon = {"none": original, "synonymous": synonyms[0], "missense": "TGG",
+                 "nonsense": "TAA", "ambiguous": original[:2] + "N"}[change]
+    cdna = cdna[:pos] + codon + cdna[pos + 3:]
+    return _effect(
+        transcript, cdna=cdna,
+        segments=(ReferenceSegment(transcript, left, right),),
+        evidence={"protein_completeness": completeness,
+                  "cds_start": 0, "cds_end": len(cdna)}), pos
+
+
+@pytest.mark.parametrize("transcript_id", ["ENST00000003084", "ENST00000357654"])
+@pytest.mark.parametrize("completeness", ["partial_start", "partial_end", "partial_both"])
+@pytest.mark.parametrize("change", ["none", "synonymous", "missense", "nonsense", "ambiguous"])
+def test_partial_observation_only_establishes_mapped_local_changes(
+        transcript_id, completeness, change):
+    transcript = cached_release(81).transcript_by_id(transcript_id)
+    effect, _ = _mapped_partial(transcript, completeness, change)
+    before = effect.mutant_transcript
+    assert effect.modifies_coding_sequence is (
+        True if change in ("synonymous", "missense", "nonsense") else None)
+    assert effect.modifies_protein_sequence is (
+        True if change in ("missense", "nonsense") else None)
+    assert effect.mutant_transcript == before
+
+
+@pytest.mark.parametrize("transcript_id", ["ENST00000003084", "ENST00000357654"])
+def test_mapped_stop_loss_is_a_protein_change(transcript_id):
+    transcript = cached_release(81).transcript_by_id(transcript_id)
+    effect, _ = _mapped_partial(transcript, "partial_start", "stop_loss")
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is True
+
+
+def test_mapped_reference_fragment_is_not_a_truncation(cftr):
+    # The #462 report, with reference coordinates: equal observed codons and a
+    # shorter supplied protein still leave the unobserved suffix unknown.
+    effect, _ = _mapped_partial(cftr, "partial_end")
+    effect.mutant_transcript = replace(
+        effect.mutant_transcript, mutant_protein_sequence=cftr.protein_sequence[:100])
+    assert effect.modifies_coding_sequence is None
+    assert effect.modifies_protein_sequence is None
+    assert len(EffectCollection([effect]).drop_silent_and_noncoding(False)) == 0
+
+
+def test_partial_uses_mitochondrial_table():
+    # TGA and TGG both encode tryptophan in vertebrate mitochondria.
+    transcript = cached_release(81).transcript_by_id("ENST00000361624")
+    effect, _ = _mapped_partial(transcript, "partial_both")
+    model = effect.mutant_transcript
+    cdna = model.cdna_sequence
+    pos = next(i for i in range(0, len(cdna), 3) if cdna[i:i + 3] in ("TGA", "TGG"))
+    swapped = "TGG" if cdna[pos:pos + 3] == "TGA" else "TGA"
+    effect.mutant_transcript = replace(
+        model, cdna_sequence=cdna[:pos] + swapped + cdna[pos + 3:])
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is None
+
+
+@pytest.mark.parametrize("upstream", [False, True])
+def test_alternative_start_codon_reads_as_met_only_where_the_orf_begins(cftr, upstream):
+    # A 3' partner's start codon is internal to a fused ORF, so CTG there is Leu.
+    brca1 = cached_release(81).transcript_by_id("ENST00000357654")
+    start = min(cftr.start_codon_spliced_offsets)
+    other = min(brca1.start_codon_spliced_offsets) + 3
+    segments = (ReferenceSegment(cftr, start, start + 300),)
+    cdna = "CTG" + cftr.sequence[start + 3:start + 300]
+    if upstream:
+        segments = (ReferenceSegment(brca1, other, other + 30),) + segments
+        cdna = brca1.sequence[other:other + 30] + cdna
+    effect = _effect(cftr, cdna=cdna, segments=segments, evidence={
+        "protein_completeness": "partial_both", "cds_start": 0, "cds_end": len(cdna)})
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is (True if upstream else None)
+
+
+def test_partial_bounds_accept_numpy_integers(cftr):
+    import numpy as np
+
+    effect, _ = _mapped_partial(cftr, "partial_both", "missense")
+    evidence = effect.mutant_transcript.evidence
+    effect.mutant_transcript = replace(effect.mutant_transcript, evidence=dict(
+        evidence, cds_start=np.int64(0), cds_end=np.int64(evidence["cds_end"])))
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is True
+
+
+def test_partial_mapped_change_survives_split_reference_segments(cftr):
+    effect, pos = _mapped_partial(cftr, "partial_both", "missense")
+    segment, = effect.mutant_transcript.reference_segments
+    effect.mutant_transcript = replace(effect.mutant_transcript, reference_segments=(
+        replace(segment, end=segment.start + pos + 1),
+        replace(segment, start=segment.start + pos + 1)))
+    assert effect.modifies_coding_sequence is True
+    assert effect.modifies_protein_sequence is True
+
+
+@pytest.mark.parametrize("missing", [
+    "frame", "float_frame", "offset_frame", "mapping", "reverse", "length", "edits"])
+def test_partial_local_change_requires_usable_coordinates(cftr, missing):
+    from varcode import TranscriptEdit
+
+    effect, _ = _mapped_partial(cftr, "partial_both", "missense")
+    model = effect.mutant_transcript
+    if missing == "frame":
+        model = replace(model, evidence={"protein_completeness": "partial_both"})
+    elif missing == "float_frame":
+        model = replace(model, evidence=dict(model.evidence, cds_start=0.0))
+    elif missing == "offset_frame":
+        # Codons out of frame with the reference CDS have no counterpart.
+        model = replace(model, evidence=dict(model.evidence, cds_start=1))
+    elif missing == "mapping":
+        model = replace(model, reference_segments=None)
+    elif missing == "reverse":
+        model = replace(model, reference_segments=(replace(model.reference_segments[0], strand="-"),))
+    elif missing == "length":
+        model = replace(model, cdna_sequence=model.cdna_sequence + "A")
+    else:
+        model = replace(model, edits=(TranscriptEdit(0, 0, "A"),))
+    effect.mutant_transcript = model
+    assert effect.modifies_coding_sequence is None
+    assert effect.modifies_protein_sequence is None
+
+
+@pytest.mark.parametrize("completeness", ["partial_start", "partial_end", "partial_both"])
+def test_imported_partial_peptide_without_reference_mapping_is_unknown(cftr, completeness):
+    # Exacto peptides carry observed ORF bounds but no reference coordinates.
+    variant = StructuralVariant(cftr.contig, cftr.start, "BND", genome=cftr.genome)
+    start = min(cftr.start_codon_spliced_offsets)
+    cdna = cftr.sequence[:start + 3] + "TGG" + cftr.sequence[start + 6:start + 300]
+    candidate = make_fusion_outcome(
+        variant, cftr, sequence=cdna, transcript_model_id="observed-model", source="exacto")
+    model = candidate.effect.mutant_transcript
+    candidate.effect.mutant_transcript = replace(
+        model, mutant_protein_sequence="MW" + cftr.protein_sequence[2:100],
+        evidence=dict(model.evidence or {}, protein_completeness=completeness,
+                      cds_start=start, cds_end=start + 300))
+    assert candidate.effect.modifies_coding_sequence is None
+    assert candidate.effect.modifies_protein_sequence is None
+
+
+def test_complete_protein_and_partial_alternative_remain_unknown(cftr):
+    primary = _effect(cftr, protein=cftr.protein_sequence,
+                      evidence={"protein_completeness": "start_to_stop"})
+    partial, _ = _mapped_partial(cftr, "partial_both", "none")
+    primary._extra_candidates = (EffectCandidate(partial, source="rna"),)
+    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
+    changed, _ = _mapped_partial(cftr, "partial_both", "missense")
+    primary._extra_candidates += (EffectCandidate(changed, source="rna"),)
+    assert primary.modifies_protein_sequence is True
+    assert len(EffectCollection([primary]).drop_silent_and_noncoding(False)) == 1
+
+
 @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)

{varcode-9.3.1 → varcode-9.3.2}/varcode/effects/sequence_change.py

@@ -1,5 +1,7 @@
 """Sequence-change flags for existing SV predictions, not a new SV model."""
 
+import operator
+
 from .codon_tables import codon_table_for_transcript, translate_sequence
 
 
@@ -82,6 +84,67 @@ def _coding_sequence(model, initiator):
     return None
 
 
+def _residue(codon, table, initiator):
+    # As for a complete ORF, any start codon at the initiator reads as Met.
+    if initiator and codon in table.start_codons:
+        return "M"
+    return table.forward_table.get(codon, "*")
+
+
+def _partial_sequence_changes(model, transcript, table):
+    """Compare only the mapped, in-frame codons of a partial observation.
+
+    ``cds_start`` / ``cds_end`` place the producer's reading frame in the
+    observed cDNA; transcript segments give each base's reference offset.
+    A codon is compared only when its three bases map contiguously onto one
+    reference CDS codon. A difference there proves a local change. Equal
+    codons cannot show that unobserved sequence is unchanged, and missing
+    coverage is not a deletion or truncation, so this never returns False.
+    """
+    evidence = model.evidence or {}
+    try:
+        # Any integer type (e.g. numpy); not missing or fractional bounds.
+        start = operator.index(evidence.get("cds_start"))
+        end = operator.index(evidence.get("cds_end"))
+    except TypeError:
+        return None, None
+    sequence = model.cdna_sequence
+    segments = model.reference_segments or ()
+    if (sequence is None or model.edits or not transcript.complete
+            or not 0 <= start < end <= len(sequence)
+            or sum(s.length for s in segments) != len(sequence)):
+        # Unmapped edits, or segments that don't render this sequence,
+        # leave observed bases without reference coordinates.
+        return None, None
+    reference_offsets = {}
+    offset = 0
+    for segment in segments:
+        if segment.source == transcript and segment.strand == "+":
+            for pos in range(max(start, offset), min(end, offset + segment.length)):
+                reference_offsets[pos] = segment.start + pos - offset
+        offset += segment.length
+    reference_start = min(transcript.start_codon_spliced_offsets)
+    reference_coding = transcript.coding_sequence.upper()
+    coding_status = None
+    for pos in range(start, end - 2, 3):
+        codon = sequence[pos:pos + 3].upper()
+        ref = reference_offsets.get(pos)
+        k = None if ref is None else ref - reference_start
+        if (k is not None and k % 3 == 0 and 0 <= k < len(reference_coding)
+                and reference_offsets.get(pos + 1) == ref + 1
+                and reference_offsets.get(pos + 2) == ref + 2):
+            reference_codon = reference_coding[k:k + 3]
+            if codon != reference_codon and not set(codon + reference_codon) - set("ACGT"):
+                coding_status = True
+                # Only an observed ORF that begins here can initiate here.
+                observed = _residue(codon, table, k == 0 and pos == start)
+                if observed != _residue(reference_codon, table, k == 0):
+                    return True, True
+        if codon in table.stop_codons:
+            break  # Later bases are not translated in this frame.
+    return coding_status, None
+
+
 def structural_sequence_changes(effect):
     """Return local (coding, protein) changes as True / False / None.
 
@@ -93,15 +156,20 @@ def structural_sequence_changes(effect):
 
     transcript = effect.transcript
     model = effect.mutant_transcript
+    initiator = getattr(effect, "five_prime_transcript", transcript)
     coding_status = protein_status = None
-    if model is not None:
+    if model is not None and (model.evidence or {}).get(
+            "protein_completeness", "start_to_stop") != "start_to_stop":
+        # A fragment is not a full-length protein; a shorter one isn't truncated.
+        coding_status, protein_status = _partial_sequence_changes(
+            model, transcript, codon_table_for_transcript(initiator))
+    elif 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

varcode-9.3.2/varcode/version.py

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

{varcode-9.3.1 → varcode-9.3.2/varcode.egg-info}/PKG-INFO

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

varcode-9.3.1/varcode/version.py

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