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

cool_seq_tool/__init__.py

@@ -1,14 +1,10 @@
 """The cool_seq_tool package"""
-import logging
-from pathlib import Path
 
-APP_ROOT = Path(__file__).resolve().parents[0]
+from importlib.metadata import PackageNotFoundError, version
 
-logging.basicConfig(
-    filename="cool_seq_tool.log",
-    format="[%(asctime)s] - %(name)s - %(levelname)s : %(message)s",
-)
-logger = logging.getLogger("cool_seq_tool")
-logger.setLevel(logging.DEBUG)
-
-LOG_FN = "cool_seq_tool.log"
+try:
+    __version__ = version("cool_seq_tool")
+except PackageNotFoundError:
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

cool_seq_tool/app.py

@@ -1,29 +1,24 @@
 """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,
+    LiftOver,
     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
 
-logger = logging.getLogger(__name__)
+_logger = logging.getLogger(__name__)
 
 
 class CoolSeqTool:
@@ -35,28 +30,47 @@ class CoolSeqTool:
     * ``self.mane_transcript_mappings``: :py:class:`ManeTranscriptMappings <cool_seq_tool.sources.mane_transcript_mappings.ManeTranscriptMappings>`
     * ``self.uta_db``: :py:class:`UtaDatabase <cool_seq_tool.sources.uta_database.UtaDatabase>`
     * ``self.alignment_mapper``: :py:class:`AlignmentMapper <cool_seq_tool.mappers.alignment.AlignmentMapper>`
+    * ``self.liftover``: :py:class:`LiftOver <cool_seq_tool.mappers.liftover.LiftOver>`
     * ``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 +78,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,23 +87,27 @@ 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(
             self.seqrepo_access, self.transcript_mappings, self.uta_db
         )
+        self.liftover = LiftOver()
         self.mane_transcript = ManeTranscript(
             self.seqrepo_access,
             self.transcript_mappings,
             self.mane_transcript_mappings,
             self.uta_db,
+            self.liftover,
         )
         self.ex_g_coords_mapper = ExonGenomicCoordsMapper(
             self.seqrepo_access,
             self.uta_db,
             self.mane_transcript,
             self.mane_transcript_mappings,
+            self.liftover,
         )

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,17 +1,20 @@
 """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
 
-from cool_seq_tool.schemas import ResidueMode
-from cool_seq_tool.utils import get_inter_residue_pos
+from cool_seq_tool.schemas import Assembly, ResidueMode
+from cool_seq_tool.utils import get_inter_residue_pos, process_chromosome_input
+
+_logger = logging.getLogger(__name__)
+
 
-logger = logging.getLogger(__name__)
+SEQREPO_ROOT_DIR = environ.get("SEQREPO_ROOT_DIR", "/usr/local/share/seqrepo/latest")
 
 
 class SeqRepoAccess(SeqRepoDataProxy):
@@ -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.
 
@@ -63,7 +66,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
             sequence = self.sr.fetch(ac, start=start, end=end)
         except KeyError:
             msg = f"Accession, {ac}, not found in SeqRepo"
-            logger.warning(msg)
+            _logger.warning(msg)
             return "", msg
         except ValueError as e:
             error = str(e)
@@ -77,7 +80,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
                 )
             else:
                 msg = f"{e}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return "", msg
         else:
             # If start is valid, but end is invalid, SeqRepo still returns
@@ -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
@@ -115,14 +118,12 @@ class SeqRepoAccess(SeqRepoDataProxy):
             )
         except KeyError:
             msg = f"SeqRepo unable to get translated identifiers for {ac}"
-            logger.warning(msg)
+            _logger.warning(msg)
             return [], msg
         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
@@ -132,29 +133,30 @@ class SeqRepoAccess(SeqRepoDataProxy):
             return self.sr.translate_alias(input_str), None
         except KeyError:
             msg = f"SeqRepo could not translate alias {input_str}"
-            logger.warning(msg)
+            _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
         :return: Accessions for chromosome (ordered by latest assembly)
         """
         acs = []
-        for assembly in ["GRCh38", "GRCh37"]:
+        for assembly in reversed(Assembly.values()):
             tmp_acs, _ = self.translate_identifier(
-                f"{assembly}:chr{chromosome}", target_namespaces="refseq"
+                f"{assembly}:{process_chromosome_input(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"
+        return (
+            None,
+            f'Unable to find matching accessions for "{chromosome}" in SeqRepo.',
+        )
 
-    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,7 +1,9 @@
 """Module for mapping data"""
+
 from .alignment import AlignmentMapper  # noqa: I001
+from .liftover import LiftOver
 from .mane_transcript import ManeTranscript
 from .exon_genomic_coords import ExonGenomicCoordsMapper
 
 
-__all__ = ["AlignmentMapper", "ManeTranscript", "ExonGenomicCoordsMapper"]
+__all__ = ["AlignmentMapper", "LiftOver", "ManeTranscript", "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.