cool-seq-tool 0.3.0.dev1__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

cool_seq_tool/mappers/mane_transcript.py

@@ -1,53 +1,121 @@
-"""Module for retrieving MANE Transcript from variation on p/c/g coordinate.
+"""Retrieve MANE transcript from a location on p./c./g. coordinates.
+
 Steps:
-1. Map annotation layer to genome
-2. Liftover to preferred genome
-    We want to liftover to GRCh38. We do not support getting MANE transcripts
-    for GRCh36 and earlier assemblies.
-3. Select preferred compatible annotation
-4. Map back to correct annotation layer
+
+#. Map annotation layer to genome
+#. Liftover to preferred genome (GRCh38). GRCh36 and earlier assemblies are not supported
+   for fetching MANE transcripts.
+#. Select preferred compatible annotation (see :ref:`transcript compatibility <transcript_compatibility>`)
+#. Map back to correct annotation layer
+
+In addition to a mapper utility class, this module also defines several vocabulary
+constraints and data models for coordinate representation.
 """
 import logging
 import math
+from enum import StrEnum
 from typing import Dict, List, Optional, Set, Tuple, Union
 
 import polars as pl
+from pydantic import BaseModel
 
 from cool_seq_tool.handlers.seqrepo_access import SeqRepoAccess
 from cool_seq_tool.schemas import (
     AnnotationLayer,
     Assembly,
     ResidueMode,
+    Strand,
     TranscriptPriority,
 )
 from cool_seq_tool.sources import (
-    MANETranscriptMappings,
+    ManeTranscriptMappings,
     TranscriptMappings,
-    UTADatabase,
+    UtaDatabase,
 )
 from cool_seq_tool.utils import get_inter_residue_pos
 
 logger = logging.getLogger(__name__)
 
 
-class MANETranscript:
+class EndAnnotationLayer(StrEnum):
+    """Define constraints for end annotation layer. This is used for determining the
+    end annotation layer when getting the longest compatible remaining representation
+    """
+
+    PROTEIN = AnnotationLayer.PROTEIN
+    CDNA = AnnotationLayer.CDNA
+    PROTEIN_AND_CDNA = "p_and_c"
+
+
+class DataRepresentation(BaseModel):
+    """Define object model for final output representation"""
+
+    gene: Optional[str] = None
+    refseq: str
+    ensembl: Optional[str] = None
+    pos: Tuple[int, int]
+    strand: Strand
+    status: TranscriptPriority
+
+
+class CdnaRepresentation(DataRepresentation):
+    """Define object model for coding DNA representation"""
+
+    coding_start_site: int
+    coding_end_site: int
+    alt_ac: Optional[str] = None
+
+
+class GenomicRepresentation(BaseModel):
+    """Define object model for genomic representation"""
+
+    refseq: str
+    pos: Tuple[int, int]
+    status: TranscriptPriority
+    alt_ac: str
+
+
+class ProteinAndCdnaRepresentation(BaseModel):
+    """Define object model for protein and cDNA representation"""
+
+    protein: DataRepresentation
+    cdna: CdnaRepresentation
+
+
+class ManeTranscript:
     """Class for retrieving MANE transcripts."""
 
     def __init__(
         self,
         seqrepo_access: SeqRepoAccess,
         transcript_mappings: TranscriptMappings,
-        mane_transcript_mappings: MANETranscriptMappings,
-        uta_db: UTADatabase,
+        mane_transcript_mappings: ManeTranscriptMappings,
+        uta_db: UtaDatabase,
     ) -> None:
-        """Initialize the MANETranscript class.
+        """Initialize the ManeTranscript class.
+
+        A handful of resources are required for initialization, so when defaults are
+        enough, it's easiest to let the core CoolSeqTool class handle it for you:
+
+        >>> from cool_seq_tool.app import CoolSeqTool
+        >>> mane_mapper = CoolSeqTool().mane_transcript
+
+        Note that most methods are defined as Python coroutines, so they must be called
+        with ``await`` or run from an ``async`` event loop:
+
+        >>> import asyncio
+        >>> result = asyncio.run(mane_mapper.g_to_grch38("NC_000001.11", 100, 200))
+        >>> result['ac']
+        'NC_000001.11'
+
+        See the :ref:`Usage section <async_note>` for more information.
 
         :param seqrepo_access: Access to seqrepo queries
         :param transcript_mappings: Access to transcript accession mappings and
             conversions
         :param mane_transcript_mappings: Access to MANE Transcript accession mapping
             data
-        :param uta_db: UTADatabase instance to give access to query UTA database
+        :param uta_db: UtaDatabase instance to give access to query UTA database
         """
         self.seqrepo_access = seqrepo_access
         self.transcript_mappings = transcript_mappings
@@ -56,10 +124,9 @@ class MANETranscript:
 
     @staticmethod
     def _get_reading_frame(pos: int) -> int:
-        """Return reading frame number.
-        Only used on c. coordinate
+        """Return reading frame number. Only used on c. coordinate.
 
-        :param int pos: cDNA position
+        :param pos: cDNA position
         :return: Reading frame
         """
         pos_mod_3 = pos % 3
@@ -71,26 +138,25 @@ class MANETranscript:
     def _p_to_c_pos(start: int, end: int) -> Tuple[int, int]:
         """Return cDNA position given a protein position.
 
-        :param int start: Start protein position
-        :param int end: End protein position
+        :param start: Start protein position. Inter-residue coordinates
+        :param end: End protein position. Inter-residue coordinates
         :return: cDNA position start, cDNA position end
         """
-        start_pos = start * 3 - 1
+        start_pos = start * 3
         if end != start:
-            end_pos = end * 3 - 1
+            end_pos = end * 3
         else:
             end_pos = start_pos
-
-        return start_pos - 1, end_pos + 1
+        return start_pos, end_pos - 1
 
     async def _p_to_c(
         self, ac: str, start_pos: int, end_pos: int
     ) -> Optional[Tuple[str, Tuple[int, int]]]:
         """Convert protein (p.) annotation to cDNA (c.) annotation.
 
-        :param str ac: Protein accession
-        :param int start_pos: Protein start position
-        :param int end_pos: Protein end position
+        :param ac: Protein accession
+        :param start_pos: Protein start position. Inter-residue coordinates
+        :param end_pos: Protein end position. Inter-residue coordinates
         :return: [cDNA transcript accession, [cDNA pos start, cDNA pos end]]
         """
         # TODO: Check version mappings 1 to 1 relationship
@@ -116,8 +182,8 @@ class MANETranscript:
     async def _c_to_g(self, ac: str, pos: Tuple[int, int]) -> Optional[Dict]:
         """Get g. annotation from c. annotation.
 
-        :param str ac: cDNA accession
-        :param Tuple[int, int] pos: [cDNA pos start, cDNA pos end]
+        :param ac: cDNA accession
+        :param pos: [cDNA pos start, cDNA pos end]
         :return: Gene, Transcript accession and position change,
             Altered transcript accession and position change, Strand
         """
@@ -127,7 +193,9 @@ class MANETranscript:
             if not self.transcript_mappings.ensembl_transcript_version_to_gene_symbol.get(
                 ac
             ):
-                if not self.seqrepo_access.get_reference_sequence(ac, 1)[0]:
+                if not self.seqrepo_access.get_reference_sequence(ac, start=1, end=1)[
+                    0
+                ]:
                     logger.warning(f"Ensembl transcript not found: {ac}")
                     return None
 
@@ -160,12 +228,11 @@ class MANETranscript:
     ) -> Optional[Dict]:
         """Get and validate genomic_tx_data
 
-        :param str tx_ac: Accession on c. coordinate
-        :param Tuple[int, int] pos: (start pos, end pos)
-        :param Union[AnnotationLayer.CDNA, AnnotationLayer.GENOMIC] annotation_layer:
-            Annotation layer for `ac` and `pos`
-        :param Optional[int] coding_start_site: Coding start site
-        :param Optional[str] alt_ac: Accession on g. coordinate
+        :param tx_ac: Accession on c. coordinate
+        :param pos: (start pos, end pos)
+        :param annotation_layer: Annotation layer for ``ac`` and ``pos``
+        :param coding_start_site: Coding start site
+        :param alt_ac: Accession on g. coordinate
         :return: genomic_tx_data if found and validated, else None
         """
         genomic_tx_data = await self.uta_db.get_genomic_tx_data(
@@ -199,27 +266,25 @@ class MANETranscript:
 
     @staticmethod
     def _get_c_data(
-        gene: str,
         cds_start_end: Tuple[int, int],
         c_pos_change: Tuple[int, int],
-        strand: str,
+        strand: Strand,
         status: TranscriptPriority,
         refseq_c_ac: str,
+        gene: Optional[str] = None,
         ensembl_c_ac: Optional[str] = None,
         alt_ac: Optional[str] = None,
-    ) -> Dict:
+    ) -> CdnaRepresentation:
         """Return transcript data on c. coordinate.
 
-        :param str gene: Gene symbol
-        :param Tuple[int, int] cds_start_end: Coding start and end site
-            for transcript
-        :param Tuple[int, int] c_pos_change: Start and end positions
-            for change on c. coordinate
-        :param str strand: Strand
-        :param TranscriptPriority status: Status of transcript
-        :param str refseq_c_ac: Refseq transcript
-        :param Optional[str] ensembl_c_ac: Ensembl transcript
-        :param Optional[str] alt_ac: Genomic accession
+        :param gene: Gene symbol
+        :param cds_start_end: Coding start and end site for transcript
+        :param c_pos_change: Start and end positions for change on c. coordinate
+        :param strand: Strand
+        :param status: Status of transcript
+        :param refseq_c_ac: Refseq transcript
+        :param ensembl_c_ac: Ensembl transcript
+        :param alt_ac: Genomic accession
         :return: Transcript data on c. coord
         """
         cds_start = cds_start_end[0]
@@ -229,10 +294,10 @@ class MANETranscript:
 
         if lt_cds_start or gt_cds_end:
             logger.info(
-                f"{refseq_c_ac} with position"
-                f" {c_pos_change} is not within CDS start/end"
+                f"{refseq_c_ac} with position {c_pos_change} is not within CDS start/end"
             )
-        return dict(
+
+        return CdnaRepresentation(
             gene=gene,
             refseq=refseq_c_ac,
             ensembl=ensembl_c_ac,
@@ -244,27 +309,37 @@ class MANETranscript:
             alt_ac=alt_ac,
         )
 
-    @staticmethod
-    def _get_mane_p(mane_data: Dict, mane_c_pos_range: Tuple[int, int]) -> Dict:
-        """Translate MANE Transcript c. annotation to p. annotation
+    def _c_to_p_pos(self, c_pos: Tuple[int, int]) -> Tuple[int, int]:
+        """Get protein position from cdna position
 
-        :param Dict mane_data: MANE Transcript data
-        :param Tuple[int, int] mane_c_pos_range: Position change range
-            on MANE Transcript c. coordinate
-        :return: MANE transcripts accessions and position change on
-            p. coordinate
+        :param c_pos: cdna position. inter-residue coordinates
+        :return: protein position. inter-residue coordinates
         """
-        start = mane_c_pos_range[0] / 3
-        end = mane_c_pos_range[1] / 3
-        start = math.floor(start) if start == end else math.ceil(start)
-        end = math.floor(end)
+        end = math.ceil(c_pos[1] / 3)
+        if c_pos[1] - c_pos[0] == 1:
+            start = end - 1
+        else:
+            start = math.ceil((c_pos[0] + 1) / 3) - 1
+        return start, end
+
+    def _get_mane_p(
+        self, mane_data: Dict, mane_c_pos_range: Tuple[int, int]
+    ) -> DataRepresentation:
+        """Translate MANE Transcript c. annotation to p. annotation
 
-        return dict(
+        :param mane_data: MANE Transcript data
+        :param mane_c_pos_range: Position change range on MANE Transcript c. coordinate
+            using inter-residue coordinates
+        :return: Protein representation
+        """
+        return DataRepresentation(
             gene=mane_data["symbol"],
             refseq=mane_data["RefSeq_prot"],
             ensembl=mane_data["Ensembl_prot"],
-            pos=(start, end),
-            strand=mane_data["chr_strand"],
+            pos=self._c_to_p_pos(mane_c_pos_range),
+            strand=Strand.NEGATIVE
+            if mane_data["chr_strand"] == "-"
+            else Strand.POSITIVE,
             status=TranscriptPriority(
                 "_".join(mane_data["MANE_status"].split()).lower()
             ),
@@ -278,17 +353,17 @@ class MANETranscript:
         ensembl_c_ac: Optional[str] = None,
         alt_ac: Optional[str] = None,
         found_result: bool = False,
-    ) -> Optional[Dict]:
+    ) -> Optional[CdnaRepresentation]:
         """Get transcript c. annotation data from g. annotation.
 
-        :param Dict g: Genomic data
-        :param str refseq_c_ac: Refseq transcript accession
-        :param TranscriptPriority status: Status of transcript
-        :param Optional[str] ensembl_c_ac: Ensembl transcript accession
-        :param Optional[str] alt_ac: Genomic accession
-        :param bool found_result: `True` if found result, so do not need to query
+        :param g: Genomic data
+        :param refseq_c_ac: Refseq transcript accession
+        :param status: Status of transcript
+        :param ensembl_c_ac: Ensembl transcript accession
+        :param alt_ac: Genomic accession
+        :param found_result: ``True`` if found result, so do not need to query
             tx_exon_aln_v table. This is because the user did not need to liftover.
-            `False` if need to get result from tx_exon_aln_v table.
+            ``False`` if need to get result from tx_exon_aln_v table.
         :return: Transcript data
         """
         if found_result:
@@ -321,7 +396,7 @@ class MANETranscript:
         g_pos = g["alt_pos_change_range"]  # start/end genomic change
         g_pos_change = g_pos[0] - tx_g_pos[0], tx_g_pos[1] - g_pos[1]
 
-        if g["strand"] == "-":
+        if g["strand"] == Strand.NEGATIVE:
             g_pos_change = (tx_g_pos[1] - g_pos[0], g_pos[1] - tx_g_pos[0])
 
         c_pos_change = (
@@ -344,29 +419,27 @@ class MANETranscript:
         )
 
     def _validate_reading_frames(
-        self, ac: str, start_pos: int, end_pos: int, transcript_data: Dict
+        self, ac: str, start_pos: int, end_pos: int, transcript_data: CdnaRepresentation
     ) -> bool:
         """Return whether reading frames are the same after translation.
 
-        :param str ac: Query accession
-        :param int start_pos: Original start cDNA position change
-        :param int end_pos: Original end cDNA position change
-        :param Dict transcript_data: Ensembl and RefSeq transcripts with
-            corresponding position change
-        :return: `True` if reading frames are the same after translation.
-            `False` otherwise
+        :param ac: Query accession
+        :param start_pos: Original start cDNA position change
+        :param end_pos: Original end cDNA position change
+        :param transcript_data: Ensembl and RefSeq transcripts with corresponding
+            position change
+        :return: ``True`` if reading frames are the same after translation.
+            ``False`` otherwise
         """
         for pos, pos_index in [(start_pos, 0), (end_pos, 1)]:
             if pos is not None:
                 og_rf = self._get_reading_frame(pos)
-                new_rf = self._get_reading_frame(transcript_data["pos"][pos_index])
+                new_rf = self._get_reading_frame(transcript_data.pos[pos_index])
 
                 if og_rf != new_rf:
                     logger.warning(
-                        f"{ac} original reading frame ({og_rf}) "
-                        f"does not match new "
-                        f"{transcript_data['ensembl']}, "
-                        f"{transcript_data['refseq']} reading "
+                        f"{ac} original reading frame ({og_rf}) does not match new "
+                        f"{transcript_data.ensembl}, {transcript_data.refseq} reading "
                         f"frame ({new_rf})"
                     )
                     return False
@@ -382,7 +455,9 @@ class MANETranscript:
         coding_start_site: int,
         start_pos: int,
         end_pos: int,
-        mane_transcript: Dict,
+        mane_transcript: Union[
+            DataRepresentation, CdnaRepresentation, GenomicRepresentation
+        ],
         expected_ref: str,
         anno: AnnotationLayer,
         residue_mode: ResidueMode,
@@ -397,29 +472,29 @@ class MANETranscript:
             position change
         :param expected_ref: Reference at position given during input
         :param anno: Annotation layer we are starting from
-        :param residue_mode: Residue mode for `start_pos` and `end_pos`
-        :return: `True` if reference check passes. `False` otherwise.
+        :param residue_mode: Residue mode for ``start_pos`` and ``end_pos``
+        :return: ``True`` if reference check passes. ``False`` otherwise.
         """
         if anno == AnnotationLayer.CDNA:
             start_pos += coding_start_site
             end_pos += coding_start_site
 
-        ref, warnings = self.seqrepo_access.get_reference_sequence(
-            ac, start_pos, end=end_pos, residue_mode=residue_mode
+        ref, _ = self.seqrepo_access.get_reference_sequence(
+            ac, start=start_pos, end=end_pos, residue_mode=residue_mode
         )
         if ref is None:
             return False
 
         if mane_transcript:
-            mane_start_pos = mane_transcript["pos"][0]
-            mane_end_pos = mane_transcript["pos"][1]
+            mane_start_pos = mane_transcript.pos[0]
+            mane_end_pos = mane_transcript.pos[1]
             if anno == AnnotationLayer.CDNA:
-                mane_cds = mane_transcript["coding_start_site"]
+                mane_cds = mane_transcript.coding_start_site
                 mane_start_pos += mane_cds
                 mane_end_pos += mane_cds
-            mane_ref, warnings = self.seqrepo_access.get_reference_sequence(
-                mane_transcript["refseq"],
-                mane_start_pos,
+            mane_ref, _ = self.seqrepo_access.get_reference_sequence(
+                mane_transcript.refseq,
+                start=mane_start_pos,
                 end=mane_end_pos if mane_start_pos != mane_end_pos else None,
                 residue_mode=residue_mode,
             )
@@ -429,12 +504,12 @@ 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']}"
+                    f" on MANE accession, {mane_transcript.refseq}"
                 )
 
         if expected_ref != ref:
             logger.warning(
-                f"Expected ref, {expected_ref}, but got {ref} " f"on accession, {ac}"
+                f"Expected ref, {expected_ref}, but got {ref} on accession, {ac}"
             )
             return False
 
@@ -445,18 +520,16 @@ class MANETranscript:
     ) -> bool:
         """Validate that positions actually exist on accession
 
-        :param str ac: Accession
-        :param Tuple[int, int] pos: Start position change, End position change
-        :param int coding_start_site: coding start site for accession
-        :return: `True` if positions exist on accession. `False` otherwise
+        :param ac: Accession
+        :param pos: Start position change, End position change
+        :param coding_start_site: coding start site for accession
+        :return: ``True`` if positions exist on accession. ``False`` otherwise
         """
         start_pos = pos[0] + coding_start_site
         end_pos = pos[1] + coding_start_site
         if self.seqrepo_access.get_reference_sequence(
-            ac, start_pos, end_pos, residue_mode=ResidueMode.INTER_RESIDUE
-        )[
-            0
-        ]:  # noqa E501
+            ac, start=start_pos, end=end_pos, residue_mode=ResidueMode.INTER_RESIDUE
+        )[0]:
             return True
         else:
             return False
@@ -517,36 +590,83 @@ class MANETranscript:
         residue_mode: ResidueMode = ResidueMode.RESIDUE,
         mane_transcripts: Optional[Set] = None,
         alt_ac: Optional[str] = None,
-        end_annotation_layer: Optional[
-            Union[AnnotationLayer.PROTEIN, AnnotationLayer.CDNA]
-        ] = None,
-    ) -> Optional[Dict]:
-        """Get longest compatible transcript from a gene.
-        Try GRCh38 first, then GRCh37.
-        Transcript is compatible if it passes validation checks.
+        end_annotation_layer: Optional[EndAnnotationLayer] = None,
+    ) -> Optional[
+        Union[DataRepresentation, CdnaRepresentation, ProteinAndCdnaRepresentation]
+    ]:
+        """Get longest compatible transcript from a gene. See the documentation for
+        the :ref:`transcript compatibility policy <transcript_compatibility>` for more
+        information.
+
+        >>> import asyncio
+        >>> from cool_seq_tool.app import CoolSeqTool
+        >>> from cool_seq_tool.schemas import AnnotationLayer, ResidueMode
+        >>> mane_mapper = CoolSeqTool().mane_transcript
+        >>> mane_transcripts = {
+        ...     "ENST00000646891.2",
+        ...     "NM_001374258.1",
+        ...     "NM_004333.6",
+        ...     "ENST00000644969.2",
+        ... }
+        >>> result = asyncio.run(mane_mapper.get_longest_compatible_transcript(
+        ...     599,
+        ...     599,
+        ...     gene="BRAF",
+        ...     start_annotation_layer=AnnotationLayer.PROTEIN,
+        ...     residue_mode=ResidueMode.INTER_RESIDUE,
+        ...     mane_transcripts=mane_transcripts,
+        ... ))
+        >>> result.refseq
+        'NP_001365396.1'
+
+        If unable to find a match on GRCh38, this method will then attempt to drop down
+        to GRCh37.
+
+        # TODO example for inputs that demonstrate this?
 
         :param start_pos: Start position change
         :param end_pos: End position change
         :param start_annotation_layer: Starting annotation layer
         :param gene: HGNC gene symbol
         :param ref: Reference at position given during input
-        :param residue_mode: Residue mode for `start_pos` and `end_pos`
+        :param residue_mode: Residue mode for ``start_pos`` and ``end_pos``
         :param mane_transcripts: Attempted mane transcripts that were not compatible
         :param alt_ac: Genomic accession
         :param end_annotation_layer: The end annotation layer. If not provided, will be
-            set to the following
-                `AnnotationLayer.PROTEIN` if
-                    `start_annotation_layer == AnnotationLayer.PROTEIN`
-                `AnnotationLayer.CDNA` otherwise
+            set to ``EndAnnotationLayer.PROTEIN`` if
+            ``start_annotation_layer == AnnotationLayer.PROTEIN``,
+            ``EndAnnotationLayer.CDNA`` otherwise
         :return: Data for longest compatible transcript
         """
-        inter_residue_pos, _ = get_inter_residue_pos(
-            start_pos, residue_mode, end_pos=end_pos
-        )
-        if not inter_residue_pos:
-            return None
+
+        def _get_protein_rep(
+            gene: Optional[str],
+            pro_ac: str,
+            lcr_c_data_pos: Tuple[int, int],
+            strand: Strand,
+            status: TranscriptPriority,
+        ) -> DataRepresentation:
+            """Get longest compatible remaining protein representation
+
+            :param gene: HGNC gene symbol
+            :param pro_ac: Protein accession
+            :param lcr_c_data_pos: Longest compatible remaining position
+            :param strand: Strand
+            :param status: Status for `pro_ac`
+            :return: Protein representation for longest compatible remaining result
+            """
+            return DataRepresentation(
+                gene=gene,
+                refseq=pro_ac if pro_ac.startswith("N") else None,
+                ensembl=pro_ac if pro_ac.startswith("E") else None,
+                pos=self._c_to_p_pos(lcr_c_data_pos),
+                strand=strand,
+                status=status,
+            )
+
+        lcr_result = None
+        start_pos, end_pos = get_inter_residue_pos(start_pos, end_pos, residue_mode)
         residue_mode = ResidueMode.INTER_RESIDUE
-        start_pos, end_pos = inter_residue_pos
 
         is_p_or_c_start_anno = True
         if start_annotation_layer == AnnotationLayer.PROTEIN:
@@ -568,7 +688,7 @@ class MANETranscript:
 
         if df.is_empty():
             logger.warning(f"Unable to get transcripts from gene {gene}")
-            return None
+            return lcr_result
 
         prioritized_tx_acs = self._get_prioritized_transcripts_from_gene(df)
 
@@ -606,7 +726,7 @@ class MANETranscript:
 
             # Get prioritized transcript data for gene
             # grch38 -> c
-            lcr_c_data = await self._g_to_c(
+            lcr_c_data: Optional[CdnaRepresentation] = await self._g_to_c(
                 g=g,
                 refseq_c_ac=tx_ac,
                 status=TranscriptPriority.LONGEST_COMPATIBLE_REMAINING,
@@ -664,74 +784,108 @@ class MANETranscript:
 
             if not end_annotation_layer:
                 if start_annotation_layer == AnnotationLayer.PROTEIN:
-                    end_annotation_layer = AnnotationLayer.PROTEIN
+                    end_annotation_layer = EndAnnotationLayer.PROTEIN
                 else:
-                    end_annotation_layer = AnnotationLayer.CDNA
+                    end_annotation_layer = EndAnnotationLayer.CDNA
+
+            if end_annotation_layer in {
+                EndAnnotationLayer.CDNA,
+                EndAnnotationLayer.PROTEIN,
+            }:
+                if end_annotation_layer == EndAnnotationLayer.CDNA:
+                    lcr_result = lcr_c_data
+                    coding_start_site = lcr_result.coding_start_site
+                else:
+                    lcr_result = _get_protein_rep(
+                        gene,
+                        row["pro_ac"],
+                        lcr_c_data.pos,
+                        g["strand"],
+                        lcr_c_data.status,
+                    )
+                    coding_start_site = 0
 
-            if end_annotation_layer == AnnotationLayer.PROTEIN:
-                pos = (
-                    math.ceil(lcr_c_data["pos"][0] / 3),
-                    math.floor(lcr_c_data["pos"][1] / 3),
-                )
-                ac = row["pro_ac"]
-                coding_start_site = 0
-            else:
-                # cDNA and Genomic annotations will return c. data
-                pos = lcr_c_data["pos"]
-                ac = tx_ac
-                coding_start_site = lcr_c_data["coding_start_site"]
+                ac = lcr_result.refseq or lcr_result.ensembl
+                pos = lcr_result.pos
 
-            if not self._validate_index(ac, pos, coding_start_site):
-                logger.warning(
-                    f"{pos} are not valid positions on {ac}"
-                    f"with coding start site "
-                    f"{coding_start_site}"
+                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}"
+                    )
+                    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,
                 )
-                continue
-
-            return dict(
-                refseq=ac if ac.startswith("N") else None,
-                ensembl=ac if ac.startswith("E") else None,  # TODO: issues 87, 4
-                pos=pos,
-                strand=g["strand"],
-                status=lcr_c_data["status"],
-            )
-        return None
+                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
+        return lcr_result
 
     async def get_mane_transcript(
         self,
         ac: str,
         start_pos: int,
+        end_pos: int,
         start_annotation_layer: AnnotationLayer,
-        end_pos: Optional[int] = None,
         gene: Optional[str] = None,
         ref: Optional[str] = None,
         try_longest_compatible: bool = False,
-        residue_mode: ResidueMode = ResidueMode.RESIDUE,
-    ) -> Optional[Dict]:
-        """Return mane transcript.
+        residue_mode: Union[
+            ResidueMode.RESIDUE, ResidueMode.INTER_RESIDUE
+        ] = ResidueMode.RESIDUE,
+    ) -> Optional[Union[DataRepresentation, CdnaRepresentation]]:
+        """Return MANE transcript.
+
+        >>> from cool_seq_tool.app import CoolSeqTool
+        >>> from cool_seq_tool.schemas import AnnotationLayer, ResidueMode
+        >>> import asyncio
+        >>> mane_mapper = CoolSeqTool().mane_transcript
+        >>> result = asyncio.run(mane_mapper.get_mane_transcript(
+        ...     "NP_004324.2",
+        ...     599,
+        ...     AnnotationLayer.PROTEIN,
+        ...     residue_mode=ResidueMode.INTER_RESIDUE,
+        ... ))
+        >>> result.gene, result.refseq, result.status
+        ('BRAF', 'NP_004324.2', <TranscriptPriority.MANE_SELECT: 'mane_select'>)
 
         :param ac: Accession
         :param start_pos: Start position change
+        :param end_pos: End position change
         :param start_annotation_layer: Starting annotation layer.
-        :param end_pos: End position change. If `None` assumes both  `start_pos` and
-            `end_pos` have same values.
         :param gene: HGNC gene symbol
         :param ref: Reference at position given during input
-        :param try_longest_compatible: `True` if should try longest compatible remaining
-            if mane transcript was not compatible. `False` otherwise.
-        :param ResidueMode residue_mode: Starting residue mode for `start_pos`
-            and `end_pos`. Will always return coordinates in inter-residue
+        :param try_longest_compatible: ``True`` if should try longest compatible remaining
+            if mane transcript was not compatible. ``False`` otherwise.
+        :param ResidueMode residue_mode: Starting residue mode for ``start_pos`` and
+            ``end_pos``. Will always return coordinates in inter-residue
         :return: MANE data or longest transcript compatible data if validation
-            checks are correct. Will return inter-residue coordinates.
-            Else, `None`
+            checks are correct. Will return inter-residue coordinates. Else, ``None``.
         """
-        inter_residue_pos, warning = get_inter_residue_pos(
-            start_pos, residue_mode, end_pos=end_pos
-        )
-        if not inter_residue_pos:
-            return None
-        start_pos, end_pos = inter_residue_pos
+        start_pos, end_pos = get_inter_residue_pos(start_pos, end_pos, residue_mode)
         residue_mode = ResidueMode.INTER_RESIDUE
         if ref:
             ref = ref[: end_pos - start_pos]
@@ -766,7 +920,7 @@ class MANETranscript:
                 mane_transcripts |= set(
                     (current_mane_data["RefSeq_nuc"], current_mane_data["Ensembl_nuc"])
                 )
-                mane = await self._g_to_c(
+                mane: Optional[CdnaRepresentation] = await self._g_to_c(
                     g=g,
                     refseq_c_ac=current_mane_data["RefSeq_nuc"],
                     status=TranscriptPriority(
@@ -777,10 +931,10 @@ class MANETranscript:
                 if not mane:
                     continue
 
-                if not mane["alt_ac"]:
+                if not mane.alt_ac:
                     g_alt_ac = g.get("alt_ac")
                     if g_alt_ac:
-                        mane["alt_ac"] = g_alt_ac
+                        mane.alt_ac = g_alt_ac
 
                 valid_reading_frame = self._validate_reading_frames(
                     c_ac, c_pos[0], c_pos[1], mane
@@ -789,7 +943,9 @@ class MANETranscript:
                     continue
 
                 if start_annotation_layer == AnnotationLayer.PROTEIN:
-                    mane = self._get_mane_p(current_mane_data, mane["pos"])
+                    mane: DataRepresentation = self._get_mane_p(
+                        current_mane_data, mane.pos
+                    )
 
                 if ref:
                     valid_references = self._validate_references(
@@ -842,9 +998,9 @@ class MANETranscript:
     ) -> Optional[Dict]:
         """Return genomic coordinate on GRCh38 when not given gene context.
 
-        :param str ac: Genomic accession
-        :param int start_pos: Genomic start position change
-        :param int end_pos: Genomic end position change
+        :param ac: Genomic accession
+        :param start_pos: Genomic start position
+        :param end_pos: Genomic end position
         :return: NC accession, start and end pos on GRCh38 assembly
         """
         if end_pos is None:
@@ -899,8 +1055,8 @@ class MANETranscript:
     ) -> Tuple[int, int]:
         """Get mane c position change
 
-        :param Dict mane_tx_genomic_data: MANE transcript and genomic data
-        :param int coding_start_site: Coding start site
+        :param mane_tx_genomic_data: MANE transcript and genomic data
+        :param coding_start_site: Coding start site
         :return: cDNA pos start, cDNA pos end
         """
         tx_pos_range = mane_tx_genomic_data["tx_pos_range"]
@@ -922,28 +1078,40 @@ class MANETranscript:
         end_pos: int,
         gene: Optional[str] = None,
         residue_mode: ResidueMode = ResidueMode.RESIDUE,
-    ) -> Optional[Dict]:
+    ) -> Optional[Union[GenomicRepresentation, CdnaRepresentation]]:
         """Return MANE Transcript on the c. coordinate.
-        If gene is provided, g->GRCh38->MANE c.
-            If MANE c. cannot be found, we return the genomic coordinate on
-                GRCh38
-        If gene is not provided, g -> GRCh38
-
-        :param str ac: Transcript accession on g. coordinate
-        :param int start_pos: genomic change start position
-        :param int end_pos: genomic change end position
-        :param str gene: Gene symbol
-        :param ResidueMode residue_mode: Starting residue mode for `start_pos`
-            and `end_pos`. Will always return coordinates in inter-residue
+
+        If an arg for ``gene`` is provided, lifts to GRCh38, then gets MANE cDNA
+        representation.
+
+        >>> import asyncio
+        >>> from cool_seq_tool.app import CoolSeqTool
+        >>> cst = CoolSeqTool()
+        >>> result = asyncio.run(cst.mane_transcript.g_to_mane_c(
+        ...     "NC_000007.13",
+        ...     55259515,
+        ...     None,
+        ...     gene="EGFR"
+        ... ))
+        >>> type(result)
+        <class 'cool_seq_tool.mappers.mane_transcript.CdnaRepresentation'>
+        >>> result.status
+        <TranscriptPriority.MANE_SELECT: 'mane_select'>
+        >>> del cst
+
+        Locating a MANE transcript requires a ``gene`` symbol argument -- if none is
+        given, this method will only lift over to genomic coordinates on GRCh38.
+
+        :param ac: Transcript accession on g. coordinate
+        :param start_pos: genomic start position
+        :param end_pos: genomic end position
+        :param gene: HGNC gene symbol
+        :param residue_mode: Starting residue mode for ``start_pos`` and ``end_pos``.
+            Will always return coordinates in inter-residue.
         :return: MANE Transcripts with cDNA change on c. coordinate if gene
             is provided. Else, GRCh38 data
         """
-        inter_residue_pos, _ = get_inter_residue_pos(
-            start_pos, residue_mode, end_pos=end_pos
-        )
-        if not inter_residue_pos:
-            return None
-        start_pos, end_pos = inter_residue_pos
+        start_pos, end_pos = get_inter_residue_pos(start_pos, end_pos, residue_mode)
         residue_mode = ResidueMode.INTER_RESIDUE
 
         # If gene not provided, return GRCh38
@@ -952,14 +1120,9 @@ class MANETranscript:
             if not grch38:
                 return None
 
-            return dict(
-                gene=None,
+            return GenomicRepresentation(
                 refseq=grch38["ac"],
-                ensembl=None,
-                coding_start_site=None,
-                coding_end_site=None,
                 pos=grch38["pos"],
-                strand=None,
                 status=TranscriptPriority.GRCH38,
                 alt_ac=grch38["ac"],
             )
@@ -981,7 +1144,7 @@ class MANETranscript:
             if grch38:
                 # GRCh38 -> MANE C
                 mane_tx_genomic_data = await self.uta_db.get_mane_c_genomic_data(
-                    mane_c_ac, None, grch38["pos"][0], grch38["pos"][1]
+                    mane_c_ac, grch38["ac"], grch38["pos"][0], grch38["pos"][1]
                 )
 
             if not grch38 or not mane_tx_genomic_data:
@@ -1014,7 +1177,9 @@ class MANETranscript:
                 gene=current_mane_data["symbol"],
                 cds_start_end=(coding_start_site, coding_end_site),
                 c_pos_change=mane_c_pos_change,
-                strand=current_mane_data["chr_strand"],
+                strand=Strand.NEGATIVE
+                if current_mane_data["chr_strand"] == "-"
+                else Strand.POSITIVE,
                 status=TranscriptPriority(
                     "_".join(current_mane_data["MANE_status"].split()).lower()
                 ),
@@ -1023,7 +1188,7 @@ class MANETranscript:
                 alt_ac=grch38["ac"] if grch38 else None,
             )
 
-    async def grch38_to_mane_p(
+    async def grch38_to_mane_c_p(
         self,
         alt_ac: str,
         start_pos: int,
@@ -1033,21 +1198,22 @@ class MANETranscript:
         try_longest_compatible: bool = False,
     ) -> Optional[Dict]:
         """Given GRCh38 genomic representation, return protein representation.
+
         Will try MANE Select and then MANE Plus Clinical. If neither is found and
-        `try_longest_compatible` is set to `true`, will also try to find the longest
+        ``try_longest_compatible`` is set to ``true``, will also try to find the longest
         compatible remaining representation.
 
         :param alt_ac: Genomic RefSeq accession on GRCh38
         :param start_pos: Start position
         :param end_pos: End position
         :param gene: HGNC gene symbol
-        :param residue_mode: Starting residue mode for `start_pos` and `end_pos`. Will
+        :param residue_mode: Starting residue mode for ``start_pos`` and ``end_pos``. Will
             always return coordinates as inter-residue.
-        :param try_longest_compatible: `True` if should try longest compatible remaining
-            if mane transcript(s) not compatible. `False` otherwise.
+        :param try_longest_compatible: ``True`` if should try longest compatible remaining
+            if mane transcript(s) not compatible. ``False`` otherwise.
         :return: If successful, return MANE data or longest compatible remaining (if
-            `try_longest_compatible` set to `True`) protein representation. Will return
-            inter-residue coordinates.
+            ``try_longest_compatible`` set to ``True``) cDNA and protein representation.
+            Will return inter-residue coordinates.
         """
         # Step 1: Get MANE data to map to
         if gene:
@@ -1061,12 +1227,7 @@ class MANETranscript:
             return None
 
         # Step 2: Get inter-residue position
-        inter_residue_pos, _ = get_inter_residue_pos(
-            start_pos, residue_mode, end_pos=end_pos
-        )
-        if not inter_residue_pos:
-            return None
-        start_pos, end_pos = inter_residue_pos
+        start_pos, end_pos = get_inter_residue_pos(start_pos, end_pos, residue_mode)
         residue_mode = ResidueMode.INTER_RESIDUE
 
         # Step 3: Try getting MANE protein representation
@@ -1084,6 +1245,7 @@ class MANETranscript:
 
             # Get MANE C positions
             coding_start_site = mane_tx_genomic_data["coding_start_site"]
+            coding_end_site = mane_tx_genomic_data["coding_end_site"]
             mane_c_pos_change = self.get_mane_c_pos_change(
                 mane_tx_genomic_data, coding_start_site
             )
@@ -1098,8 +1260,21 @@ class MANETranscript:
                 )
                 continue
 
-            # MANE C -> MANE P
-            return self._get_mane_p(current_mane_data, mane_c_pos_change)
+            return ProteinAndCdnaRepresentation(
+                protein=self._get_mane_p(current_mane_data, mane_c_pos_change),
+                cdna=self._get_c_data(
+                    (coding_start_site, coding_end_site),
+                    mane_c_pos_change,
+                    mane_tx_genomic_data["strand"],
+                    TranscriptPriority(
+                        "_".join(current_mane_data["MANE_status"].split()).lower()
+                    ),
+                    mane_c_ac,
+                    alt_ac=alt_ac,
+                    ensembl_c_ac=current_mane_data["Ensembl_nuc"],
+                    gene=current_mane_data["symbol"],
+                ),
+            )
 
         if try_longest_compatible:
             return await self.get_longest_compatible_transcript(
@@ -1108,7 +1283,7 @@ class MANETranscript:
                 AnnotationLayer.GENOMIC,
                 residue_mode=residue_mode,
                 alt_ac=alt_ac,
-                end_annotation_layer=AnnotationLayer.PROTEIN,
+                end_annotation_layer=EndAnnotationLayer.PROTEIN_AND_CDNA,
                 mane_transcripts=mane_transcripts,
             )
         else: