Resolves merge conflict with main in variantmapper.py imports.

      Merged ShiftOverBoundaryPreference and HGVSInvalidIntervalError imports
      from PR biocommons#719 with existing imports in main.

      Fixes biocommons#714 — ins/dup variants spanning intron/exon boundary where
      splice site & region remain completely intact.

Co-Authored-By: Brendan ODonnell <brendan@odonnell.xyz>

Author: andreasprlic

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

src/hgvs/assemblymapper.py

@@ -59,6 +59,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,
     ):
@@ -80,6 +82,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,
         )
@@ -94,6 +98,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,
             )
             self._norm = hgvs.normalizer.Normalizer(
                 hdp,
@@ -307,6 +313,14 @@ def _maybe_normalize(self, var):
                 # fall through to return unnormalized variant
         return var
 
+    def _var_c_shifts(self, var_c):
+        """Try to shift c. variants to find alternative representations."""
+        alt_ac = self._alt_ac_for_tx_ac(var_c.ac)
+        yield from super(AssemblyMapper, self)._var_c_shifts(
+            var_c, alt_ac, alt_aln_method=self.alt_aln_method
+        )
+
+
 
 # <LICENSE>
 # Copyright 2018 HGVS Contributors (https://github.com/biocommons/hgvs)

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")

src/hgvs/utils/altseqbuilder.py

@@ -132,7 +132,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 +176,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 +200,37 @@ 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
+            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
+            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
+            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
+            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
+            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
+            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

src/hgvs/variantmapper.py

@@ -16,14 +16,21 @@
 import hgvs.sequencevariant
 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 (
+    HGVSInvalidIntervalError,
+    HGVSInvalidVariantError,
+    HGVSUnsupportedOperationError,
+)
 from hgvs.utils import altseq_to_hgvsp, altseqbuilder
 from hgvs.utils.position import get_start_end, get_start_end_interbase
 from hgvs.utils.reftranscriptdata import RefTranscriptData
 
 _logger = logging.getLogger(__name__)
 
+_SHUFFLE_3PRIME = 3
+_SHUFFLE_5PRIME = 5
+
 
 class VariantMapper:
     r"""Maps SequenceVariant objects between g., n., r., c., and p. representations.
@@ -70,6 +77,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)
@@ -92,6 +101,13 @@ 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
@@ -456,15 +472,43 @@ def c_to_p(
             var_c, reference_data, translation_table=reference_data.translation_table
         )
 
+        # attempt to shift ins/dup variants from the intron into the exon or vice versa
+        if self.shift_over_boundary:
+            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:
+                    msg = f"mapping specific variant {var_c} requires alt_ac"
+                    raise HGVSUnsupportedOperationError(msg)
+                for shifted_var_c in VariantMapper._var_c_shifts(
+                    self, 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
+                        if self.shift_over_boundary_preference.name.lower() == shifted_region:
+                            # and that shift is preferred
+                            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]
@@ -645,6 +689,82 @@ 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."""
+        if not var_c.posedit or var_c.posedit.edit.type not in ("ins", "dup"):
+            return
+        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 [_SHUFFLE_3PRIME, _SHUFFLE_5PRIME]:
+            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 == _SHUFFLE_3PRIME) or (
+                strand == -1 and shuffle_direction == _SHUFFLE_5PRIME
+            ):
+                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)

tests/data/cache-py3.hdp

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