Fix ins/dups where splice region is preserved

b0d0nne11 · b0d0nne11 · commit ded59aefd2e3 · 2025-09-04T15:15:29.000-04:00
diff --git a/src/hgvs/_data/defaults.ini b/src/hgvs/_data/defaults.ini
@@ -7,6 +7,8 @@ normalize = True
 prevalidation_level = EXTRINSIC
 replace_reference = True
 ins_at_boundary_is_intronic = True
+shift_over_boundary = False
+shift_over_boundary_preference = DEFAULT
 
 # strict_bounds: require transcript variants to be within transcript sequence bounds
 strict_bounds = True
diff --git a/src/hgvs/assemblymapper.py b/src/hgvs/assemblymapper.py
@@ -58,6 +58,8 @@ def __init__(
         in_par_assume=hgvs.global_config.mapping.in_par_assume,
         replace_reference=hgvs.global_config.mapping.replace_reference,
         add_gene_symbol=hgvs.global_config.mapping.add_gene_symbol,
+        shift_over_boundary=hgvs.global_config.mapping.shift_over_boundary,
+        shift_over_boundary_preference=hgvs.global_config.mapping.shift_over_boundary_preference,
         *args,
         **kwargs,
     ):
@@ -79,6 +81,8 @@ def __init__(
             replace_reference=replace_reference,
             prevalidation_level=prevalidation_level,
             add_gene_symbol=add_gene_symbol,
+            shift_over_boundary=shift_over_boundary,
+            shift_over_boundary_preference=shift_over_boundary_preference,
             *args,
             **kwargs,
         )
@@ -90,7 +94,9 @@ def __init__(
         if self.normalize:
             vm = VariantMapper(hdp=hdp, replace_reference=replace_reference,
                                prevalidation_level=prevalidation_level,
-                               add_gene_symbol=add_gene_symbol)
+                               add_gene_symbol=add_gene_symbol,
+                               shift_over_boundary=shift_over_boundary,
+                               shift_over_boundary_preference=shift_over_boundary_preference)
             self._norm = hgvs.normalizer.Normalizer(
                 hdp, alt_aln_method=alt_aln_method, validate=False, variantmapper=vm,
             )
diff --git a/src/hgvs/enums.py b/src/hgvs/enums.py
@@ -5,3 +5,5 @@
 ValidationLevel = OrderedEnum("ValidationLevel", "VALID WARNING ERROR")
 
 PrevalidationLevel = OrderedEnum("PrevalidationLevel", "NONE INTRINSIC EXTRINSIC")
+
+ShiftOverBoundaryPreference = OrderedEnum("ShiftOverBoundaryPreference", "DEFAULT INTRON EXON")
diff --git a/src/hgvs/sequencevariant.py b/src/hgvs/sequencevariant.py
@@ -20,6 +20,9 @@ class SequenceVariant:
     type = attr.ib()
     posedit = attr.ib()
     gene = attr.ib(default=None)
+    shifts_into_exon_and_intron = attr.ib(default=False)
+    is_shifted = attr.ib(default=False)
+    at_boundary = attr.ib(default=False)
 
     def format(self, conf=None):
         """Formatting the stringification of sequence variants
diff --git a/src/hgvs/utils/altseqbuilder.py b/src/hgvs/utils/altseqbuilder.py
@@ -106,6 +106,7 @@ def __init__(self, var_c, transcript_data, translation_table=TranslationTable.st
         # check reference for special characteristics
         self._ref_has_multiple_stops = self._transcript_data.aa_sequence.count("*") > 1
         self._translation_table = translation_table
+        self.at_boundary = False
 
     def build_altseq(self):
         """given a variant and a sequence, incorporate the variant and return the new sequence
@@ -132,7 +133,7 @@ def build_altseq(self):
         # should loop over each allele rather than assume only 1 variant; return a list for now
         alt_data = []
 
-        variant_location = self._get_variant_region()
+        variant_location = self.get_variant_region()
 
         if variant_location == self.EXON:
             edit_type = type(self._var_c.posedit.edit)
@@ -176,7 +177,7 @@ def build_altseq(self):
 
         return alt_data
 
-    def _get_variant_region(self):
+    def get_variant_region(self):
         """Categorize variant by location in transcript (5'utr, exon, intron, 3'utr)
 
         :return "exon", "intron", "five_utr", "three_utr", "whole_gene"
@@ -200,41 +201,43 @@ def _get_variant_region(self):
         ):
             result = self.WHOLE_GENE
         elif (
-            global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "dup"
+            self._var_c.posedit.edit.type == "dup"
             and self._var_c.posedit.pos.start.base in self._transcript_data.exon_start_positions
+            and self._var_c.posedit.pos.start.offset == 0
         ):
-            result = self.INTRON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif (
-            global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "dup"
+            self._var_c.posedit.edit.type == "dup"
             and self._var_c.posedit.pos.end.base in self._transcript_data.exon_end_positions
+            and self._var_c.posedit.pos.end.offset == 0
         ):
-            result = self.INTRON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif (
-            not global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "ins"
+            self._var_c.posedit.edit.type == "ins"
             and self._var_c.posedit.pos.start.offset == -1 and self._var_c.posedit.pos.end.offset == 0
         ):
-            result = self.EXON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif (
-            not global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "ins"
+            self._var_c.posedit.edit.type == "ins"
             and self._var_c.posedit.pos.start.offset == 0 and self._var_c.posedit.pos.end.offset == 1
         ):
-            result = self.EXON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif (
-            not global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "dup"
+            self._var_c.posedit.edit.type == "dup"
             and self._var_c.posedit.pos.end.offset == -1
         ):
-            result = self.EXON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif (
-            not global_config.mapping.ins_at_boundary_is_intronic
-            and self._var_c.posedit.edit.type == "dup"
+            self._var_c.posedit.edit.type == "dup"
             and self._var_c.posedit.pos.start.offset == 1
         ):
-            result = self.EXON
+            self.at_boundary = True
+            result = self.INTRON if global_config.mapping.ins_at_boundary_is_intronic else self.EXON
         elif self._var_c.posedit.pos.start.offset != 0 or self._var_c.posedit.pos.end.offset != 0:
             # leave out anything else intronic for now
             result = self.INTRON
diff --git a/src/hgvs/variantmapper.py b/src/hgvs/variantmapper.py
@@ -19,8 +19,8 @@
 import hgvs.utils.altseqbuilder as altseqbuilder
 import hgvs.validator
 from hgvs.decorators.lru_cache import lru_cache
-from hgvs.enums import PrevalidationLevel
-from hgvs.exceptions import HGVSInvalidVariantError, HGVSUnsupportedOperationError
+from hgvs.enums import PrevalidationLevel, ShiftOverBoundaryPreference
+from hgvs.exceptions import HGVSInvalidVariantError, HGVSUnsupportedOperationError, HGVSInvalidIntervalError
 from hgvs.utils.reftranscriptdata import RefTranscriptData
 
 _logger = logging.getLogger(__name__)
@@ -71,6 +71,8 @@ def __init__(
         replace_reference=hgvs.global_config.mapping.replace_reference,
         prevalidation_level=hgvs.global_config.mapping.prevalidation_level,
         add_gene_symbol=hgvs.global_config.mapping.add_gene_symbol,
+        shift_over_boundary=hgvs.global_config.mapping.shift_over_boundary,
+        shift_over_boundary_preference=hgvs.global_config.mapping.shift_over_boundary_preference,
     ):
         """
         :param bool replace_reference: replace reference (entails additional network access)
@@ -93,6 +95,11 @@ def __init__(
         self.left_normalizer = hgvs.normalizer.Normalizer(
             hdp, shuffle_direction=5, variantmapper=self
         )
+        self.shift_over_boundary = shift_over_boundary
+        if shift_over_boundary_preference is None:
+            self.shift_over_boundary_preference = ShiftOverBoundaryPreference.DEFAULT
+        else:
+            self.shift_over_boundary_preference = ShiftOverBoundaryPreference[shift_over_boundary_preference.upper()]
 
     # ############################################################################
     # g⟷t
@@ -436,21 +443,52 @@ def c_to_p(self, var_c, pro_ac=None, alt_ac=None, alt_aln_method=hgvs.global_con
         reference_data = RefTranscriptData(self.hdp, var_c.ac, pro_ac, translation_table=translation_table)
         builder = altseqbuilder.AltSeqBuilder(var_c, reference_data, translation_table=translation_table)
 
+        # attempt to shift ins/dup variants from the intron into the exon or vice versa
+        if self.shift_over_boundary:
+            shifts_into_exon_and_intron = False
+            is_shifted = False
+            original_region = builder.get_variant_region()
+            if (
+                var_c.posedit.edit.type in ['ins', 'dup']
+                and original_region in [builder.INTRON, builder.EXON]
+            ):
+                if alt_ac is None:
+                    raise HGVSUnsupportedOperationError(f'mapping specific variant {var_c} requires alt_ac')
+                for shifted_var_c in self._var_c_shifts(var_c, alt_ac, alt_aln_method):
+                    shifted_reference_data = RefTranscriptData(self.hdp, shifted_var_c.ac, pro_ac)
+                    shifted_builder = altseqbuilder.AltSeqBuilder(shifted_var_c, shifted_reference_data)
+                    shifted_region = shifted_builder.get_variant_region()
+                    if shifted_region not in [shifted_builder.INTRON, shifted_builder.EXON]:
+                        continue
+                    if original_region != shifted_region:
+                        # a shift is posible
+                        shifts_into_exon_and_intron = True
+                        if self.shift_over_boundary_preference.name.lower() == shifted_region:
+                            # and that shift is preferred
+                            is_shifted = True
+                            reference_data = shifted_reference_data
+                            builder = shifted_builder
+                        break
+
         # TODO: handle case where you get 2+ alt sequences back;
         # currently get list of 1 element loop structure implemented
         # to handle this, but doesn't really do anything currently.
         all_alt_data = builder.build_altseq()
 
         var_ps = []
         for alt_data in all_alt_data:
-            builder = altseq_to_hgvsp.AltSeqToHgvsp(reference_data, alt_data)
-            var_p = builder.build_hgvsp()
+            hgvsp_builder = altseq_to_hgvsp.AltSeqToHgvsp(reference_data, alt_data)
+            var_p = hgvsp_builder.build_hgvsp()
             var_ps.append(var_p)
 
         var_p = var_ps[0]
 
         if self.add_gene_symbol:
             self._update_gene_symbol(var_p, var_c.gene)
+        var_p.at_boundary = builder.at_boundary
+        if self.shift_over_boundary:
+            var_p.shifts_into_exon_and_intron = shifts_into_exon_and_intron
+            var_p.is_shifted = is_shifted
 
         return var_p
 
@@ -625,6 +663,59 @@ def _update_gene_symbol(self, var, symbol):
         var.gene = symbol
         return var
 
+    def _var_c_shifts(self, var_c, alt_ac, alt_aln_method):
+        """Try to shift c. variants to find alternative representations."""
+        strand = self._fetch_AlignmentMapper(tx_ac=var_c.ac, alt_ac=alt_ac, alt_aln_method=alt_aln_method).strand
+        var_g = VariantMapper.c_to_g(self, var_c, alt_ac=alt_ac, alt_aln_method=alt_aln_method)
+        for shifted_var_g in self._var_g_shifts(var_g, strand=strand, alt_aln_method=alt_aln_method):
+            try:
+                shifted_var_c = VariantMapper.g_to_c(self, shifted_var_g, tx_ac=var_c.ac, alt_aln_method=alt_aln_method)
+                yield shifted_var_c
+            except (HGVSInvalidVariantError, HGVSInvalidIntervalError, HGVSUnsupportedOperationError):
+                pass
+
+    def _var_g_shifts(self, var_g, strand, alt_aln_method):
+        """Try to shift g. variants to find alternative representations."""
+        prev_var_g_strs = [str(var_g)]
+        for shuffle_direction in [3, 5]:
+            try:
+                shifted_var_g = self._var_g_shift_with_rewrite(var_g, shuffle_direction, strand, alt_aln_method)
+                if str(shifted_var_g) in prev_var_g_strs:
+                    continue
+                prev_var_g_strs.append(str(shifted_var_g))
+                yield shifted_var_g
+            except (HGVSInvalidVariantError, HGVSInvalidIntervalError, HGVSUnsupportedOperationError):
+                pass
+
+    def _var_g_shift_with_rewrite(self, var_g, shuffle_direction, strand, alt_aln_method):
+        """Attempt to shift a variant all the way left or right. Rewrite
+        duplications as insertions so that the variant is shifted farther
+        than would normally be possible using the HGVS notation."""
+        var_g = copy.deepcopy(var_g)
+        normalizer = hgvs.normalizer.Normalizer(
+            self.hdp, alt_aln_method=alt_aln_method, validate=False, shuffle_direction=shuffle_direction
+        )
+        var_g = normalizer.normalize(var_g)
+        if var_g.posedit.edit.type == 'dup':
+            self._replace_reference(var_g)
+            if (strand == 1 and shuffle_direction == 3) or (strand == -1 and shuffle_direction == 5):
+                var_g.posedit = hgvs.posedit.PosEdit(
+                    pos=hgvs.location.Interval(
+                        start=hgvs.location.SimplePosition(base=var_g.posedit.pos.start.base-1),
+                        end=hgvs.location.SimplePosition(base=var_g.posedit.pos.start.base),
+                    ),
+                    edit=hgvs.edit.NARefAlt(ref=None, alt=var_g.posedit.edit.ref)
+                )
+            else:
+                var_g.posedit = hgvs.posedit.PosEdit(
+                    pos=hgvs.location.Interval(
+                        start=hgvs.location.SimplePosition(base=var_g.posedit.pos.end.base),
+                        end=hgvs.location.SimplePosition(base=var_g.posedit.pos.end.base+1),
+                    ),
+                    edit=hgvs.edit.NARefAlt(ref=None, alt=var_g.posedit.edit.ref)
+                )
+        return var_g
+
 
 # <LICENSE>
 # Copyright 2018 HGVS Contributors (https://github.com/biocommons/hgvs)
diff --git a/tests/data/gcp/real.tsv b/tests/data/gcp/real.tsv
@@ -50,14 +50,12 @@ ID00048	NC_000010.10:g.89692922T>C	NM_000314.4:c.406T>C	NP_000305.3:p.(Cys136Arg
 ID00049	NC_000010.10:g.89692921dupA	NM_000314.4:c.405dupA	NP_000305.3:p.(Cys136Metfs*44)
 ID00050	NC_000010.10:g.89692923_89692939delGTGCATATTTATTACAT	NM_000314.4:c.407_423delGTGCATATTTATTACAT	NP_000305.3:p.(Cys136Serfs*38)
 ID00051	NC_000010.10:g.89712015C>A	NM_000314.4:c.633C>A	NP_000305.3:p.(Cys211*)
-ID00052	NC_000010.10:g.89685314dupT	NM_000314.4:c.209dupT	NP_000305.3:p.?
 ID00053	NC_000010.10:g.89711893C>T	NM_000314.4:c.511C>T	NP_000305.3:p.(Gln171*)
 ID00054	NC_000010.10:g.89692963dupA	NM_000314.4:c.447dupA	NP_000305.3:p.(Glu150Argfs*30)
 ID00055	NC_000010.10:g.89685315G>A	NM_000314.4:c.209+1G>A	NP_000305.3:p.?
 ID00056	NC_000010.10:g.89693009delG	NM_000314.4:c.492+1delG	NP_000305.3:p.?
 ID00057	NC_000010.10:g.89711873A>C	NM_000314.4:c.493-2A>C	NP_000305.3:p.?
 ID00058	NC_000010.10:g.89717676G>A	NM_000314.4:c.701G>A	NP_000305.3:p.(Arg234Gln)
 ID00059	NC_000010.10:g.89717777G>A	NM_000314.4:c.801+1G>A	NP_000305.3:p.?
-ID00060	NC_000010.10:g.89720648dupT	NM_000314.4:c.802-3dupT	NP_000305.3:p.?
 ID00061	NC_000005.9:g.131705667G>T	NM_003060.3:c.3G>T	NP_003051.1:p.Met1?
 ID00062	NC_000005.9:g.131706014G>A	NM_003060.3:c.350G>A	NP_003051.1:p.(Trp117*)
diff --git a/tests/issues/test_655.py b/tests/issues/test_655.py
diff --git a/tests/issues/test_714.py b/tests/issues/test_714.py
diff --git a/tests/support/mock_input_source.py b/tests/support/mock_input_source.py
