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

cool_seq_tool/__init__.py

@@ -1,8 +1,6 @@
 """The cool_seq_tool package"""
-import logging
-from pathlib import Path
 
-APP_ROOT = Path(__file__).resolve().parents[0]
+import logging
 
 logging.basicConfig(
     filename="cool_seq_tool.log",

cool_seq_tool/api.py

@@ -1,5 +1,4 @@
 """Main application for FastAPI"""
-from typing import Dict
 
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
@@ -19,7 +18,7 @@ app.include_router(mane.router)
 app.include_router(mappings.router)
 
 
-def custom_openapi() -> Dict:
+def custom_openapi() -> dict:
     """Generate custom fields for OpenAPI response."""
     if app.openapi_schema:
         return app.openapi_schema

cool_seq_tool/app.py

@@ -1,24 +1,18 @@
 """Provides core CoolSeqTool class, which non-redundantly initializes all Cool-Seq-Tool
 data handler and mapping resources for straightforward access.
 """
+
 import logging
 from pathlib import Path
-from typing import Optional
 
 from biocommons.seqrepo import SeqRepo
 
-from cool_seq_tool.handlers.seqrepo_access import SeqRepoAccess
+from cool_seq_tool.handlers.seqrepo_access import SEQREPO_ROOT_DIR, SeqRepoAccess
 from cool_seq_tool.mappers import (
     AlignmentMapper,
     ExonGenomicCoordsMapper,
     ManeTranscript,
 )
-from cool_seq_tool.paths import (
-    LRG_REFSEQGENE_PATH,
-    MANE_SUMMARY_PATH,
-    SEQREPO_ROOT_DIR,
-    TRANSCRIPT_MAPPINGS_PATH,
-)
 from cool_seq_tool.sources.mane_transcript_mappings import ManeTranscriptMappings
 from cool_seq_tool.sources.transcript_mappings import TranscriptMappings
 from cool_seq_tool.sources.uta_database import UTA_DB_URL, UtaDatabase
@@ -37,26 +31,44 @@ class CoolSeqTool:
     * ``self.alignment_mapper``: :py:class:`AlignmentMapper <cool_seq_tool.mappers.alignment.AlignmentMapper>`
     * ``self.mane_transcript``: :py:class:`ManeTranscript <cool_seq_tool.mappers.mane_transcript.ManeTranscript>`
     * ``self.ex_g_coords_mapper``: :py:class:`ExonGenomicCoordsMapper <cool_seq_tool.mappers.exon_genomic_coords.ExonGenomicCoordsMapper>`
-
-    Initialization with default resource locations is straightforward:
-
-    .. code-block:: pycon
-
-       >>> from cool_seq_tool.app import CoolSeqTool
-       >>> cst = CoolSeqTool()
-
-    See the :ref:`configuration <configuration>` section for more information.
     """
 
     def __init__(
         self,
-        transcript_file_path: Path = TRANSCRIPT_MAPPINGS_PATH,
-        lrg_refseqgene_path: Path = LRG_REFSEQGENE_PATH,
-        mane_data_path: Path = MANE_SUMMARY_PATH,
+        transcript_file_path: Path | None = None,
+        lrg_refseqgene_path: Path | None = None,
+        mane_data_path: Path | None = None,
         db_url: str = UTA_DB_URL,
-        sr: Optional[SeqRepo] = None,
+        sr: SeqRepo | None = None,
+        force_local_files: bool = False,
     ) -> None:
-        """Initialize CoolSeqTool class
+        """Initialize CoolSeqTool class.
+
+        Initialization with default resource locations is straightforward:
+
+        >>> from cool_seq_tool.app import CoolSeqTool
+        >>> cst = CoolSeqTool()
+
+        By default, this will attempt to fetch the latest versions of static resources,
+        which means brief FTP and HTTPS requests to NCBI servers upon initialization.
+        To suppress this check and simply rely on the most recent locally-available
+        data:
+
+        >>> cst = CoolSeqTool(force_local_files=True)
+
+        Note that this will raise a FileNotFoundError if no locally-available data exists.
+
+        Paths to those files can also be explicitly passed to avoid checks as well:
+
+        >>> from pathlib import Path
+        >>> cst = CoolSeqTool(
+        ...     lrg_refseqgene_path=Path("lrg_refseqgene_20240625.tsv"),
+        ...     mane_data_path=Path("ncbi_mane_summary_1.3.txt"),
+        ... )
+
+        If not passed explicit arguments, these locations can also be set via
+        environment variables. See the :ref:`configuration <configuration>` section of
+        the docs for more information.
 
         :param transcript_file_path: The path to ``transcript_mapping.tsv``
         :param lrg_refseqgene_path: The path to the LRG_RefSeqGene file
@@ -64,6 +76,8 @@ class CoolSeqTool:
         :param db_url: PostgreSQL connection URL
             Format: ``driver://user:password@host/database/schema``
         :param sr: SeqRepo instance. If this is not provided, will create a new instance
+        :param force_local_files: if ``True``, don't check for or try to acquire latest
+            versions of static data files -- just use most recently available, if any
         """
         if not sr:
             sr = SeqRepo(root_dir=SEQREPO_ROOT_DIR)
@@ -71,9 +85,10 @@ class CoolSeqTool:
         self.transcript_mappings = TranscriptMappings(
             transcript_file_path=transcript_file_path,
             lrg_refseqgene_path=lrg_refseqgene_path,
+            from_local=force_local_files,
         )
         self.mane_transcript_mappings = ManeTranscriptMappings(
-            mane_data_path=mane_data_path
+            mane_data_path=mane_data_path, from_local=force_local_files
         )
         self.uta_db = UtaDatabase(db_url=db_url)
         self.alignment_mapper = AlignmentMapper(

cool_seq_tool/handlers/__init__.py

@@ -1,2 +1,3 @@
 """Module for extending clients"""
+
 from .seqrepo_access import SeqRepoAccess

cool_seq_tool/handlers/seqrepo_access.py

@@ -1,10 +1,10 @@
 """Wrap SeqRepo to provide additional lookup and identification methods on top of basic
 dereferencing functions.
 """
+
 import logging
 from os import environ
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
 
 from ga4gh.vrs.dataproxy import SeqRepoDataProxy
 
@@ -14,6 +14,9 @@ from cool_seq_tool.utils import get_inter_residue_pos
 logger = logging.getLogger(__name__)
 
 
+SEQREPO_ROOT_DIR = environ.get("SEQREPO_ROOT_DIR", "/usr/local/share/seqrepo/latest")
+
+
 class SeqRepoAccess(SeqRepoDataProxy):
     """Provide a wrapper around the base SeqRepoDataProxy class from ``VRS-Python`` to
     provide additional lookup and identification methods.
@@ -24,10 +27,10 @@ class SeqRepoAccess(SeqRepoDataProxy):
     def get_reference_sequence(
         self,
         ac: str,
-        start: Optional[int] = None,
-        end: Optional[int] = None,
+        start: int | None = None,
+        end: int | None = None,
         residue_mode: ResidueMode = ResidueMode.RESIDUE,
-    ) -> Tuple[str, Optional[str]]:
+    ) -> tuple[str, str | None]:
         """Get reference sequence for an accession given a start and end position. If
         ``start`` and ``end`` are not given, returns the entire reference sequence.
 
@@ -93,8 +96,8 @@ class SeqRepoAccess(SeqRepoDataProxy):
             return sequence, None
 
     def translate_identifier(
-        self, ac: str, target_namespaces: Optional[Union[str, List[str]]] = None
-    ) -> Tuple[List[str], Optional[str]]:
+        self, ac: str, target_namespaces: str | list[str] | None = None
+    ) -> tuple[list[str], str | None]:
         """Return list of identifiers for accession.
 
         >>> from cool_seq_tool.handlers import SeqRepoAccess
@@ -120,9 +123,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
         else:
             return ga4gh_identifiers, None
 
-    def translate_alias(
-        self, input_str: str
-    ) -> Tuple[List[Optional[str]], Optional[str]]:
+    def translate_alias(self, input_str: str) -> tuple[list[str | None], str | None]:
         """Get aliases for a given input.
 
         :param str input_str: Input to get aliases for
@@ -135,9 +136,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
             logger.warning(msg)
             return [], msg
 
-    def chromosome_to_acs(
-        self, chromosome: str
-    ) -> Tuple[Optional[List[str]], Optional[str]]:
+    def chromosome_to_acs(self, chromosome: str) -> tuple[list[str] | None, str | None]:
         """Get accessions for a chromosome
 
         :param chromosome: Chromosome number. Must be either 1-22, X, or Y
@@ -148,13 +147,12 @@ class SeqRepoAccess(SeqRepoDataProxy):
             tmp_acs, _ = self.translate_identifier(
                 f"{assembly}:chr{chromosome}", target_namespaces="refseq"
             )
-            for ac in tmp_acs:
-                acs.append(ac.split("refseq:")[-1])
+            acs += [ac.split("refseq:")[-1] for ac in tmp_acs]
         if acs:
             return acs, None
         return None, f"{chromosome} is not a valid chromosome"
 
-    def ac_to_chromosome(self, ac: str) -> Tuple[Optional[str], Optional[str]]:
+    def ac_to_chromosome(self, ac: str) -> tuple[str | None, str | None]:
         """Get chromosome for accession.
 
         :param str ac: Accession

cool_seq_tool/mappers/__init__.py

@@ -1,4 +1,5 @@
 """Module for mapping data"""
+
 from .alignment import AlignmentMapper  # noqa: I001
 from .mane_transcript import ManeTranscript
 from .exon_genomic_coords import ExonGenomicCoordsMapper

cool_seq_tool/mappers/alignment.py

@@ -1,7 +1,6 @@
 """Module containing alignment methods for translating to and from different
 reference sequences.
 """
-from typing import Dict, Optional, Tuple
 
 from cool_seq_tool.handlers.seqrepo_access import SeqRepoAccess
 from cool_seq_tool.schemas import AnnotationLayer, Assembly, ResidueMode
@@ -34,7 +33,7 @@ class AlignmentMapper:
         p_start_pos: int,
         p_end_pos: int,
         residue_mode: ResidueMode = ResidueMode.RESIDUE,
-    ) -> Tuple[Optional[Dict], Optional[str]]:
+    ) -> tuple[dict | None, str | None]:
         """Translate protein representation to cDNA representation.
 
         :param p_ac: Protein RefSeq accession
@@ -83,7 +82,7 @@ class AlignmentMapper:
             "residue_mode": ResidueMode.INTER_RESIDUE.value,
         }, None
 
-    async def _get_cds_start(self, c_ac: str) -> Tuple[Optional[int], Optional[str]]:
+    async def _get_cds_start(self, c_ac: str) -> tuple[int | None, str | None]:
         """Get CDS start for a given cDNA RefSeq accession
 
         :param c_ac: cDNA RefSeq accession
@@ -105,10 +104,10 @@ class AlignmentMapper:
         c_ac: str,
         c_start_pos: int,
         c_end_pos: int,
-        cds_start: Optional[int] = None,
+        cds_start: int | None = None,
         residue_mode: ResidueMode = ResidueMode.RESIDUE,
         target_genome_assembly: bool = Assembly.GRCH38,
-    ) -> Tuple[Optional[Dict], Optional[str]]:
+    ) -> tuple[dict | None, str | None]:
         """Translate cDNA representation to genomic representation
 
         :param c_ac: cDNA RefSeq accession
@@ -212,7 +211,7 @@ class AlignmentMapper:
         p_end_pos: int,
         residue_mode: ResidueMode = ResidueMode.INTER_RESIDUE,
         target_genome_assembly: Assembly = Assembly.GRCH38,
-    ) -> Tuple[Optional[Dict], Optional[str]]:
+    ) -> tuple[dict | None, str | None]:
         """Translate protein representation to genomic representation, by way of
         intermediary conversion into cDNA coordinates.
 

cool_seq_tool/mappers/exon_genomic_coords.py

@@ -1,6 +1,7 @@
 """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.mane_transcript import CdnaRepresentation, ManeTranscript
@@ -50,15 +51,15 @@ 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
@@ -86,10 +87,10 @@ class ExonGenomicCoordsMapper:
     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 +100,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)
 
@@ -223,17 +227,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,13 +247,15 @@ 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)
 
@@ -267,7 +272,7 @@ 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
@@ -358,8 +363,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 +384,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 +420,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
@@ -469,11 +474,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:
@@ -592,7 +597,7 @@ 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
@@ -648,8 +653,8 @@ class ExonGenomicCoordsMapper:
 
     @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 +692,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 +711,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,
@@ -777,8 +782,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
@@ -861,7 +866,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 +890,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 +922,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 +963,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