cool-seq-tool 0.4.0.dev3__py3-none-any.whl → 0.5.0__py3-none-any.whl

cool_seq_tool/mappers/exon_genomic_coords.py

@@ -1,8 +1,10 @@
 """Provide mapping capabilities between transcript exon and genomic coordinates."""
+
 import logging
-from typing import Dict, List, Optional, Tuple, TypeVar, Union
+from typing import Literal, TypeVar
 
 from cool_seq_tool.handlers.seqrepo_access import SeqRepoAccess
+from cool_seq_tool.mappers.liftover import LiftOver
 from cool_seq_tool.mappers.mane_transcript import CdnaRepresentation, ManeTranscript
 from cool_seq_tool.schemas import (
     AnnotationLayer,
@@ -22,7 +24,7 @@ CoordinatesResponseType = TypeVar(
     "CoordinatesResponseType", GenomicDataResponse, TranscriptExonDataResponse
 )
 
-logger = logging.getLogger(__name__)
+_logger = logging.getLogger(__name__)
 
 
 class ExonGenomicCoordsMapper:
@@ -36,6 +38,7 @@ class ExonGenomicCoordsMapper:
         uta_db: UtaDatabase,
         mane_transcript: ManeTranscript,
         mane_transcript_mappings: ManeTranscriptMappings,
+        liftover: LiftOver,
     ) -> None:
         """Initialize ExonGenomicCoordsMapper class.
 
@@ -50,46 +53,49 @@ class ExonGenomicCoordsMapper:
         event loop. See the :ref:`Usage section <async_note>` for more information.
 
         >>> import asyncio
-        >>> result = asyncio.run(egc.transcript_to_genomic_coordinates(
-        ...     "NM_002529.3",
-        ...     exon_start=2,
-        ...     exon_end=17
-        ... ))
+        >>> result = asyncio.run(
+        ...     egc.transcript_to_genomic_coordinates(
+        ...         "NM_002529.3", exon_start=2, exon_end=17
+        ...     )
+        ... )
         >>> result.genomic_data.start, result.genomic_data.end
         (156864428, 156881456)
 
-        :param: seqrepo_access: SeqRepo instance to give access to query SeqRepo database
+        :param seqrepo_access: SeqRepo instance to give access to query SeqRepo database
         :param uta_db: UtaDatabase instance to give access to query UTA database
         :param mane_transcript: Instance to align to MANE or compatible representation
         :param mane_transcript_mappings: Instance to provide access to ManeTranscriptMappings class
+        :param liftover: Instance to provide mapping between human genome assemblies
         """
         self.seqrepo_access = seqrepo_access
         self.uta_db = uta_db
         self.mane_transcript = mane_transcript
         self.mane_transcript_mappings = mane_transcript_mappings
+        self.liftover = liftover
 
     @staticmethod
     def _return_warnings(
-        resp: CoordinatesResponseType, warning_msg: str
+        resp: CoordinatesResponseType, warning_msg: list[str]
     ) -> CoordinatesResponseType:
         """Add warnings to response object
 
         :param resp: Response object
-        :param warning_msg: Warning message on why ``transcript_exon_data`` or
+        :param warning_msg: Warning message(s) on why ``transcript_exon_data`` or
             ``genomic_data`` field is ``None``
         :return: Response object with warning message
         """
-        logger.warning(warning_msg)
-        resp.warnings.append(warning_msg)
+        for msg in warning_msg:
+            _logger.warning(msg)
+            resp.warnings.append(msg)
         return resp
 
     async def transcript_to_genomic_coordinates(
         self,
         transcript: str,
-        gene: Optional[str] = None,
-        exon_start: Optional[int] = None,
+        gene: str | None = None,
+        exon_start: int | None = None,
         exon_start_offset: int = 0,
-        exon_end: Optional[int] = None,
+        exon_end: int | None = None,
         exon_end_offset: int = 0,
     ) -> GenomicDataResponse:
         """Get genomic data given transcript data.
@@ -99,11 +105,14 @@ class ExonGenomicCoordsMapper:
         >>> import asyncio
         >>> from cool_seq_tool.app import CoolSeqTool
         >>> egc = CoolSeqTool().ex_g_coords_mapper
-        >>> tpm3 = asyncio.run(egc.transcript_to_genomic_coordinates(
-        ...     "NM_152263.3"
-        ...     gene="TPM3", chr="NC_000001.11",
-        ...     exon_start=1, exon_end=8,
-        ... ))
+        >>> tpm3 = asyncio.run(
+        ...     egc.transcript_to_genomic_coordinates(
+        ...         "NM_152263.3",
+        ...         gene="TPM3",
+        ...         exon_start=1,
+        ...         exon_end=8,
+        ...     )
+        ... )
         >>> tpm3.genomic_data.chr, tpm3.genomic_data.start, tpm3.genomic_data.end
         ('NC_000001.11', 154192135, 154170399)
 
@@ -122,42 +131,44 @@ class ExonGenomicCoordsMapper:
         )
 
         # Ensure valid inputs
+        warnings = []
         if not transcript:
-            return self._return_warnings(resp, "Must provide `transcript`")
-        transcript = transcript.strip()
+            warnings.append("Must provide `transcript`")
+        else:
+            transcript = transcript.strip()
 
         exon_start_exists, exon_end_exists = False, False
         if exon_start is not None:
             if exon_start < 1:
-                return self._return_warnings(resp, "`exon_start` cannot be less than 1")
+                warnings.append("`exon_start` cannot be less than 1")
             exon_start_exists = True
 
         if exon_end is not None:
             if exon_end < 1:
-                return self._return_warnings(resp, "`exon_end` cannot be less than 1")
+                warnings.append("`exon_end` cannot be less than 1")
             exon_end_exists = True
 
         if not exon_start_exists and not exon_end_exists:
-            return self._return_warnings(
-                resp, "Must provide either `exon_start` or `exon_end`"
-            )
+            warnings.append("Must provide either `exon_start` or `exon_end`")
         if exon_start_exists and exon_end_exists and (exon_start > exon_end):
-            return self._return_warnings(
-                resp,
-                f"Start exon {exon_start} is greater than end exon {exon_end}",
+            warnings.append(
+                f"Start exon {exon_start} is greater than end exon {exon_end}"
             )
 
+        if warnings:
+            return self._return_warnings(resp, warnings)
+
         # Get all exons and associated start/end coordinates for transcript
         tx_exons, warning = await self.uta_db.get_tx_exons(transcript)
         if not tx_exons:
-            return self._return_warnings(resp, warning or "")
+            return self._return_warnings(resp, [warning] if warning else [])
 
         # Get exon start and exon end coordinates
         tx_exon_coords, warning = self.get_tx_exon_coords(
             transcript, tx_exons, exon_start, exon_end
         )
         if not tx_exon_coords:
-            return self._return_warnings(resp, warning or "")
+            return self._return_warnings(resp, [warning] if warning else [])
         tx_exon_start_coords, tx_exon_end_coords = tx_exon_coords
 
         if gene:
@@ -169,7 +180,7 @@ class ExonGenomicCoordsMapper:
             transcript, tx_exon_start_coords, tx_exon_end_coords, gene=gene
         )
         if not alt_ac_start_end:
-            return self._return_warnings(resp, warning or "")
+            return self._return_warnings(resp, [warning] if warning else [])
         alt_ac_start_data, alt_ac_end_data = alt_ac_start_end
 
         # Get gene and chromosome data, check that at least one was retrieved
@@ -178,8 +189,9 @@ class ExonGenomicCoordsMapper:
         if gene is None or chromosome is None:
             return self._return_warnings(
                 resp,
-                "Unable to retrieve `gene` or `chromosome` from genomic start and "
-                "genomic end data",
+                [
+                    "Unable to retrieve `gene` or `chromosome` from genomic start and genomic end data"
+                ],
             )
 
         g_start = alt_ac_start_data[3] - 1 if alt_ac_start_data else None
@@ -223,17 +235,16 @@ class ExonGenomicCoordsMapper:
 
     async def genomic_to_transcript_exon_coordinates(
         self,
-        chromosome: Optional[str] = None,
-        alt_ac: Optional[str] = None,
-        start: Optional[int] = None,
-        end: Optional[int] = None,
-        strand: Optional[Strand] = None,
-        transcript: Optional[str] = None,
+        chromosome: str | None = None,
+        alt_ac: str | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        strand: Strand | None = None,
+        transcript: str | None = None,
         get_nearest_transcript_junction: bool = False,
-        gene: Optional[str] = None,
-        residue_mode: Union[
-            ResidueMode.INTER_RESIDUE, ResidueMode.RESIDUE
-        ] = ResidueMode.RESIDUE,
+        gene: str | None = None,
+        residue_mode: Literal[ResidueMode.INTER_RESIDUE]
+        | Literal[ResidueMode.RESIDUE] = ResidueMode.RESIDUE,
     ) -> GenomicDataResponse:
         """Get transcript data for genomic data, lifted over to GRCh38.
 
@@ -244,19 +255,20 @@ class ExonGenomicCoordsMapper:
         >>> from cool_seq_tool.app import CoolSeqTool
         >>> from cool_seq_tool.schemas import Strand
         >>> egc = CoolSeqTool().ex_g_coords_mapper
-        >>> result = asyncio.run(egc.genomic_to_transcript_exon_coordinates(
-        ...     chromosome="NC_000001.11",
-        ...     start=154192136,
-        ...     end=154170400,
-        ...     strand=Strand.NEGATIVE,
-        ...     transcript="NM_152263.3"
-        ... ))
+        >>> result = asyncio.run(
+        ...     egc.genomic_to_transcript_exon_coordinates(
+        ...         alt_ac="NC_000001.11",
+        ...         start=154192136,
+        ...         end=154170400,
+        ...         strand=Strand.NEGATIVE,
+        ...         transcript="NM_152263.3",
+        ...     )
+        ... )
         >>> result.genomic_data.exon_start, result.genomic_data.exon_end
         (1, 8)
 
-        :param chromosome: Chromosome. Must give chromosome without a prefix
-            (i.e. ``1`` or ``X``). If not provided, must provide ``alt_ac``.
-            If ``alt_ac`` is also provided, ``alt_ac`` will be used.
+        :param chromosome: e.g. ``"1"`` or ``"chr1"``. If not provided, must provide
+            ``alt_ac``. If ``alt_ac`` is also provided, ``alt_ac`` will be used.
         :param alt_ac: Genomic accession (i.e. ``NC_000001.11``). If not provided,
             must provide ``chromosome. If ``chromosome`` is also provided, ``alt_ac``
             will be used.
@@ -267,21 +279,30 @@ class ExonGenomicCoordsMapper:
             following transcripts: MANE Select, MANE Clinical Plus, Longest Remaining
             Compatible Transcript. See the :ref:`Transcript Selection policy <transcript_selection_policy>`
             page.
-        param get_nearest_transcript_junction: If ``True``, this will return the
+        :param get_nearest_transcript_junction: If ``True``, this will return the
             adjacent exon if the position specified by``start`` or ``end`` does not
             occur on an exon. For the positive strand, adjacent is defined as the exon
             preceding the breakpoint for the 5' end and the exon 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 gene: gene name. Ideally, HGNC symbol. Must be given if no ``transcript``
+            value is provided.
         :param residue_mode: Residue mode for ``start`` and ``end``
         :return: Genomic data (inter-residue coordinates)
         """
         resp = GenomicDataResponse(
             genomic_data=None, warnings=[], service_meta=service_meta()
         )
+        warnings = []
         if start is None and end is None:
-            return self._return_warnings(resp, "Must provide either `start` or `end`")
+            warnings.append("Must provide either `start` or `end`")
+        if chromosome is None and alt_ac is None:
+            warnings.append("Must provide either `chromosome` or `alt_ac`")
+        if transcript is None and gene is None:
+            warnings.append("Must provide either `gene` or `transcript`")
+        if warnings:
+            return self._return_warnings(resp, warnings)
 
         params = {key: None for key in GenomicData.model_fields}
         if gene is not None:
@@ -305,7 +326,7 @@ class ExonGenomicCoordsMapper:
             if start_data.transcript_exon_data:
                 start_data = start_data.transcript_exon_data.model_dump()
             else:
-                return self._return_warnings(resp, start_data.warnings[0])
+                return self._return_warnings(resp, [start_data.warnings[0]])
         else:
             start_data = None
 
@@ -325,7 +346,7 @@ class ExonGenomicCoordsMapper:
             if end_data.transcript_exon_data:
                 end_data = end_data.transcript_exon_data.model_dump()
             else:
-                return self._return_warnings(resp, end_data.warnings[0])
+                return self._return_warnings(resp, [end_data.warnings[0]])
         else:
             end_data = None
 
@@ -336,7 +357,7 @@ class ExonGenomicCoordsMapper:
                         f"Start `{field}`, {start_data[field]}, does "
                         f"not match End `{field}`, {end_data[field]}"
                     )
-                    return self._return_warnings(resp, msg)
+                    return self._return_warnings(resp, [msg])
                 params[field] = start_data[field]
             else:
                 params[field] = end_data[field]
@@ -346,7 +367,7 @@ class ExonGenomicCoordsMapper:
                 f"Input gene, {gene}, does not match expected output"
                 f"gene, {params['gene']}"
             )
-            return self._return_warnings(resp, msg)
+            return self._return_warnings(resp, [msg])
 
         for label, data in [("start", start_data), ("end", end_data)]:
             if data:
@@ -358,8 +379,8 @@ class ExonGenomicCoordsMapper:
 
     @staticmethod
     def _validate_exon(
-        transcript: str, tx_exons: List[Tuple[int, int]], exon_number: int
-    ) -> Tuple[Optional[Tuple[int, int]], Optional[str]]:
+        transcript: str, tx_exons: list[tuple[int, int]], exon_number: int
+    ) -> tuple[tuple[int, int] | None, str | None]:
         """Validate that exon number exists on a given transcript
 
         :param transcript: Transcript accession
@@ -379,12 +400,12 @@ class ExonGenomicCoordsMapper:
     def get_tx_exon_coords(
         self,
         transcript: str,
-        tx_exons: List[Tuple[int, int]],
-        exon_start: Optional[int] = None,
-        exon_end: Optional[int] = None,
-    ) -> Tuple[
-        Optional[Tuple[Optional[Tuple[int, int]], Optional[Tuple[int, int]]]],
-        Optional[str],
+        tx_exons: list[tuple[int, int]],
+        exon_start: int | None = None,
+        exon_end: int | None = None,
+    ) -> tuple[
+        tuple[tuple[int, int] | None, tuple[int, int] | None] | None,
+        str | None,
     ]:
         """Get exon coordinates for ``exon_start`` and ``exon_end``
 
@@ -415,10 +436,10 @@ class ExonGenomicCoordsMapper:
     async def _get_alt_ac_start_and_end(
         self,
         tx_ac: str,
-        tx_exon_start: Optional[Tuple[int, int]] = None,
-        tx_exon_end: Optional[Tuple[int, int]] = None,
-        gene: Optional[str] = None,
-    ) -> Tuple[Optional[Tuple[Tuple[int, int], Tuple[int, int]]], Optional[str]]:
+        tx_exon_start: tuple[int, int] | None = None,
+        tx_exon_end: tuple[int, int] | None = None,
+        gene: str | None = None,
+    ) -> tuple[tuple[tuple[int, int], tuple[int, int]] | None, str | None]:
         """Get aligned genomic coordinates for transcript exon start and end.
 
         :param tx_ac: Transcript accession
@@ -431,7 +452,7 @@ class ExonGenomicCoordsMapper:
         """
         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)
+            _logger.warning(msg)
             return None, msg
 
         alt_ac_data = {"start": None, "end": None}
@@ -457,7 +478,7 @@ class ExonGenomicCoordsMapper:
                         error = "Genomic accession does not match"
                     else:
                         error = "Strand does not match"
-                    logger.warning(
+                    _logger.warning(
                         "%s: %s != %s",
                         error,
                         alt_ac_data["start"][i],
@@ -469,11 +490,11 @@ class ExonGenomicCoordsMapper:
     async def _genomic_to_transcript_exon_coordinate(
         self,
         pos: int,
-        chromosome: Optional[str] = None,
-        alt_ac: Optional[str] = None,
-        strand: Optional[Strand] = None,
-        transcript: Optional[str] = None,
-        gene: Optional[str] = None,
+        chromosome: str | None = None,
+        alt_ac: str | None = None,
+        strand: Strand | None = None,
+        transcript: str | None = None,
+        gene: str | None = None,
         get_nearest_transcript_junction: bool = False,
         is_start: bool = True,
     ) -> TranscriptExonDataResponse:
@@ -505,25 +526,22 @@ class ExonGenomicCoordsMapper:
         resp = TranscriptExonDataResponse(
             transcript_exon_data=None, warnings=[], service_meta=service_meta()
         )
-
-        if transcript is None and gene is None:
-            return self._return_warnings(
-                resp, "Must provide either `gene` or `transcript`"
-            )
-
         params = {key: None for key in TranscriptExonData.model_fields}
 
         if get_nearest_transcript_junction:
             if not gene or not strand:
                 return self._return_warnings(
                     resp,
-                    "Gene or strand must be provided to select the adjacent transcript junction",
+                    [
+                        "Gene or strand must be provided to select the adjacent transcript junction"
+                    ],
                 )
-            alt_acs, w = self.seqrepo_access.chromosome_to_acs(chromosome)
+            if not alt_ac:
+                alt_acs, w = self.seqrepo_access.chromosome_to_acs(chromosome)
 
-            if not alt_acs:
-                return self._return_warnings(resp, w)
-            alt_ac = alt_acs[0]
+                if not alt_acs:
+                    return self._return_warnings(resp, [w])
+                alt_ac = alt_acs[0]
 
             if not transcript:
                 # Select a transcript if not provided
@@ -557,14 +575,14 @@ class ExonGenomicCoordsMapper:
                         else:
                             return self._return_warnings(
                                 resp,
-                                f"Could not find a transcript for {gene} on {alt_ac}",
+                                [f"Could not find a transcript for {gene} on {alt_ac}"],
                             )
 
             tx_genomic_coords, w = await self.uta_db.get_tx_exons_genomic_coords(
                 tx_ac=transcript, alt_ac=alt_ac
             )
             if not tx_genomic_coords:
-                return self._return_warnings(resp, w)
+                return self._return_warnings(resp, [w])
 
             # Check if breakpoint occurs on an exon.
             # If not, determine the adjacent exon given the selected transcript
@@ -592,13 +610,13 @@ class ExonGenomicCoordsMapper:
                 )
                 params["strand"] = strand.value
                 resp.transcript_exon_data = TranscriptExonData(**params)
-            return resp
+                return resp
 
         if alt_ac:
             # Check if valid accession is given
             if not await self.uta_db.validate_genomic_ac(alt_ac):
                 return self._return_warnings(
-                    resp, f"Invalid genomic accession: {alt_ac}"
+                    resp, [f"Invalid genomic accession: {alt_ac}"]
                 )
 
             genes_alt_acs, warning = await self.uta_db.get_genes_and_alt_acs(
@@ -621,11 +639,11 @@ class ExonGenomicCoordsMapper:
             genes_alt_acs = None
 
         if not genes_alt_acs:
-            return self._return_warnings(resp, warning)
+            return self._return_warnings(resp, [warning])
 
         gene_alt_ac, warning = self._get_gene_and_alt_ac(genes_alt_acs, gene)
         if not gene_alt_ac:
-            return self._return_warnings(resp, warning)
+            return self._return_warnings(resp, [warning])
         gene, alt_ac = gene_alt_ac
 
         if transcript is None:
@@ -633,7 +651,7 @@ class ExonGenomicCoordsMapper:
                 params, gene, alt_ac, pos, strand, is_start
             )
             if warnings:
-                return self._return_warnings(resp, warnings)
+                return self._return_warnings(resp, [warnings])
         else:
             params["transcript"] = transcript
             params["gene"] = gene
@@ -641,15 +659,15 @@ class ExonGenomicCoordsMapper:
             params["chr"] = alt_ac
             warning = await self._set_genomic_data(params, strand, is_start)
             if warning:
-                return self._return_warnings(resp, warning)
+                return self._return_warnings(resp, [warning])
 
         resp.transcript_exon_data = TranscriptExonData(**params)
         return resp
 
     @staticmethod
     def _get_gene_and_alt_ac(
-        genes_alt_acs: Dict, gene: Optional[str]
-    ) -> Tuple[Optional[Tuple[str, str]], Optional[str]]:
+        genes_alt_acs: dict, gene: str | None
+    ) -> tuple[tuple[str, str] | None, str | None]:
         """Return gene genomic accession
 
         :param genes_alt_acs: Dictionary containing genes and genomic accessions
@@ -687,13 +705,13 @@ class ExonGenomicCoordsMapper:
 
     async def _set_mane_genomic_data(
         self,
-        params: Dict,
+        params: dict,
         gene: str,
         alt_ac: str,
         pos: int,
         strand: Strand,
         is_start: bool,
-    ) -> Optional[str]:
+    ) -> str | None:
         """Set genomic data in `params` found from MANE.
 
         :param params: Parameters for response
@@ -706,9 +724,9 @@ class ExonGenomicCoordsMapper:
         :return: Warnings if found
         """
         start, end = get_inter_residue_pos(pos, pos, residue_mode=ResidueMode.ZERO)
-        mane_data: Optional[
-            CdnaRepresentation
-        ] = await self.mane_transcript.get_mane_transcript(
+        mane_data: (
+            CdnaRepresentation | None
+        ) = await self.mane_transcript.get_mane_transcript(
             alt_ac,
             start,
             end,
@@ -721,7 +739,7 @@ class ExonGenomicCoordsMapper:
             msg = f"Unable to find mane data for {alt_ac} with position {pos}"
             if gene:
                 msg += f" on gene {gene}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return msg
 
         params["gene"] = mane_data.gene
@@ -745,7 +763,7 @@ class ExonGenomicCoordsMapper:
                 f"{params['transcript']} with position {tx_pos} "
                 f"does not exist on exons: {tx_exons}"
             )
-            logger.warning(msg)
+            _logger.warning(msg)
             return msg
 
         strand_to_use = strand if strand is not None else mane_data.strand
@@ -777,8 +795,8 @@ class ExonGenomicCoordsMapper:
         return None
 
     async def _set_genomic_data(
-        self, params: Dict, strand: Strand, is_start: bool
-    ) -> Optional[str]:
+        self, params: dict, strand: Strand, is_start: bool
+    ) -> str | None:
         """Set genomic data in ``params``
 
         :param params: Parameters for response
@@ -800,7 +818,7 @@ class ExonGenomicCoordsMapper:
                 return f"Unable to get chromosome and assembly for " f"{params['chr']}"
 
             chromosome_number, assembly = descr
-            liftover_data = self.uta_db.get_liftover(
+            liftover_data = self.liftover.get_liftover(
                 chromosome_number, params["pos"], Assembly.GRCH38
             )
             if liftover_data is None:
@@ -861,7 +879,7 @@ class ExonGenomicCoordsMapper:
 
     @staticmethod
     def _set_exon_offset(
-        params: Dict, start: int, end: int, pos: int, is_start: bool, strand: Strand
+        params: dict, start: int, end: int, pos: int, is_start: bool, strand: Strand
     ) -> None:
         """Set value for ``exon_offset`` in ``params``.
 
@@ -885,26 +903,23 @@ class ExonGenomicCoordsMapper:
                 params["exon_offset"] = pos - start
 
     async def _structure_exons(
-        self, transcript: str, alt_ac: Optional[str] = None
-    ) -> List[Tuple[int, int]]:
+        self, transcript: str, alt_ac: str | None = None
+    ) -> list[tuple[int, int]]:
         """Structure exons as list of tuples.
 
         :param transcript: Transcript accession
         :param alt_ac: Genomic accession
         :return: List of tuples containing transcript exon coordinates
         """
-        result = []
         tx_exons, _ = await self.uta_db.get_tx_exons(transcript, alt_ac=alt_ac)
 
         if not tx_exons:
-            return result
+            return []
 
-        for coords in tx_exons:
-            result.append((coords[0], coords[1]))
-        return result
+        return [(coords[0], coords[1]) for coords in tx_exons]
 
     @staticmethod
-    def _get_exon_number(tx_exons: List, tx_pos: int) -> int:
+    def _get_exon_number(tx_exons: list, tx_pos: int) -> int:
         """Find related exon number for a position
 
         :param tx_exons: List of exon coordinates for a transcript
@@ -920,10 +935,10 @@ class ExonGenomicCoordsMapper:
 
     @staticmethod
     def _get_adjacent_exon(
-        tx_exons_genomic_coords: List[Tuple[int, int, int, int, int]],
+        tx_exons_genomic_coords: list[tuple[int, int, int, int, int]],
         strand: Strand,
-        start: Optional[int] = None,
-        end: Optional[int] = None,
+        start: int | None = None,
+        end: int | None = None,
     ) -> int:
         """Return the adjacent exon given a non-exonic breakpoint. For the positive
         strand, adjacent is defined as the exon preceding the breakpoint for the 5' end
@@ -961,7 +976,7 @@ class ExonGenomicCoordsMapper:
         return exon[0] + 1 if end else exon[0] + 2
 
     @staticmethod
-    def _is_exonic_breakpoint(pos: int, tx_genomic_coords: List) -> bool:
+    def _is_exonic_breakpoint(pos: int, tx_genomic_coords: list) -> bool:
         """Check if a breakpoint occurs on an exon
 
         :param pos: Genomic breakpoint