Uncertain ranges

src/hgvs/_data/hgvs.pymeta

@@ -2,7 +2,7 @@
 # variant specification.  The subset is limited to is limited to those
 # rules that define sequence variants precisely.  It does not current
 # cover rules for translocations or conversions.
- 
+
 # The basic structure of a HGVS sequence variant is:
 #    <ac>:<type>.<posedit>
 # where <ac> is a sequence accession, <type> determines the sequence
@@ -26,7 +26,7 @@ r_variant = accn:ac opt_gene_expr:gene ':' 'r':type '.' r_posedit:posedit -> hgv
 
 ############################################################################
 ## HGVS Position -- e.g., NM_01234.5:c.22+6 (without an edit)
-# This is unofficial syntax 
+# This is unofficial syntax
 
 hgvs_position     = g_hgvs_position | m_hgvs_position | c_hgvs_position | n_hgvs_position | r_hgvs_position | p_hgvs_position
 
@@ -65,7 +65,7 @@ r_posedit = (r_interval:pos rna_edit:edit -> hgvs.posedit.PosEdit(pos=pos,edit=e
 p_posedit   = (p_interval:pos pro_edit:edit -> hgvs.posedit.PosEdit(pos=pos,edit=edit))
    | ('(' p_interval:pos pro_edit:edit ')' -> hgvs.posedit.PosEdit(pos=pos,edit=edit, uncertain=True))
    | p_posedit_special
-p_posedit_special = 
+p_posedit_special =
       '=':x -> hgvs.posedit.PosEdit(pos=None,edit=x,uncertain=False)
 	| '(' '=':x ')' -> hgvs.posedit.PosEdit(pos=None,edit=x,uncertain=True)
 	| '0':x '?' -> hgvs.posedit.PosEdit(pos=None,edit=x,uncertain=True)
@@ -122,20 +122,26 @@ pro_ident  = '='                             -> hgvs.edit.AARefAlt(ref='',alt=''
 
 # potentially indefinite/uncertain intervals
 c_interval = def_c_interval | '(' def_c_interval:iv ')' -> iv._set_uncertain()
-g_interval = def_g_interval | '(' def_g_interval:iv ')' -> iv._set_uncertain()
+g_interval = uncertain_g_interval:iv | ('(' def_g_interval:iv ')' -> iv._set_uncertain()) | def_g_interval
 m_interval = def_m_interval | '(' def_m_interval:iv ')' -> iv._set_uncertain()
 n_interval = def_n_interval | '(' def_n_interval:iv ')' -> iv._set_uncertain()
 p_interval = def_p_interval | '(' def_p_interval:iv ')' -> iv._set_uncertain()
 r_interval = def_r_interval | '(' def_r_interval:iv ')' -> iv._set_uncertain()
 
 # definite intervals
-def_g_interval = (g_pos:start '_' g_pos:end -> hgvs.location.Interval(start,end)) | (g_pos:start -> hgvs.location.Interval(start,copy.deepcopy(start)))
-def_m_interval = (m_pos:start '_' m_pos:end -> hgvs.location.Interval(start,end)) | (m_pos:start -> hgvs.location.Interval(start,copy.deepcopy(start)))
-def_p_interval = (p_pos:start '_' p_pos:end -> hgvs.location.Interval(start,end)) | (p_pos:start -> hgvs.location.Interval(start,copy.deepcopy(start)))
-def_r_interval = (r_pos:start '_' r_pos:end -> hgvs.location.Interval(start,end)) | (r_pos:start -> hgvs.location.Interval(start,copy.deepcopy(start)))
+def_g_interval = (g_pos:start '_' g_pos:end -> hgvs.location.Interval(start,end)) | (g_pos:start -> hgvs.location.Interval(start,None))
+def_m_interval = (m_pos:start '_' m_pos:end -> hgvs.location.Interval(start,end)) | (m_pos:start -> hgvs.location.Interval(start,None))
+def_p_interval = (p_pos:start '_' p_pos:end -> hgvs.location.Interval(start,end)) | (p_pos:start -> hgvs.location.Interval(start,None))
+def_r_interval = (r_pos:start '_' r_pos:end -> hgvs.location.Interval(start,end)) | (r_pos:start -> hgvs.location.Interval(start,None))
 def_c_interval = (c_pos:start '_' c_pos:end -> hgvs.location.BaseOffsetInterval(start,end)) | (c_pos:start -> hgvs.location.BaseOffsetInterval(start,copy.deepcopy(start)))
 def_n_interval = (n_pos:start '_' n_pos:end -> hgvs.location.BaseOffsetInterval(start,end)) | (n_pos:start -> hgvs.location.BaseOffsetInterval(start,copy.deepcopy(start)))
 
+# indefinite ranges
+uncertain_g_interval = '(' def_g_interval:ivl_start ')' '_' '(' def_g_interval:ivl_end ')' -> hgvs.location.Interval(start=ivl_start._set_uncertain(), end=ivl_end._set_uncertain())
+                        | def_g_interval:ivl_start '_' '(' def_g_interval:ivl_end ')' -> hgvs.location.Interval(start=ivl_start, end=ivl_end._set_uncertain())
+                        | '(' def_g_interval:ivl_start ')' '_' def_g_interval:ivl_end -> hgvs.location.Interval(start=ivl_start._set_uncertain(), end=ivl_end)
+
+
 # positions
 c_pos = def_c_pos #| '(' def_c_pos:pos ')' -> pos._set_uncertain()
 g_pos = def_g_pos #| '(' def_g_pos:pos ')' -> pos._set_uncertain()

src/hgvs/alignmentmapper.py

@@ -27,6 +27,10 @@
 #
 
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from typing import Optional
+
 from bioutils.coordinates import strand_int_to_pm
 from six.moves import range
 
@@ -39,6 +43,7 @@
     HGVSInvalidIntervalError,
     HGVSUsageError,
 )
+from hgvs.location import Interval, BaseOffsetInterval
 from hgvs.utils import build_tx_cigar
 from hgvs.utils.cigarmapper import CIGARMapper
 
@@ -151,16 +156,29 @@ def __str__(self):
             )
         )
 
-    def g_to_n(self, g_interval, strict_bounds=None):
+    def g_to_n(self, g_interval: Interval, strict_bounds:Optional[bool]=None)->BaseOffsetInterval:
         """convert a genomic (g.) interval to a transcript cDNA (n.) interval"""
 
         if strict_bounds is None:
             strict_bounds = global_config.mapping.strict_bounds
 
-        grs, gre = (
-            g_interval.start.base - 1 - self.gc_offset,
-            g_interval.end.base - 1 - self.gc_offset,
-        )
+        # in case of uncertain ranges, we fall back to the inner (more confident) interval
+        if g_interval.start.uncertain:
+            grs = g_interval.start.end.base - 1 - self.gc_offset
+        else:
+            if isinstance(g_interval.start, Interval):
+                grs = g_interval.start.start.base - 1 - self.gc_offset
+            else:
+                grs = g_interval.start.base - 1 - self.gc_offset
+
+        if g_interval.end.uncertain:
+            gre = g_interval.end.start.base - 1 - self.gc_offset
+        else:
+            if isinstance(g_interval.end, Interval):
+                gre = g_interval.end.end.base - 1 - self.gc_offset
+            else:
+                gre = g_interval.end.base - 1 - self.gc_offset
+
         # frs, fre = (f)orward (r)na (s)tart & (e)nd; forward w.r.t. genome
         frs, frs_offset, frs_cigar = self.cigarmapper.map_ref_to_tgt(
             pos=grs, end="start", strict_bounds=strict_bounds
@@ -174,17 +192,24 @@ def g_to_n(self, g_interval, strict_bounds=None):
             frs_offset, fre_offset = -fre_offset, -frs_offset
 
         # The returned interval would be uncertain when locating at alignment gaps
+        # of if the initial interval was uncertain
         return hgvs.location.BaseOffsetInterval(
             start=hgvs.location.BaseOffsetPosition(
-                base=_zbc_to_hgvs(frs), offset=frs_offset, datum=Datum.SEQ_START
+                base=_zbc_to_hgvs(frs),
+                offset=frs_offset,
+                datum=Datum.SEQ_START,
+                uncertain=g_interval.start.uncertain
             ),
             end=hgvs.location.BaseOffsetPosition(
-                base=_zbc_to_hgvs(fre), offset=fre_offset, datum=Datum.SEQ_START
+                base=_zbc_to_hgvs(fre),
+                offset=fre_offset,
+                datum=Datum.SEQ_START,
+                uncertain=g_interval.end.uncertain
             ),
             uncertain=frs_cigar in "DI" or fre_cigar in "DI",
         )
 
-    def n_to_g(self, n_interval, strict_bounds=None):
+    def n_to_g(self, n_interval, strict_bounds=None) ->Interval:
         """convert a transcript (n.) interval to a genomic (g.) interval"""
 
         if strict_bounds is None:
@@ -216,7 +241,7 @@ def n_to_g(self, n_interval, strict_bounds=None):
             uncertain=grs_cigar in "DI" or gre_cigar in "DI",
         )
 
-    def n_to_c(self, n_interval, strict_bounds=None):
+    def n_to_c(self, n_interval:Interval, strict_bounds:Optional[bool]=None):
         """convert a transcript cDNA (n.) interval to a transcript CDS (c.) interval"""
 
         if strict_bounds is None:
@@ -246,7 +271,10 @@ def pos_n_to_c(pos):
             else:
                 c = pos.base - self.cds_end_i
                 c_datum = Datum.CDS_END
-            return hgvs.location.BaseOffsetPosition(base=c, offset=pos.offset, datum=c_datum)
+            return hgvs.location.BaseOffsetPosition(base=c,
+                                                    offset=pos.offset,
+                                                    datum=c_datum,
+                                                    uncertain=pos.uncertain)
 
         c_interval = hgvs.location.BaseOffsetInterval(
             start=pos_n_to_c(n_interval.start),