Uncertain ranges

.github/workflows/python-package.yml

@@ -65,6 +65,9 @@ jobs:
 
       - name: Install dependencies
         run: |
+          pip install --upgrade setuptools
+          pip install pytest
+          pip install pytest-cov
           pip install -e .[dev]
 
       - name: Test with pytest

.pre-commit-config.yaml

@@ -1,14 +1,16 @@
 repos:
-- repo: local
-  hooks:
-    -  id: pyright
-       name: pyright
-       entry: pyright
-       language: system
-       types: [python]
+# - repo: local
+#   hooks:
+#     -  id: pyright
+#        name: pyright
+#        entry: pyright
+#        language: system
+#        types: [python]
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.4.4
+  rev: v0.9.2
   hooks:
     - id: ruff
+      types_or: [ python, pyi ]
     - id: ruff-format
+      types_or: [ python, pyi ]
       args: [ --check ]

examples/creating-a-variant.ipynb

@@ -123,7 +123,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import hgvs.edit, hgvs.posedit"
+    "import hgvs.edit\n",
+    "import hgvs.posedit"
    ]
   },
   {

examples/hgvs-poster.ipynb

@@ -43,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },

pyproject.toml

@@ -31,7 +31,7 @@ keywords = [
     "hgvs",
     "variation"
     ]
-dynamic = ["version", "optional-dependencies"]
+dynamic = ["version"]
 
 dependencies=[
     "attrs >= 17.4.0",  # https://github.com/biocommons/hgvs/issues/473
@@ -44,7 +44,10 @@ dependencies=[
     "pre-commit ~= 3.4",
     "psycopg2",
 ]
-
+[project.optional-dependencies]
+dev = [
+    "parameterized"
+]
 [project.urls]
 "Homepage" = "https://github.com/biocommons/hgvs"
 "Bug Tracker" = "https://github.com/biocommons/hgvs/issues"

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,27 @@ 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
 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) 
+                        | ('(' def_g_interval:iv ')' -> iv._set_uncertain()) 
+
+
 # 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

@@ -26,6 +26,9 @@
 #    g.   ... 123   124   125   126   127   128   129   130   131   132   133 ...
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from typing import Optional
 
 from bioutils.coordinates import strand_int_to_pm
 
@@ -38,6 +41,7 @@
     HGVSInvalidIntervalError,
     HGVSUsageError,
 )
+from hgvs.location import Interval, BaseOffsetInterval
 from hgvs.utils import build_tx_cigar
 from hgvs.utils.cigarmapper import CIGARMapper
 
@@ -108,11 +112,16 @@ def __init__(self, hdp, tx_ac, alt_ac, alt_aln_method):
             # is that exons are adjacent. Assert that here.
             sorted_tx_exons = sorted(tx_exons, key=lambda e: e["ord"])
             for i in range(1, len(sorted_tx_exons)):
-                if sorted_tx_exons[i - 1]["tx_end_i"] != sorted_tx_exons[i]["tx_start_i"]:
+                if (
+                    sorted_tx_exons[i - 1]["tx_end_i"]
+                    != sorted_tx_exons[i]["tx_start_i"]
+                ):
                     raise HGVSDataNotAvailableError(
                         "AlignmentMapper(tx_ac={self.tx_ac}, "
                         "alt_ac={self.alt_ac}, alt_aln_method={self.alt_aln_method}): "
-                        "Exons {a} and {b} are not adjacent".format(self=self, a=i, b=i + 1)
+                        "Exons {a} and {b} are not adjacent".format(
+                            self=self, a=i, b=i + 1
+                        )
                     )
 
             self.strand = tx_exons[0]["alt_strand"]
@@ -138,9 +147,9 @@ def __init__(self, hdp, tx_ac, alt_ac, alt_aln_method):
             self.tgt_len = sum(tx_identity_info["lengths"])
             self.cigarmapper = None
 
-        assert not (
-            (self.cds_start_i is None) ^ (self.cds_end_i is None)
-        ), "CDS start and end must both be defined or neither defined"
+        assert not ((self.cds_start_i is None) ^ (self.cds_end_i is None)), (
+            "CDS start and end must both be defined or neither defined"
+        )
 
     def __str__(self):
         return (
@@ -150,16 +159,31 @@ 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
@@ -173,17 +197,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:
@@ -208,14 +239,32 @@ def n_to_g(self, n_interval, strict_bounds=None):
         grs, gre = grs + self.gc_offset + 1, gre + self.gc_offset + 1
         gs, ge = grs + start_offset, gre + end_offset
 
+        if n_interval.start.uncertain:
+            start = hgvs.location.Interval(
+                start=hgvs.location.SimplePosition(uncertain=False),
+                end=hgvs.location.SimplePosition(gs, uncertain=False),
+                uncertain=True,
+            )
+        else:
+            start = hgvs.location.SimplePosition(gs, uncertain=False)
+
+        if n_interval.end.uncertain:
+            end = hgvs.location.Interval(
+                start=hgvs.location.SimplePosition(ge, uncertain=False),
+                end=hgvs.location.SimplePosition(uncertain=False),
+                uncertain=True,
+            )
+        else:
+            end = hgvs.location.SimplePosition(ge, uncertain=False)
+
         # The returned interval would be uncertain when locating at alignment gaps
         return hgvs.location.Interval(
-            start=hgvs.location.SimplePosition(gs, uncertain=n_interval.start.uncertain),
-            end=hgvs.location.SimplePosition(ge, uncertain=n_interval.end.uncertain),
+            start=start,
+            end=end,
             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:
@@ -230,7 +279,9 @@ def n_to_c(self, n_interval, strict_bounds=None):
                 )
             )
 
-        if strict_bounds and (n_interval.start.base <= 0 or n_interval.end.base > self.tgt_len):
+        if strict_bounds and (
+            n_interval.start.base <= 0 or n_interval.end.base > self.tgt_len
+        ):
             raise HGVSInvalidIntervalError(
                 "The given coordinate is outside the bounds of the reference sequence."
             )
@@ -245,7 +296,9 @@ 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),
@@ -278,16 +331,23 @@ def pos_c_to_n(pos):
                 n -= 1
             if n <= 0 or n > self.tgt_len:
                 if strict_bounds:
-                    raise HGVSInvalidIntervalError(f"c.{pos} coordinate is out of bounds")
+                    raise HGVSInvalidIntervalError(
+                        f"c.{pos} coordinate is out of bounds"
+                    )
+
             return hgvs.location.BaseOffsetPosition(
-                base=n, offset=pos.offset, datum=Datum.SEQ_START
+                base=n,
+                offset=pos.offset,
+                datum=Datum.SEQ_START,
+                uncertain=pos.uncertain,
             )
 
         n_interval = hgvs.location.BaseOffsetInterval(
             start=pos_c_to_n(c_interval.start),
             end=pos_c_to_n(c_interval.end),
             uncertain=c_interval.uncertain,
         )
+
         return n_interval
 
     def g_to_c(self, g_interval, strict_bounds=None):