cool-seq-tool 0.4.0.dev2__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(
@@ -86,5 +101,8 @@ class CoolSeqTool:
             self.uta_db,
         )
         self.ex_g_coords_mapper = ExonGenomicCoordsMapper(
-            self.uta_db, self.mane_transcript
+            self.seqrepo_access,
+            self.uta_db,
+            self.mane_transcript,
+            self.mane_transcript_mappings,
         )

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.