cool-seq-tool 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

cool_seq_tool/mappers/exon_genomic_coords.py

@@ -14,13 +14,13 @@ from cool_seq_tool.schemas import (
     Strand,
 )
 from cool_seq_tool.sources.mane_transcript_mappings import ManeTranscriptMappings
-from cool_seq_tool.sources.uta_database import UtaDatabase
+from cool_seq_tool.sources.uta_database import GenomicAlnData, UtaDatabase
 from cool_seq_tool.utils import service_meta
 
 _logger = logging.getLogger(__name__)
 
 
-class ExonCoord(BaseModelForbidExtra):
+class _ExonCoord(BaseModelForbidExtra):
     """Model for representing exon coordinate data"""
 
     ord: StrictInt = Field(..., description="Exon number. 0-based.")
@@ -97,19 +97,18 @@ class GenomicTxSeg(BaseModelForbidExtra):
         """Ensure that fields are (un)set depending on errors
 
         :param values: Values in model
-        :raises ValueError: If `seg`, `gene`, `genomic_ac` and `tx_ac` are not
+        :raises ValueError: If `seg`, `genomic_ac` and `tx_ac` are not
         provided when there are no errors
         :return: Values in model
         """
         if not values.get("errors") and not all(
             (
                 values.get("seg"),
-                values.get("gene"),
                 values.get("genomic_ac"),
                 values.get("tx_ac"),
             )
         ):
-            err_msg = "`seg`, `gene`, `genomic_ac` and `tx_ac` must be provided"
+            err_msg = "`seg`, `genomic_ac` and `tx_ac` must be provided"
             raise ValueError(err_msg)
         return values
 
@@ -154,20 +153,21 @@ class GenomicTxSegService(BaseModelForbidExtra):
         on errors
 
         :param values: Values in model
-        :raises ValueError: If `gene`, `genomic_ac`, `tx_ac` and `seg_start` or `seg_end`
+        :raises ValueError: If `genomic_ac`, `tx_ac` and `seg_start` or `seg_end`
             not provided when there are no errors
         :return: Values in model, including service metadata
         """
         values["service_meta"] = service_meta()
         if not values.get("errors") and not all(
             (
-                values.get("gene"),
                 values.get("genomic_ac"),
                 values.get("tx_ac"),
                 values.get("seg_start") or values.get("seg_end"),
             )
         ):
-            err_msg = "`gene`, `genomic_ac`, `tx_ac` and `seg_start` or `seg_end` must be provided"
+            err_msg = (
+                "`genomic_ac`, `tx_ac` and `seg_start` or `seg_end` must be provided"
+            )
             raise ValueError(err_msg)
 
         return values
@@ -340,17 +340,20 @@ class ExonGenomicCoordsMapper:
 
         # Get aligned genomic data (hgnc gene, alt_ac, alt_start_i, alt_end_i, strand)
         # for exon(s)
-        alt_ac_start_end, err_msg = await self._get_alt_ac_start_and_end(
+        (
+            genomic_aln_start,
+            genomic_aln_end,
+            err_msg,
+        ) = await self._get_genomic_aln_coords(
             transcript, tx_exon_start_coords, tx_exon_end_coords, gene=gene
         )
-        if not alt_ac_start_end:
-            return _return_service_errors([err_msg] if err_msg else [])
-        alt_ac_start_data, alt_ac_end_data = alt_ac_start_end
+        if err_msg:
+            return _return_service_errors([err_msg])
 
         # Get gene and chromosome data, check that at least one was retrieved
-        gene = alt_ac_start_data.hgnc if alt_ac_start_data else alt_ac_end_data.hgnc
+        gene = genomic_aln_start.hgnc if genomic_aln_start else genomic_aln_end.hgnc
         genomic_ac = (
-            alt_ac_start_data.alt_ac if alt_ac_start_data else alt_ac_end_data.alt_ac
+            genomic_aln_start.alt_ac if genomic_aln_start else genomic_aln_end.alt_ac
         )
         if gene is None or genomic_ac is None:
             return _return_service_errors(
@@ -360,9 +363,9 @@ class ExonGenomicCoordsMapper:
             )
 
         strand = (
-            Strand(alt_ac_start_data.alt_strand)
-            if alt_ac_start_data
-            else Strand(alt_ac_end_data.alt_strand)
+            Strand(genomic_aln_start.alt_strand)
+            if genomic_aln_start
+            else Strand(genomic_aln_end.alt_strand)
         )
 
         if exon_start_exists:
@@ -370,7 +373,7 @@ class ExonGenomicCoordsMapper:
                 genomic_ac,
                 strand,
                 exon_start_offset,
-                alt_ac_start_data,
+                genomic_aln_start,
                 is_seg_start=True,
             )
             if err_msg:
@@ -380,7 +383,11 @@ class ExonGenomicCoordsMapper:
 
         if exon_end_exists:
             seg_end, err_msg = self._get_tx_segment(
-                genomic_ac, strand, exon_end_offset, alt_ac_end_data, is_seg_start=False
+                genomic_ac,
+                strand,
+                exon_end_offset,
+                genomic_aln_end,
+                is_seg_start=False,
             )
             if err_msg:
                 return _return_service_errors([err_msg])
@@ -479,7 +486,7 @@ class ExonGenomicCoordsMapper:
                 transcript=transcript,
                 gene=gene,
                 get_nearest_transcript_junction=get_nearest_transcript_junction,
-                is_start=True,
+                is_seg_start=True,
             )
             if start_tx_seg_data.errors:
                 return _return_service_errors(start_tx_seg_data.errors)
@@ -499,7 +506,7 @@ class ExonGenomicCoordsMapper:
                 transcript=transcript,
                 gene=gene,
                 get_nearest_transcript_junction=get_nearest_transcript_junction,
-                is_start=False,
+                is_seg_start=False,
             )
             if end_tx_seg_data.errors:
                 return _return_service_errors(end_tx_seg_data.errors)
@@ -525,53 +532,13 @@ class ExonGenomicCoordsMapper:
 
         return GenomicTxSegService(**params)
 
-    async def _get_all_exon_coords(
-        self, tx_ac: str, genomic_ac: str | None = None
-    ) -> list[ExonCoord]:
-        """Get all exon coordinate data for a transcript.
-
-        If ``genomic_ac`` is NOT provided, this method will use the GRCh38 accession
-        associated to ``tx_ac``.
-
-        :param tx_ac: The RefSeq transcript accession to get exon data for.
-        :param genomic_ac: The RefSeq genomic accession to get exon data for.
-        :return: List of all exon coordinate data for ``tx_ac`` and ``genomic_ac``.
-            The exon coordinate data will include the exon number, transcript and
-            genomic positions for the start and end of the exon, and strand.
-            The list will be ordered by ascending exon number.
-        """
-        if genomic_ac:
-            query = f"""
-                SELECT DISTINCT ord, tx_start_i, tx_end_i, alt_start_i, alt_end_i, alt_strand
-                FROM {self.uta_db.schema}.tx_exon_aln_v
-                WHERE tx_ac = '{tx_ac}'
-                AND alt_aln_method = 'splign'
-                AND alt_ac = '{genomic_ac}'
-                ORDER BY ord ASC
-                """  # noqa: S608
-        else:
-            query = f"""
-                SELECT DISTINCT ord, tx_start_i, tx_end_i, alt_start_i, alt_end_i, alt_strand
-                FROM {self.uta_db.schema}.tx_exon_aln_v as t
-                INNER JOIN {self.uta_db.schema}._seq_anno_most_recent as s
-                ON t.alt_ac = s.ac
-                WHERE s.descr = ''
-                AND t.tx_ac = '{tx_ac}'
-                AND t.alt_aln_method = 'splign'
-                AND t.alt_ac like 'NC_000%'
-                ORDER BY ord ASC
-                """  # noqa: S608
-
-        results = await self.uta_db.execute_query(query)
-        return [ExonCoord(**r) for r in results]
-
     async def _get_start_end_exon_coords(
         self,
         tx_ac: str,
         exon_start: int | None = None,
         exon_end: int | None = None,
         genomic_ac: str | None = None,
-    ) -> tuple[ExonCoord | None, ExonCoord | None, list[str]]:
+    ) -> tuple[_ExonCoord | None, _ExonCoord | None, list[str]]:
         """Get exon coordinates for a transcript given exon start and exon end.
 
         If ``genomic_ac`` is NOT provided, this method will use the GRCh38 accession
@@ -606,56 +573,160 @@ class ExonGenomicCoordsMapper:
 
         return *start_end_exons, errors
 
-    async def _get_alt_ac_start_and_end(
+    async def _get_all_exon_coords(
+        self, tx_ac: str, genomic_ac: str | None = None
+    ) -> list[_ExonCoord]:
+        """Get all exon coordinate data for a transcript.
+
+        If ``genomic_ac`` is NOT provided, this method will use the GRCh38 accession
+        associated to ``tx_ac``.
+
+        :param tx_ac: The RefSeq transcript accession to get exon data for.
+        :param genomic_ac: The RefSeq genomic accession to get exon data for.
+        :return: List of all exon coordinate data for ``tx_ac`` and ``genomic_ac``.
+            The exon coordinate data will include the exon number, transcript and
+            genomic positions for the start and end of the exon, and strand.
+            The list will be ordered by ascending exon number.
+        """
+        if genomic_ac:
+            query = f"""
+                SELECT DISTINCT ord, tx_start_i, tx_end_i, alt_start_i, alt_end_i, alt_strand
+                FROM {self.uta_db.schema}.tx_exon_aln_v
+                WHERE tx_ac = '{tx_ac}'
+                AND alt_aln_method = 'splign'
+                AND alt_ac = '{genomic_ac}'
+                ORDER BY ord ASC
+                """  # noqa: S608
+        else:
+            query = f"""
+                SELECT DISTINCT ord, tx_start_i, tx_end_i, alt_start_i, alt_end_i, alt_strand
+                FROM {self.uta_db.schema}.tx_exon_aln_v as t
+                INNER JOIN {self.uta_db.schema}._seq_anno_most_recent as s
+                ON t.alt_ac = s.ac
+                WHERE s.descr = ''
+                AND t.tx_ac = '{tx_ac}'
+                AND t.alt_aln_method = 'splign'
+                AND t.alt_ac like 'NC_000%'
+                ORDER BY ord ASC
+                """  # noqa: S608
+
+        results = await self.uta_db.execute_query(query)
+        return [_ExonCoord(**r) for r in results]
+
+    async def _get_genomic_aln_coords(
         self,
         tx_ac: str,
-        tx_exon_start: ExonCoord | None = None,
-        tx_exon_end: ExonCoord | None = None,
+        tx_exon_start: _ExonCoord | None = None,
+        tx_exon_end: _ExonCoord | None = None,
         gene: str | None = None,
-    ) -> tuple[tuple[tuple[int, int], tuple[int, int]] | None, str | None]:
+    ) -> tuple[GenomicAlnData | None, GenomicAlnData | None, str | None]:
         """Get aligned genomic coordinates for transcript exon start and end.
 
+        ``tx_exon_start`` and ``tx_exon_end`` is expected to reference the same
+        transcript and genomic accession.
+
         :param tx_ac: Transcript accession
         :param tx_exon_start: Transcript's exon start coordinates. If not provided,
             must provide ``tx_exon_end``
         :param tx_exon_end: Transcript's exon end coordinates. If not provided, must
             provide ``tx_exon_start``
         :param gene: HGNC gene symbol
-        :return: Aligned genomic data, and warnings if found
+        :return: Tuple containing aligned genomic data for start and end exon and
+            warnings if found
         """
         if tx_exon_start is None and tx_exon_end is None:
             msg = "Must provide either `tx_exon_start` or `tx_exon_end` or both"
             _logger.warning(msg)
-            return None, msg
+            return None, None, msg
 
-        alt_ac_data = {"start": None, "end": None}
+        aligned_coords = {"start": None, "end": None}
         for exon, key in [(tx_exon_start, "start"), (tx_exon_end, "end")]:
             if exon:
-                alt_ac_val, warning = await self.uta_db.get_alt_ac_start_or_end(
+                aligned_coord, warning = await self.uta_db.get_alt_ac_start_or_end(
                     tx_ac, exon.tx_start_i, exon.tx_end_i, gene=gene
                 )
-                if alt_ac_val:
-                    alt_ac_data[key] = alt_ac_val
+                if aligned_coord:
+                    aligned_coords[key] = aligned_coord
                 else:
-                    return None, warning
-
-        alt_ac_data_values = alt_ac_data.values()
-        # Validate that start and end alignments have matching gene, genomic accession,
-        # and strand
-        if all(alt_ac_data_values):
-            for attr in ["hgnc", "alt_ac", "alt_strand"]:
-                start_attr = getattr(alt_ac_data["start"], attr)
-                end_attr = getattr(alt_ac_data["end"], attr)
-                if start_attr != end_attr:
-                    error = f"{attr} mismatch. {start_attr} != {end_attr}."
-                    _logger.warning(
-                        "%s: %s != %s",
-                        error,
-                        start_attr,
-                        end_attr,
-                    )
-                    return None, error
-        return tuple(alt_ac_data_values), None
+                    return None, None, warning
+
+        return *aligned_coords.values(), None
+
+    def _get_tx_segment(
+        self,
+        genomic_ac: str,
+        strand: Strand,
+        offset: int,
+        genomic_ac_data: _ExonCoord,
+        is_seg_start: bool = False,
+    ) -> tuple[TxSegment | None, str | None]:
+        """Get transcript segment data given ``genomic_ac`` and offset data
+
+        :param genomic_ac: Genomic RefSeq accession
+        :param strand: Strand
+        :param offset: Exon offset
+        :param genomic_ac_data: Exon coordinate data for ``genomic_ac``
+        :param is_seg_start: ``True`` if retrieving genomic data where the transcript
+            segment starts, defaults to ``False``
+        :return: Transcript segment data
+        """
+        if is_seg_start:
+            if strand == Strand.POSITIVE:
+                seg_genomic_pos = offset + genomic_ac_data.alt_start_i
+            else:
+                seg_genomic_pos = genomic_ac_data.alt_end_i - offset
+        else:
+            if strand == Strand.POSITIVE:
+                seg_genomic_pos = offset + genomic_ac_data.alt_end_i
+            else:
+                seg_genomic_pos = genomic_ac_data.alt_start_i - offset
+
+        genomic_loc, err_msg = self._get_vrs_seq_loc(
+            genomic_ac,
+            seg_genomic_pos,
+            is_seg_start=is_seg_start,
+            strand=strand,
+        )
+        if err_msg:
+            return None, err_msg
+
+        return TxSegment(
+            exon_ord=genomic_ac_data.ord,
+            genomic_location=genomic_loc,
+            offset=offset,
+        ), None
+
+    def _get_vrs_seq_loc(
+        self, genomic_ac: str, genomic_pos: int, is_seg_start: bool, strand: Strand
+    ) -> tuple[SequenceLocation | None, str | None]:
+        """Create VRS Sequence Location for genomic position where transcript segment
+        occurs
+
+        :param genomic_ac: RefSeq genomic accession
+        :param genomic_pos: Genomic position where the transcript segment occurs
+        :param is_seg_start: ``True`` if ``genomic_pos`` is where the transcript segment
+            starts. ``False`` if ``genomic_pos`` is where the transcript segment ends.
+        :param strand: Strand
+        :return: Tuple containing VRS location (if successful) and error message (if
+            unable to get GA4GH identifier for ``genomic_ac``).
+        """
+        ga4gh_seq_id, err_msg = self.seqrepo_access.translate_identifier(
+            genomic_ac, "ga4gh"
+        )
+        if err_msg:
+            return None, err_msg
+
+        use_start = (
+            strand == Strand.POSITIVE if is_seg_start else strand != Strand.POSITIVE
+        )
+
+        return SequenceLocation(
+            sequenceReference=SequenceReference(
+                refgetAccession=ga4gh_seq_id[0].split("ga4gh:")[-1]
+            ),
+            start=genomic_pos if use_start else None,
+            end=genomic_pos if not use_start else None,
+        ), None
 
     async def _genomic_to_tx_segment(
         self,
@@ -665,7 +736,7 @@ class ExonGenomicCoordsMapper:
         transcript: str | None = None,
         gene: str | None = None,
         get_nearest_transcript_junction: bool = False,
-        is_start: bool = True,
+        is_seg_start: bool = True,
     ) -> GenomicTxSeg:
         """Given genomic data, generate a boundary for a transcript segment.
 
@@ -692,17 +763,17 @@ class ExonGenomicCoordsMapper:
             following the breakpoint for the 3' end. For the negative strand, adjacent
             is defined as the exon following the breakpoint for the 5' end and the exon
             preceding the breakpoint for the 3' end.
-        :param is_start: ``True`` if ``genomic_pos`` is where the transcript segment starts.
+        :param is_seg_start: ``True`` if ``genomic_pos`` is where the transcript segment starts.
             ``False`` if ``genomic_pos`` is where the transcript segment ends.
         :return: Data for a transcript segment boundary (inter-residue coordinates)
         """
         params = {key: None for key in GenomicTxSeg.model_fields}
 
         if get_nearest_transcript_junction:
-            if not gene:
+            if not gene and not transcript:
                 return GenomicTxSeg(
                     errors=[
-                        "`gene` must be provided to select the adjacent transcript junction"
+                        "`gene` or `transcript` must be provided to select the adjacent transcript junction"
                     ]
                 )
 
@@ -773,8 +844,8 @@ class ExonGenomicCoordsMapper:
                 exon_num = self._get_adjacent_exon(
                     tx_exons_genomic_coords=tx_exons,
                     strand=strand,
-                    start=genomic_pos if is_start else None,
-                    end=genomic_pos if not is_start else None,
+                    start=genomic_pos if is_seg_start else None,
+                    end=genomic_pos if not is_seg_start else None,
                 )
 
                 offset = self._get_exon_offset(
@@ -782,19 +853,26 @@ class ExonGenomicCoordsMapper:
                     end_i=tx_exons[exon_num].alt_end_i,
                     strand=strand,
                     use_start_i=strand == Strand.POSITIVE
-                    if is_start
+                    if is_seg_start
                     else strand != Strand.POSITIVE,
                     is_in_exon=False,
-                    start=genomic_pos if is_start else None,
-                    end=genomic_pos if not is_start else None,
+                    start=genomic_pos if is_seg_start else None,
+                    end=genomic_pos if not is_seg_start else None,
                 )
 
                 genomic_location, err_msg = self._get_vrs_seq_loc(
-                    genomic_ac, genomic_pos, is_start, strand
+                    genomic_ac, genomic_pos, is_seg_start, strand
                 )
                 if err_msg:
                     return GenomicTxSeg(errors=[err_msg])
 
+                # gene is not required to liftover coordinates if tx_ac and genomic_ac are given, but we should set the associated gene
+                if not gene:
+                    _gene, err_msg = await self._get_tx_ac_gene(transcript)
+                    if err_msg:
+                        return GenomicTxSeg(errors=[err_msg])
+                    gene = _gene
+
                 return GenomicTxSeg(
                     gene=gene,
                     genomic_ac=genomic_ac,
@@ -807,20 +885,17 @@ class ExonGenomicCoordsMapper:
                 )
 
         if genomic_ac:
-            # Check if valid accession is given
-            if not await self.uta_db.validate_genomic_ac(genomic_ac):
-                return GenomicTxSeg(errors=[f"Invalid genomic accession: {genomic_ac}"])
-
             _gene, err_msg = await self._get_genomic_ac_gene(genomic_pos, genomic_ac)
-            if _gene:
-                if gene and _gene != gene:
-                    return GenomicTxSeg(
-                        errors=[f"Expected gene, {gene}, but found {_gene}"]
-                    )
 
-                gene = _gene
-            else:
+            if err_msg:
                 return GenomicTxSeg(errors=[err_msg])
+
+            if gene and _gene != gene:
+                return GenomicTxSeg(
+                    errors=[f"Expected gene, {gene}, but found {_gene}"]
+                )
+
+            gene = _gene
         elif chromosome:
             # Try GRCh38 first
             for assembly in [Assembly.GRCH38.value, Assembly.GRCH37.value]:
@@ -858,7 +933,7 @@ class ExonGenomicCoordsMapper:
                 )
 
         return await self._get_tx_seg_genomic_metadata(
-            genomic_ac, genomic_pos, is_start, gene, tx_ac=transcript
+            genomic_ac, genomic_pos, is_seg_start, gene, tx_ac=transcript
         )
 
     async def _get_grch38_ac_pos(
@@ -943,85 +1018,37 @@ class ExonGenomicCoordsMapper:
 
         return results[0]["hgnc"], None
 
-    def _get_tx_segment(
+    async def _get_tx_ac_gene(
         self,
-        genomic_ac: str,
-        strand: Strand,
-        offset: int,
-        genomic_ac_data: ExonCoord,
-        is_seg_start: bool = False,
-    ) -> tuple[TxSegment | None, str | None]:
-        """Get transcript segment data given ``genomic_ac`` and offset data
-
-        :param genomic_ac: Genomic RefSeq accession
-        :param strand: Strand
-        :param offset: Exon offset
-        :param genomic_ac_data: Exon coordinate data for ``genomic_ac``
-        :param is_seg_start: ``True`` if retrieving genomic data where the transcript
-            segment starts, defaults to ``False``
-        :return: Transcript segment data
-        """
-        if is_seg_start:
-            if strand == Strand.POSITIVE:
-                seg_genomic_pos = offset + genomic_ac_data.alt_start_i
-            else:
-                seg_genomic_pos = genomic_ac_data.alt_end_i - offset
-        else:
-            if strand == Strand.POSITIVE:
-                seg_genomic_pos = offset + genomic_ac_data.alt_end_i
-            else:
-                seg_genomic_pos = genomic_ac_data.alt_start_i - offset
-
-        genomic_loc, err_msg = self._get_vrs_seq_loc(
-            genomic_ac,
-            seg_genomic_pos,
-            is_start=is_seg_start,
-            strand=strand,
-        )
-        if err_msg:
-            return None, err_msg
-
-        return TxSegment(
-            exon_ord=genomic_ac_data.ord,
-            genomic_location=genomic_loc,
-            offset=offset,
-        ), None
+        tx_ac: str,
+    ) -> tuple[str | None, str | None]:
+        """Get gene given a transcript.
 
-    def _get_vrs_seq_loc(
-        self, genomic_ac: str, genomic_pos: int, is_start: bool, strand: Strand
-    ) -> tuple[SequenceLocation | None, str | None]:
-        """Create VRS Sequence Location for genomic position where transcript segment
-        occurs
+        If multiple genes are found for a given ``tx_ac``, only one
+        gene will be returned.
 
-        :param genomic_ac: RefSeq genomic accession
-        :param genomic_pos: Genomic position where the transcript segment occurs
-        :param is_start: ``True`` if ``genomic_pos`` is where the transcript segment
-            starts. ``False`` if ``genomic_pos`` is where the transcript segment ends.
-        :param strand: Strand
-        :return: Tuple containing VRS location (if successful) and error message (if
-            unable to get GA4GH identifier for ``genomic_ac``).
+        :param tx_ac: RefSeq transcript, e.g. ``"NM_004333.6"``
+        :return: HGNC gene symbol associated to transcript and
+            warning
         """
-        ga4gh_seq_id, err_msg = self.seqrepo_access.translate_identifier(
-            genomic_ac, "ga4gh"
-        )
-        if err_msg:
-            return None, err_msg
-
-        use_start = strand == Strand.POSITIVE if is_start else strand != Strand.POSITIVE
+        query = f"""
+            SELECT DISTINCT hgnc
+            FROM {self.uta_db.schema}.tx_exon_aln_v
+            WHERE tx_ac = '{tx_ac}'
+            ORDER BY hgnc
+            LIMIT 1;
+            """  # noqa: S608
+        results = await self.uta_db.execute_query(query)
+        if not results:
+            return None, f"No gene(s) found given {tx_ac}"
 
-        return SequenceLocation(
-            sequenceReference=SequenceReference(
-                refgetAccession=ga4gh_seq_id[0].split("ga4gh:")[-1]
-            ),
-            start=genomic_pos if use_start else None,
-            end=genomic_pos if not use_start else None,
-        ), None
+        return results[0]["hgnc"], None
 
     async def _get_tx_seg_genomic_metadata(
         self,
         genomic_ac: str,
         genomic_pos: int,
-        is_start: bool,
+        is_seg_start: bool,
         gene: str,
         tx_ac: str | None,
     ) -> GenomicTxSeg:
@@ -1034,7 +1061,7 @@ class ExonGenomicCoordsMapper:
 
         :param genomic_ac: Genomic RefSeq accession
         :param genomic_pos: Genomic position where the transcript segment occurs
-        :param is_start: Whether or not ``genomic_pos`` represents the start position.
+        :param is_seg_start: Whether or not ``genomic_pos`` represents the start position.
         :param gene: HGNC gene symbol
         :param tx_ac: Transcript RefSeq accession. If not provided, will use MANE
             transcript
@@ -1092,12 +1119,12 @@ class ExonGenomicCoordsMapper:
             strand=Strand(tx_exon_aln_data.alt_strand),
             use_start_i=False,  # This doesn't impact anything since we're on the exon
             is_in_exon=True,
-            start=genomic_pos if is_start else None,
-            end=genomic_pos if not is_start else None,
+            start=genomic_pos if is_seg_start else None,
+            end=genomic_pos if not is_seg_start else None,
         )
 
         genomic_location, err_msg = self._get_vrs_seq_loc(
-            genomic_ac, genomic_pos, is_start, tx_exon_aln_data.alt_strand
+            genomic_ac, genomic_pos, is_seg_start, tx_exon_aln_data.alt_strand
         )
         if err_msg:
             return GenomicTxSeg(errors=[err_msg])
@@ -1114,46 +1141,20 @@ class ExonGenomicCoordsMapper:
         )
 
     @staticmethod
-    def _get_exon_offset(
-        start_i: int,
-        end_i: int,
-        strand: Strand,
-        use_start_i: bool = True,
-        is_in_exon: bool = True,
-        start: int | None = None,
-        end: int | None = None,
-    ) -> int:
-        """Compute offset from exon start or end index
+    def _is_exonic_breakpoint(pos: int, tx_genomic_coords: list[_ExonCoord]) -> bool:
+        """Check if a breakpoint occurs on an exon
 
-        :param start_i: Exon start index (inter-residue)
-        :param end_i: Exon end index (inter-residue)
-        :param strand: Strand
-        :param use_start_i: Whether or not ``start_i`` should be used to compute the
-            offset, defaults to ``True``. This is only used when ``is_in_exon`` is
-            ``False``.
-        :param is_in_exon: Whether or not the position occurs in an exon, defaults to
-            ``True``
-        :param start: Provided start position, defaults to ``None``. Must provide
-            ``start`` or ``end``, not both.
-        :param end: Provided end position, defaults to ``None``. Must provide ``start``
-            or ``end``, not both
-        :return: Offset from exon start or end index
+        :param pos: Genomic breakpoint
+        :param tx_genomic_coords: A list of transcript exon coordinate data
+        :return: ``True`` if the breakpoint occurs on an exon
         """
-        if is_in_exon:
-            if start is not None:
-                offset = start - start_i if strand == Strand.POSITIVE else end_i - start
-            else:
-                offset = end - end_i if strand == Strand.POSITIVE else start_i - end
-        else:
-            if strand == Strand.POSITIVE:
-                offset = start - start_i if use_start_i else end - end_i
-            else:
-                offset = start_i - end if use_start_i else end_i - start
-        return offset
+        return any(
+            exon.alt_start_i <= pos <= exon.alt_end_i for exon in tx_genomic_coords
+        )
 
     @staticmethod
     def _get_adjacent_exon(
-        tx_exons_genomic_coords: list[ExonCoord],
+        tx_exons_genomic_coords: list[_ExonCoord],
         strand: Strand,
         start: int | None = None,
         end: int | None = None,
@@ -1191,13 +1192,39 @@ class ExonGenomicCoordsMapper:
         return exon.ord if end else exon.ord + 1
 
     @staticmethod
-    def _is_exonic_breakpoint(pos: int, tx_genomic_coords: list[ExonCoord]) -> bool:
-        """Check if a breakpoint occurs on an exon
+    def _get_exon_offset(
+        start_i: int,
+        end_i: int,
+        strand: Strand,
+        use_start_i: bool = True,
+        is_in_exon: bool = True,
+        start: int | None = None,
+        end: int | None = None,
+    ) -> int:
+        """Compute offset from exon start or end index
 
-        :param pos: Genomic breakpoint
-        :param tx_genomic_coords: A list of transcript exon coordinate data
-        :return: ``True`` if the breakpoint occurs on an exon
+        :param start_i: Exon start index (inter-residue)
+        :param end_i: Exon end index (inter-residue)
+        :param strand: Strand
+        :param use_start_i: Whether or not ``start_i`` should be used to compute the
+            offset, defaults to ``True``. This is only used when ``is_in_exon`` is
+            ``False``.
+        :param is_in_exon: Whether or not the position occurs in an exon, defaults to
+            ``True``
+        :param start: Provided start position, defaults to ``None``. Must provide
+            ``start`` or ``end``, not both.
+        :param end: Provided end position, defaults to ``None``. Must provide ``start``
+            or ``end``, not both
+        :return: Offset from exon start or end index
         """
-        return any(
-            exon.alt_start_i <= pos <= exon.alt_end_i for exon in tx_genomic_coords
-        )
+        if is_in_exon:
+            if start is not None:
+                offset = start - start_i if strand == Strand.POSITIVE else end_i - start
+            else:
+                offset = end - end_i if strand == Strand.POSITIVE else start_i - end
+        else:
+            if strand == Strand.POSITIVE:
+                offset = start - start_i if use_start_i else end - end_i
+            else:
+                offset = start_i - end if use_start_i else end_i - start
+        return offset

{cool_seq_tool-0.7.0.dist-info → cool_seq_tool-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cool_seq_tool
-Version: 0.7.0
+Version: 0.7.1
 Summary: Common Operation on Lots of Sequences Tool
 Author: Kori Kuzma, James Stevenson, Katie Stahl, Alex Wagner
 License: MIT License

{cool_seq_tool-0.7.0.dist-info → cool_seq_tool-0.7.1.dist-info}/RECORD

@@ -6,7 +6,7 @@ cool_seq_tool/handlers/__init__.py,sha256=KalQ46vX1MO4SJz2SlspKoIRy1n3c3Vp1t4Y2p
 cool_seq_tool/handlers/seqrepo_access.py,sha256=Jd19jbdUvPRPn_XWozL67ph-nSIxpb4_UUimapDrsm4,9162
 cool_seq_tool/mappers/__init__.py,sha256=O0JRxNFk8nWxD4v5ij47xelhvfVLdEXS43l2tzRuiUE,305
 cool_seq_tool/mappers/alignment.py,sha256=nV6PS3mhkQ2MD1GcpNBujBOqd3AKxYSYA9BCusFOa1o,9636
-cool_seq_tool/mappers/exon_genomic_coords.py,sha256=hfzfuxsNwMvj6y9thwWCj4WcOXamdnqvvd29gmX19Bo,48261
+cool_seq_tool/mappers/exon_genomic_coords.py,sha256=lfmzuVXaYT7w2FBDS3xhJNgETusllomFy5Utzhfhlpc,48782
 cool_seq_tool/mappers/liftover.py,sha256=lltx9zxfkrb5PHtJlKp3a39JCwPP4e0Zft-mQc1jXL8,3367
 cool_seq_tool/mappers/mane_transcript.py,sha256=nirxlf3EGVInFYG4fsAqiEmDdTc_h1XuPyX2ul-a7Rk,54368
 cool_seq_tool/resources/__init__.py,sha256=VwUC8YaucTS6SmRirToulZTF6CuvuLQRSxFfSfAovCc,77
@@ -17,8 +17,8 @@ cool_seq_tool/sources/__init__.py,sha256=51QiymeptF7AeVGgV-tW_9f4pIUr0xtYbyzpvHO
 cool_seq_tool/sources/mane_transcript_mappings.py,sha256=E_pj7FEBcB6HUR8yhSVibB0beMMlKJ62pK0qvl4y5nw,5358
 cool_seq_tool/sources/transcript_mappings.py,sha256=903RKTMBO2rbKh6iTQ1BEWnY4C7saBFMPw2_4ATuudg,10054
 cool_seq_tool/sources/uta_database.py,sha256=gc5wsKOIhvzhwFmPmqOY0hhaVfRkRSzYNa9tpBt81_U,35017
-cool_seq_tool-0.7.0.dist-info/LICENSE,sha256=IpqC9A-tZW7XXXvCS8c4AVINqkmpxiVA-34Qe3CZSjo,1072
-cool_seq_tool-0.7.0.dist-info/METADATA,sha256=UrSjQTJOgl4sqFvMG_p_TpeZW2R0GE6lMGus9NQhUew,6226
-cool_seq_tool-0.7.0.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-cool_seq_tool-0.7.0.dist-info/top_level.txt,sha256=cGuxdN6p3y16jQf6hCwWhE4OptwUeZPm_PNJlPb3b0k,14
-cool_seq_tool-0.7.0.dist-info/RECORD,,
+cool_seq_tool-0.7.1.dist-info/LICENSE,sha256=IpqC9A-tZW7XXXvCS8c4AVINqkmpxiVA-34Qe3CZSjo,1072
+cool_seq_tool-0.7.1.dist-info/METADATA,sha256=Y9_RZI2iHpmNOFwXoFCCKyHs6aXmNrzKQfyHkmqUVmQ,6226
+cool_seq_tool-0.7.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+cool_seq_tool-0.7.1.dist-info/top_level.txt,sha256=cGuxdN6p3y16jQf6hCwWhE4OptwUeZPm_PNJlPb3b0k,14
+cool_seq_tool-0.7.1.dist-info/RECORD,,

{cool_seq_tool-0.7.0.dist-info → cool_seq_tool-0.7.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any