cool-seq-tool 0.4.0.dev1__py3-none-any.whl → 0.4.0.dev2__py3-none-any.whl

cool_seq_tool/data/__init__.py

@@ -1,2 +1,2 @@
 """Module for data"""
-from .data_downloads import DataDownload  # noqa: F401
+from .data_downloads import DataDownload

cool_seq_tool/data/data_downloads.py

@@ -4,7 +4,6 @@ import gzip
 import logging
 import shutil
 from ftplib import FTP
-from os import remove
 from pathlib import Path
 
 from dateutil import parser
@@ -38,18 +37,20 @@ class DataDownload:
             files = ftp.nlst()
             mane_summary_file = [f for f in files if f.endswith(".summary.txt.gz")]
             if not mane_summary_file:
-                raise Exception("Unable to download MANE summary data")
+                msg = "Unable to download MANE summary data"
+                raise Exception(msg)
             mane_summary_file = mane_summary_file[0]
             self._mane_summary_path = self._data_dir / mane_summary_file[:-3]
             mane_data_path = self._data_dir / mane_summary_file
             if not self._mane_summary_path.exists():
                 logger.info("Downloading MANE summary file from NCBI.")
-                with open(mane_data_path, "wb") as fp:
+                with mane_data_path.open("wb") as fp:
                     ftp.retrbinary(f"RETR {mane_summary_file}", fp.write)
-                with gzip.open(mane_data_path, "rb") as f_in:
-                    with open(self._mane_summary_path, "wb") as f_out:
-                        shutil.copyfileobj(f_in, f_out)
-                remove(mane_data_path)
+                with gzip.open(
+                    mane_data_path, "rb"
+                ) as f_in, self._mane_summary_path.open("wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+                mane_data_path.unlink()
                 logger.info("MANE summary file download complete.")
         return self._mane_summary_path
 
@@ -66,18 +67,23 @@ class DataDownload:
             ftp_file_path = f"{ftp_dir_path}{lrg_refseqgene_file}"
             timestamp = ftp.voidcmd(f"MDTM {ftp_file_path}")[4:].strip()
             date = str(parser.parse(timestamp)).split()[0]
-            version = datetime.datetime.strptime(date, "%Y-%m-%d").strftime("%Y%m%d")
+            version = (
+                datetime.datetime.strptime(date, "%Y-%m-%d")
+                .astimezone(tz=datetime.timezone.utc)
+                .strftime("%Y%m%d")
+            )
             fn_versioned = f"{lrg_refseqgene_file}_{version}"
             lrg_refseqgene_path = self._data_dir / lrg_refseqgene_file
             self._lrg_refseqgene_path = self._data_dir / fn_versioned
             if not self._lrg_refseqgene_path.exists():
                 logger.info("Downloading LRG RefSeq data from NCBI.")
                 ftp.cwd(ftp_dir_path)
-                with open(lrg_refseqgene_path, "wb") as fp:
+                with lrg_refseqgene_path.open("wb") as fp:
                     ftp.retrbinary(f"RETR {lrg_refseqgene_file}", fp.write)
-                with open(lrg_refseqgene_path, "rb") as f_in:
-                    with open(self._lrg_refseqgene_path, "wb") as f_out:
-                        shutil.copyfileobj(f_in, f_out)
-                remove(lrg_refseqgene_path)
+                with lrg_refseqgene_path.open(
+                    "rb"
+                ) as f_in, self._lrg_refseqgene_path.open("wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+                lrg_refseqgene_path.unlink()
                 logger.info("LRG RefSeq data download complete.")
         return self._lrg_refseqgene_path

cool_seq_tool/handlers/seqrepo_access.py

@@ -152,8 +152,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
                 acs.append(ac.split("refseq:")[-1])
         if acs:
             return acs, None
-        else:
-            return None, f"{chromosome} is not a valid chromosome"
+        return None, f"{chromosome} is not a valid chromosome"
 
     def ac_to_chromosome(self, ac: str) -> Tuple[Optional[str], Optional[str]]:
         """Get chromosome for accession.
@@ -172,8 +171,7 @@ class SeqRepoAccess(SeqRepoDataProxy):
         )[0]
         if aliases is None:
             return None, f"Unable to get chromosome for {ac}"
-        else:
-            return aliases, None
+        return aliases, None
 
     def get_fasta_file(self, sequence_id: str, outfile_path: Path) -> None:
         """Retrieve FASTA file containing sequence for requested sequence ID.

cool_seq_tool/mappers/exon_genomic_coords.py

@@ -112,8 +112,7 @@ class ExonGenomicCoordsMapper:
         # Ensure valid inputs
         if not transcript:
             return self._return_warnings(resp, "Must provide `transcript`")
-        else:
-            transcript = transcript.strip()
+        transcript = transcript.strip()
 
         exon_start_exists, exon_end_exists = False, False
         if exon_start is not None:
@@ -130,12 +129,11 @@ class ExonGenomicCoordsMapper:
             return self._return_warnings(
                 resp, "Must provide either `exon_start` or `exon_end`"
             )
-        elif exon_start_exists and exon_end_exists:
-            if exon_start > exon_end:
-                return self._return_warnings(
-                    resp,
-                    f"Start exon {exon_start} is greater than end exon {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}",
+            )
 
         # Get all exons and associated start/end coordinates for transcript
         tx_exons, warning = await self.uta_db.get_tx_exons(transcript)
@@ -266,7 +264,7 @@ class ExonGenomicCoordsMapper:
         if start is None and end is None:
             return self._return_warnings(resp, "Must provide either `start` or `end`")
 
-        params = {key: None for key in GenomicData.model_fields.keys()}
+        params = {key: None for key in GenomicData.model_fields}
         if gene is not None:
             gene = gene.upper().strip()
 
@@ -312,13 +310,12 @@ class ExonGenomicCoordsMapper:
 
         for field in ["transcript", "gene", "chr", "strand"]:
             if start_data:
-                if end_data:
-                    if start_data[field] != end_data[field]:
-                        msg = (
-                            f"Start `{field}`, {start_data[field]}, does "
-                            f"not match End `{field}`, {end_data[field]}"
-                        )
-                        return self._return_warnings(resp, msg)
+                if end_data and (start_data[field] != end_data[field]):
+                    msg = (
+                        f"Start `{field}`, {start_data[field]}, does "
+                        f"not match End `{field}`, {end_data[field]}"
+                    )
+                    return self._return_warnings(resp, msg)
                 params[field] = start_data[field]
             else:
                 params[field] = end_data[field]
@@ -440,7 +437,10 @@ class ExonGenomicCoordsMapper:
                     else:
                         error = "Strand does not match"
                     logger.warning(
-                        f"{error}: {alt_ac_data['start'][i]} != {alt_ac_data['end'][i]}"
+                        "%s: %s != %s",
+                        error,
+                        alt_ac_data["start"][i],
+                        alt_ac_data["end"][i],
                     )
                     return None, error
         return tuple(alt_ac_data_values), None
@@ -482,7 +482,7 @@ class ExonGenomicCoordsMapper:
                 resp, "Must provide either `gene` or `transcript`"
             )
 
-        params = {key: None for key in TranscriptExonData.model_fields.keys()}
+        params = {key: None for key in TranscriptExonData.model_fields}
 
         if alt_ac:
             # Check if valid accession is given
@@ -550,7 +550,7 @@ class ExonGenomicCoordsMapper:
         len_alt_acs = len(alt_acs)
         if len_alt_acs > 1:
             return None, f"Found more than one accessions: {alt_acs}"
-        elif len_alt_acs == 0:
+        if len_alt_acs == 0:
             return None, "No genomic accessions found"
         alt_ac = next(iter(alt_acs))
 
@@ -565,13 +565,12 @@ class ExonGenomicCoordsMapper:
         elif len_genes == 0:
             return None, "No genes found"
 
-        if input_gene is not None:
-            if output_gene != input_gene.upper():
-                return (
-                    None,
-                    f"Input gene, {input_gene}, does not match "
-                    f"expected output gene, {output_gene}",
-                )
+        if input_gene is not None and output_gene != input_gene.upper():
+            return (
+                None,
+                f"Input gene, {input_gene}, does not match "
+                f"expected output gene, {output_gene}",
+            )
 
         gene = output_gene if output_gene else input_gene
         return (gene, alt_ac), None

cool_seq_tool/mappers/mane_transcript.py

@@ -13,7 +13,7 @@ constraints and data models for coordinate representation.
 """
 import logging
 import math
-from enum import StrEnum
+from enum import Enum
 from typing import Dict, List, Optional, Set, Tuple, Union
 
 import polars as pl
@@ -37,7 +37,7 @@ from cool_seq_tool.utils import get_inter_residue_pos
 logger = logging.getLogger(__name__)
 
 
-class EndAnnotationLayer(StrEnum):
+class EndAnnotationLayer(str, Enum):
     """Define constraints for end annotation layer. This is used for determining the
     end annotation layer when getting the longest compatible remaining representation
     """
@@ -143,10 +143,7 @@ class ManeTranscript:
         :return: cDNA position start, cDNA position end
         """
         start_pos = start * 3
-        if end != start:
-            end_pos = end * 3
-        else:
-            end_pos = start_pos
+        end_pos = end * 3 if end != start else start_pos
         return start_pos, end_pos - 1
 
     async def _p_to_c(
@@ -170,10 +167,10 @@ class ManeTranscript:
                 elif ac.startswith("ENSP"):
                     ac = self.transcript_mappings.ensp_to_enst[ac]
                 else:
-                    logger.warning(f"Unable to find accession: {ac}")
+                    logger.warning("Unable to find accession: %s", ac)
                     return None
             except KeyError:
-                logger.warning(f"{ac} not found in transcript_mappings")
+                logger.warning("%s not found in transcript_mappings", ac)
                 return None
 
         pos = self._p_to_c_pos(start_pos, end_pos)
@@ -190,14 +187,16 @@ class ManeTranscript:
         # UTA does not store ENST versions
         # So we want to make sure version is valid
         if ac.startswith("ENST"):
-            if not self.transcript_mappings.ensembl_transcript_version_to_gene_symbol.get(
-                ac
-            ):
-                if not self.seqrepo_access.get_reference_sequence(ac, start=1, end=1)[
+            if (
+                not self.transcript_mappings.ensembl_transcript_version_to_gene_symbol.get(
+                    ac
+                )
+                and not self.seqrepo_access.get_reference_sequence(ac, start=1, end=1)[
                     0
-                ]:
-                    logger.warning(f"Ensembl transcript not found: {ac}")
-                    return None
+                ]
+            ):
+                logger.warning("Ensembl transcript not found: %s", ac)
+                return None
 
             temp_ac = ac.split(".")[0]
         else:
@@ -206,15 +205,14 @@ class ManeTranscript:
         # c. coordinate does not contain cds start, so we need to add it
         cds_start_end = await self.uta_db.get_cds_start_end(temp_ac)
         if not cds_start_end:
-            logger.warning(f"Accession {temp_ac} not found in UTA")
+            logger.warning("Accession %s not found in UTA", temp_ac)
             return None
         coding_start_site = cds_start_end[0]
         pos = pos[0] + coding_start_site, pos[1] + coding_start_site
 
-        genomic_tx_data = await self._get_and_validate_genomic_tx_data(
+        return await self._get_and_validate_genomic_tx_data(
             ac, pos, AnnotationLayer.CDNA, coding_start_site=coding_start_site
         )
-        return genomic_tx_data
 
     async def _get_and_validate_genomic_tx_data(
         self,
@@ -240,8 +238,10 @@ class ManeTranscript:
         )
         if not genomic_tx_data:
             logger.warning(
-                f"Unable to find genomic_tx_data for {alt_ac} at position"
-                f" {pos} on annotation layer {annotation_layer}"
+                "Unable to find genomic_tx_data for %s at position %s on annotation layer %s",
+                alt_ac,
+                pos,
+                annotation_layer,
             )
             return None
         genomic_tx_data["coding_start_site"] = coding_start_site
@@ -256,9 +256,9 @@ class ManeTranscript:
             # Validation check: Exon structure
             if og_alt_exon_id != liftover_alt_exon_id:
                 logger.warning(
-                    f"Original alt_exon_id {og_alt_exon_id} "
-                    f"does not match liftover alt_exon_id "
-                    f"{liftover_alt_exon_id}"
+                    "Original alt_exon_id %s does not match liftover alt_exon_id %s",
+                    og_alt_exon_id,
+                    liftover_alt_exon_id,
                 )
                 return None
 
@@ -294,7 +294,9 @@ class ManeTranscript:
 
         if lt_cds_start or gt_cds_end:
             logger.info(
-                f"{refseq_c_ac} with position {c_pos_change} is not within CDS start/end"
+                "%s with position %s is not within CDS start/end",
+                refseq_c_ac,
+                c_pos_change,
             )
 
         return CdnaRepresentation(
@@ -380,13 +382,12 @@ class ManeTranscript:
 
             if not result:
                 logger.warning(
-                    f"Unable to find transcript, {refseq_c_ac}, " f"position change"
+                    "Unable to find transcript, %s, position change", refseq_c_ac
                 )
                 return None
-            else:
-                result = result[-1]
-                tx_g_pos = result[5], result[6]  # alt_start_i, alt_end_i
-                tx_pos_range = result[2], result[3]  # tx_start_i, tx_end_i
+            result = result[-1]
+            tx_g_pos = result[5], result[6]  # alt_start_i, alt_end_i
+            tx_pos_range = result[2], result[3]  # tx_start_i, tx_end_i
 
         cds_start_end = await self.uta_db.get_cds_start_end(refseq_c_ac)
         if not cds_start_end:
@@ -438,14 +439,17 @@ class ManeTranscript:
 
                 if og_rf != new_rf:
                     logger.warning(
-                        f"{ac} original reading frame ({og_rf}) does not match new "
-                        f"{transcript_data.ensembl}, {transcript_data.refseq} reading "
-                        f"frame ({new_rf})"
+                        "%s original reading frame (%s) does not match new %s, %s reading frame (%s)",
+                        ac,
+                        og_rf,
+                        transcript_data.ensembl,
+                        transcript_data.refseq,
+                        new_rf,
                     )
                     return False
             else:
                 if pos_index == 0:
-                    logger.warning(f"{ac} must having start position")
+                    logger.warning("%s must having start position", ac)
                     return False
         return True
 
@@ -503,13 +507,15 @@ class ManeTranscript:
 
             if expected_ref != mane_ref:
                 logger.info(
-                    f"Expected ref, {expected_ref}, but got {mane_ref}"
-                    f" on MANE accession, {mane_transcript.refseq}"
+                    "Expected ref, %s, but got %s on MANE accession, %s",
+                    expected_ref,
+                    mane_ref,
+                    mane_transcript.refseq,
                 )
 
         if expected_ref != ref:
             logger.warning(
-                f"Expected ref, {expected_ref}, but got {ref} on accession, {ac}"
+                "Expected ref, %s, but got %s on accession, %s", expected_ref, ref, ac
             )
             return False
 
@@ -531,8 +537,7 @@ class ManeTranscript:
             ac, start=start_pos, end=end_pos, residue_mode=ResidueMode.INTER_RESIDUE
         )[0]:
             return True
-        else:
-            return False
+        return False
 
     def _get_prioritized_transcripts_from_gene(self, df: pl.DataFrame) -> List:
         """Sort and filter transcripts from gene to get priority list
@@ -687,7 +692,7 @@ class ManeTranscript:
             )
 
         if df.is_empty():
-            logger.warning(f"Unable to get transcripts from gene {gene}")
+            logger.warning("Unable to get transcripts from gene %s", gene)
             return lcr_result
 
         prioritized_tx_acs = self._get_prioritized_transcripts_from_gene(df)
@@ -810,38 +815,42 @@ class ManeTranscript:
 
                 if not self._validate_index(ac, pos, coding_start_site):
                     logger.warning(
-                        f"{pos} are not valid positions on {ac} with coding start site "
-                        f"{coding_start_site}"
+                        "%s are not valid positions on %s with coding start site %s",
+                        pos,
+                        ac,
+                        coding_start_site,
                     )
                     continue
                 return lcr_result
-            else:
-                lcr_result = ProteinAndCdnaRepresentation(
-                    protein=_get_protein_rep(
-                        gene,
-                        row["pro_ac"],
-                        lcr_c_data.pos,
-                        g["strand"],
-                        lcr_c_data.status,
-                    ),
-                    cdna=lcr_c_data,
-                )
-                lcr_result_dict = lcr_result.model_dump()
-
-                valid = True
-                for k in lcr_result_dict.keys():
-                    cds = lcr_result_dict[k].get("coding_start_site", 0)
-                    ac = lcr_result_dict[k]["refseq"] or lcr_result_dict[k]["ensembl"]
-                    pos = lcr_result_dict[k]["pos"]
-                    if not self._validate_index(ac, pos, cds):
-                        valid = False
-                        logger.warning(
-                            f"{pos} are not valid positions on {ac} with coding start site {cds}"
-                        )
-                        break
-
-                if valid:
-                    return lcr_result
+            lcr_result = ProteinAndCdnaRepresentation(
+                protein=_get_protein_rep(
+                    gene,
+                    row["pro_ac"],
+                    lcr_c_data.pos,
+                    g["strand"],
+                    lcr_c_data.status,
+                ),
+                cdna=lcr_c_data,
+            )
+            lcr_result_dict = lcr_result.model_dump()
+
+            valid = True
+            for k in lcr_result_dict:
+                cds = lcr_result_dict[k].get("coding_start_site", 0)
+                ac = lcr_result_dict[k]["refseq"] or lcr_result_dict[k]["ensembl"]
+                pos = lcr_result_dict[k]["pos"]
+                if not self._validate_index(ac, pos, cds):
+                    valid = False
+                    logger.warning(
+                        "%s are not valid positions on %s with coding start site %s",
+                        pos,
+                        ac,
+                        cds,
+                    )
+                    break
+
+            if valid:
+                return lcr_result
         return lcr_result
 
     async def get_mane_transcript(
@@ -917,9 +926,10 @@ class ManeTranscript:
             #        those transcripts meeting criterion
             mane_transcripts = set()
             for current_mane_data in mane_data:
-                mane_transcripts |= set(
-                    (current_mane_data["RefSeq_nuc"], current_mane_data["Ensembl_nuc"])
-                )
+                mane_transcripts |= {
+                    current_mane_data["RefSeq_nuc"],
+                    current_mane_data["Ensembl_nuc"],
+                }
                 mane: Optional[CdnaRepresentation] = await self._g_to_c(
                     g=g,
                     refseq_c_ac=current_mane_data["RefSeq_nuc"],
@@ -974,24 +984,22 @@ class ManeTranscript:
                         residue_mode=residue_mode,
                         mane_transcripts=mane_transcripts,
                     )
-                else:
-                    return await self.get_longest_compatible_transcript(
-                        c_pos[0],
-                        c_pos[1],
-                        AnnotationLayer.CDNA,
-                        ref=ref,
-                        gene=g["gene"],
-                        residue_mode=residue_mode,
-                        mane_transcripts=mane_transcripts,
-                    )
-            else:
-                return None
-        elif start_annotation_layer == AnnotationLayer.GENOMIC:
+                return await self.get_longest_compatible_transcript(
+                    c_pos[0],
+                    c_pos[1],
+                    AnnotationLayer.CDNA,
+                    ref=ref,
+                    gene=g["gene"],
+                    residue_mode=residue_mode,
+                    mane_transcripts=mane_transcripts,
+                )
+            return None
+        if start_annotation_layer == AnnotationLayer.GENOMIC:
             return await self.g_to_mane_c(
                 ac, start_pos, end_pos, gene=gene, residue_mode=residue_mode
             )
-        else:
-            logger.warning(f"Annotation layer not supported: {start_annotation_layer}")
+        logger.warning("Annotation layer not supported: %s", start_annotation_layer)
+        return None
 
     async def g_to_grch38(
         self, ac: str, start_pos: int, end_pos: int
@@ -1011,9 +1019,8 @@ class ManeTranscript:
         if not descr:
             # Already GRCh38 assembly
             if self._validate_index(ac, (start_pos, end_pos), 0):
-                return dict(ac=ac, pos=(start_pos, end_pos))
-            else:
-                return None
+                return {"ac": ac, "pos": (start_pos, end_pos)}
+            return None
         chromosome, assembly = descr
         is_same_pos = start_pos == end_pos
 
@@ -1027,8 +1034,7 @@ class ManeTranscript:
         )
         if liftover_start_i is None:
             return None
-        else:
-            start_pos = liftover_start_i[1]
+        start_pos = liftover_start_i[1]
 
         if not is_same_pos:
             liftover_end_i = self.uta_db.get_liftover(
@@ -1036,8 +1042,7 @@ class ManeTranscript:
             )
             if liftover_end_i is None:
                 return None
-            else:
-                end_pos = liftover_end_i[1]
+            end_pos = liftover_end_i[1]
         else:
             end_pos = start_pos
 
@@ -1045,8 +1050,7 @@ class ManeTranscript:
         if newest_ac:
             ac = newest_ac[0]
             if self._validate_index(ac, (start_pos, end_pos), 0):
-                return dict(ac=ac, pos=(start_pos, end_pos))
-
+                return {"ac": ac, "pos": (start_pos, end_pos)}
         return None
 
     @staticmethod
@@ -1128,7 +1132,7 @@ class ManeTranscript:
             )
 
         if not await self.uta_db.validate_genomic_ac(ac):
-            logger.warning(f"Genomic accession does not exist: {ac}")
+            logger.warning("Genomic accession does not exist: %s", ac)
             return None
 
         mane_data = self.mane_transcript_mappings.get_gene_mane_data(gene)
@@ -1154,8 +1158,7 @@ class ManeTranscript:
                 )
                 if not mane_tx_genomic_data:
                     continue
-                else:
-                    logger.info("Not using most recent assembly")
+                logger.info("Not using most recent assembly")
 
             coding_start_site = mane_tx_genomic_data["coding_start_site"]
             coding_end_site = mane_tx_genomic_data["coding_end_site"]
@@ -1167,9 +1170,10 @@ class ManeTranscript:
                 mane_c_ac, mane_c_pos_change, coding_start_site
             ):
                 logger.warning(
-                    f"{mane_c_pos_change} are not valid positions"
-                    f" on {mane_c_ac}with coding start site "
-                    f"{coding_start_site}"
+                    "%s are not valid positions on %s with coding start site %s",
+                    mane_c_pos_change,
+                    mane_c_ac,
+                    coding_start_site,
                 )
                 continue
 
@@ -1187,6 +1191,7 @@ class ManeTranscript:
                 ensembl_c_ac=current_mane_data["Ensembl_nuc"],
                 alt_ac=grch38["ac"] if grch38 else None,
             )
+        return None
 
     async def grch38_to_mane_c_p(
         self,
@@ -1234,7 +1239,7 @@ class ManeTranscript:
         mane_transcripts = set()  # Used if getting longest compatible remaining
         for current_mane_data in mane_data:
             mane_c_ac = current_mane_data["RefSeq_nuc"]
-            mane_transcripts |= set((mane_c_ac, current_mane_data["Ensembl_nuc"]))
+            mane_transcripts |= {mane_c_ac, current_mane_data["Ensembl_nuc"]}
 
             # GRCh38 -> MANE C
             mane_tx_genomic_data = await self.uta_db.get_mane_c_genomic_data(
@@ -1255,8 +1260,10 @@ class ManeTranscript:
                 mane_c_ac, mane_c_pos_change, coding_start_site
             ):
                 logger.warning(
-                    f"{mane_c_pos_change} are not valid positions on {mane_c_ac} with "
-                    f"coding start site {coding_start_site}"
+                    "%s are not valid positions on %s with coding start site %s",
+                    mane_c_pos_change,
+                    mane_c_ac,
+                    coding_start_site,
                 )
                 continue
 
@@ -1286,5 +1293,4 @@ class ManeTranscript:
                 end_annotation_layer=EndAnnotationLayer.PROTEIN_AND_CDNA,
                 mane_transcripts=mane_transcripts,
             )
-        else:
-            return None
+        return None