geney 1.2.69__py2.py3-none-any.whl → 1.3.2__py2.py3-none-any.whl

geney/Gene.py

@@ -0,0 +1,177 @@
+import copy
+from typing import Any, Dict, List, Tuple, Optional, Iterator, Union, TYPE_CHECKING
+from collections import Counter
+from . import unload_pickle, config
+from .Transcript import Transcript
+
+class Gene:
+    """
+    A class representing a Gene, with associated transcripts and metadata.
+
+    Attributes:
+        organism (str): The organism build (e.g. 'hg38').
+        transcripts (dict): A dictionary of transcript annotations keyed by transcript ID.
+        gene_name (str): The name of the gene.
+        gene_id (str): The unique identifier for the gene.
+        chrm (str): The chromosome on which the gene resides.
+    """
+
+    def __init__(self, gene_name, gene_id, rev, chrm, transcripts, organism='hg38'):
+        """
+        Initialize a Gene instance by loading gene information from stored pickled files.
+
+        Args:
+            gene_name (str): Name of the gene (default 'KRAS').
+            variation: Variation information (unused currently).
+            organism (str): Organism reference build (default 'hg38').
+
+        Raises:
+            FileNotFoundError: If no files for the specified gene are found.
+            AssertionError: If required attributes are missing after loading.
+        """
+
+    def __init__(self, gene_name, gene_id, rev, chrm, transcripts, organism='hg38'):
+        self.gene_name = gene_name
+        self.gene_id = gene_id
+        self.rev = rev
+        self.chrm = chrm
+        self.organism = organism
+        self.transcripts = transcripts if transcripts is not None else {}
+
+    def __repr__(self) -> str:
+        """
+        Official string representation of the Gene object.
+        """
+        return f"Gene({self.gene_name})"
+
+    def __str__(self) -> str:
+        """
+        Unofficial, user-friendly string representation of the Gene object.
+        """
+        return f"Gene: {self.gene_name}, ID: {self.gene_id}, Chr: {self.chrm}, Transcripts: {len(self.transcripts)}"
+
+    def __len__(self) -> int:
+        """
+        Returns the number of transcripts associated with this gene.
+
+        Returns:
+            int: The count of transcripts.
+        """
+        return len(self.transcripts)
+
+    def __copy__(self):
+        """
+        Returns a shallow copy of the Gene object.
+        """
+        return copy.copy(self)
+
+    def __deepcopy__(self, memo):
+        """
+        Returns a deep copy of the Gene object.
+        """
+        return copy.deepcopy(self, memo)
+
+    def __iter__(self):
+        """
+        Allow iteration over the gene's transcripts, yielding Transcript objects.
+        """
+        for tid, annotations in self.transcripts.items():
+            yield Transcript(annotations, organism=self.organism)
+
+    @classmethod
+    def from_file(cls, gene_name, organism='hg38'):
+        # Load data from file here
+
+        # Find gene data files in the configured organism MRNA path
+        gene_files = list((config[organism]['MRNA_PATH'] / 'protein_coding').glob(f'*_{gene_name}.pkl'))
+        if not gene_files:
+            raise FileNotFoundError(f"No files available for gene '{gene_name}'.")
+
+        # Load gene data from the first matching file
+        data = unload_pickle(gene_files[0])
+        gene_name = data.get('gene_name')
+        gene_id = data.get('gene_id')
+        rev = data.get('rev')
+        chrm = data.get('chrm')
+        transcripts = data.get('transcripts', {})
+
+        return cls(
+            gene_name=gene_name,
+            gene_id=gene_id,
+            rev=rev,
+            chrm=chrm,
+            transcripts=transcripts,
+            organism=organism
+        )
+
+    def splice_sites(self) -> Tuple['Counter', 'Counter']:
+        """
+        Aggregates splice sites (acceptors and donors) from all transcripts.
+
+        Returns:
+            tuple(Counter, Counter): A tuple of two Counters for acceptors and donors.
+        """
+        from collections import Counter
+        acceptors: List[Any] = []
+        donors: List[Any] = []
+
+        # Collect acceptor and donor sites from each transcript
+        for transcript in self.transcripts.values():
+            acceptors.extend(transcript.get('acceptors', []))
+            donors.extend(transcript.get('donors', []))
+
+        return Counter(acceptors), Counter(donors)
+
+    def transcript(self, tid: Optional[str] = None):
+        """
+        Retrieve a Transcript object by ID, or the primary transcript if no ID is given.
+
+        Args:
+            tid (str, optional): Transcript ID. If None, returns primary transcript.
+
+        Returns:
+            Transcript: The Transcript object with the given ID or the primary transcript.
+
+        Raises:
+            AttributeError: If the requested transcript does not exist.
+        """
+        if tid is None:
+            tid = self.primary_transcript
+
+        if tid not in self.transcripts:
+            raise AttributeError(f"Transcript '{tid}' not found in gene '{self.gene_name}'.")
+
+        return Transcript(self.transcripts[tid], organism=self.organism)
+
+    @property
+    def primary_transcript(self) -> Optional[str]:
+        """
+        Returns the primary transcript ID for this gene.
+        If not explicitly defined, it attempts to select a primary transcript.
+        If none is found, it falls back to the first protein-coding transcript.
+        If still none is found, returns None.
+
+        Returns:
+            str or None: The primary transcript ID or None if not available.
+        """
+        # If already calculated, return it
+        if hasattr(self, '_primary_transcript'):
+            return self._primary_transcript
+
+        # Try to find a primary transcript
+        primary_transcripts = [k for k, v in self.transcripts.items() if v.get('primary_transcript')]
+        if primary_transcripts:
+            self._primary_transcript = primary_transcripts[0]
+            return self._primary_transcript
+
+        # Fallback: find a protein-coding transcript
+        protein_coding = [k for k, v in self.transcripts.items() if v.get('transcript_biotype') == 'protein_coding']
+        if protein_coding:
+            self._primary_transcript = protein_coding[0]
+            return self._primary_transcript
+
+        # No primary or protein-coding transcript found
+        self._primary_transcript = None
+        return None
+
+

geney/SeqMats.py

@@ -0,0 +1,492 @@
+import re
+import numpy as np
+
+ALPHABET = {'N': 'N', 'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', '-': '-'}
+
+class SeqMat:
+    ROW_SEQ = 0
+    ROW_INDS = 1
+    ROW_SUPERINDS = 2
+    ROW_MUTATED = 3
+
+    def __init__(self, seqmat, alphabet=None):
+        self.seqmat = seqmat
+        self.alphabet = alphabet or {'N': 'N', 'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C', '-': '-'}
+
+        self.char_to_value = {c: i for i, c in enumerate(self.alphabet.keys())}
+        self.value_to_char = {i: c for i, c in enumerate(self.alphabet.keys())}
+        self.value_complements = {self.char_to_value[c1]: self.char_to_value[c2] for c1, c2 in self.alphabet.items()}
+
+    def __repr__(self):
+        return f"<SeqMat: {self.seq}>"
+
+    def __str__(self):
+        return self.seq
+
+    def __len__(self):
+        return self.seqmat.shape[1]
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            pos1, pos2 = self._rel_index(key.start), self._rel_index(key.stop)
+            return SeqMat(self.seqmat[:, pos1:pos2+1])
+        else:
+            pos = self._rel_index(key)
+            return SeqMat(self.seqmat[:, pos:pos + 1])
+
+    def __contains__(self, other):
+        """
+        Checks if another SeqMat object is entirely contained within this SeqMat object.
+
+        Args:
+            other (SeqMat): Another SeqMat object to check for containment.
+
+        Returns:
+            bool: True if `other` is contained in `self`, False otherwise.
+        """
+        # Ensure `other` is a SeqMat
+        if not isinstance(other, SeqMat):
+            raise TypeError("Can only check containment with another SeqMat object.")
+
+        # Check if all indices of `other` are in `self`
+        other_indices = other.seqmat[other.ROW_INDS, :]
+        self_indices = self.seqmat[self.ROW_INDS, :]
+        if not np.all(np.isin(other_indices, self_indices)):
+            return False
+
+        return True
+
+    def __eq__(self, other):
+        """
+        Implements the == operator to compare two SeqMat objects.
+
+        Args:
+            other (SeqMat): The other SeqMat object to compare.
+
+        Returns:
+            bool: True if the two SeqMat objects are equal, False otherwise.
+        """
+        # Ensure `other` is a SeqMat object
+        if not isinstance(other, SeqMat):
+            return False
+
+        # Compare the sequence matrix
+        if not np.array_equal(self.seqmat, other.seqmat):
+            return False
+
+        return True
+
+    @classmethod
+    def empty(cls, alphabet=None):
+        """
+        Creates an empty SeqMat object.
+
+        Args:
+            alphabet (dict): Optional alphabet dictionary (default: {'N': 'N', 'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}).
+
+        Returns:
+            SeqMat: An empty SeqMat object.
+        """
+        empty_seqmat = np.zeros((4, 0), dtype=np.int32)  # 4 rows, 0 columns (no data)
+        return cls(empty_seqmat, alphabet=alphabet)
+
+    def __add__(self, other):
+        """
+        Implements the + operator. Joins two SeqMat objects or applies mutations.
+
+        If `other` is outside the range of indices, the sequences are concatenated, provided the indices are
+        monotonically increasing or decreasing. Otherwise, it applies the mutation.
+
+        Args:
+            other (SeqMat): Another SeqMat object to join or mutate.
+
+        Returns:
+            SeqMat: A new SeqMat object with the resulting sequence.
+        """
+        # Ensure `other` is a SeqMat
+        if not isinstance(other, SeqMat):
+            raise TypeError("Can only add another SeqMat object.")
+
+        if other in self:
+            return self.mutate(other)
+
+        else:
+            combined_seqmat = np.hstack((self.seqmat, other.seqmat))
+
+        # Ensure the combined sequence is monotonic
+        if not self._is_monotonic(combined_seqmat[self.ROW_INDS]):
+            raise ValueError("Resulting sequence indices are not monotonic.")
+
+        return SeqMat(combined_seqmat, alphabet=self.alphabet)
+
+    def __iadd__(self, other):
+        """
+        Implements the += operator. Joins two SeqMat objects or applies mutations in place.
+
+        Args:
+            other (SeqMat): Another SeqMat object to join or mutate.
+
+        Returns:
+            SeqMat: The mutated or joined SeqMat object.
+        """
+        # Ensure `other` is a SeqMat
+        if not isinstance(other, SeqMat):
+            raise TypeError("Can only add another SeqMat object.")
+
+        if other in self:
+            self.seqmat = self.mutate(other).seqmat
+            return self
+        else:
+            self.seqmat = np.hstack((self.seqmat, other.seqmat))
+
+        if not self._is_monotonic(self.seqmat[self.ROW_INDS]):
+            raise ValueError("Resulting sequence indices are not monotonic.")
+
+        return self
+
+    # def get_context(self, pos, context=500):
+    #     pos = self._rel_index(pos)
+    #     lower_bound, upper_bound = max(0, pos - context), min(len(self), pos + context + 1)
+    #     return SeqMat(self.seqmat[:, lower_bound:upper_bound])
+
+    def get_context(self, pos, context=500, padding=None):
+        """
+        Returns a SeqMat object representing the region around `pos` with the given context.
+        If padding is provided and the requested context extends beyond the sequence boundaries,
+        the result is padded with the specified nucleotide in the sequence row and -1 in the indices rows.
+
+        Args:
+            pos (int): The position of interest in the original coordinate space.
+            context (int): The number of nucleotides to include on each side of pos (default 500).
+            padding (str or None): The nucleotide to use for padding. If None, no padding is applied and
+                                   the returned region may be shorter than requested.
+
+        Returns:
+            SeqMat: A new SeqMat object containing the context region (padded if requested).
+        """
+        # Resolve the relative index
+        pos = self._rel_index(pos)
+
+        # Calculate desired start and end positions
+        desired_length = 2 * context + 1
+        start = pos - context
+        end = pos + context + 1
+
+        # Actual bounds clipped to the available length
+        actual_start = max(start, 0)
+        actual_end = min(len(self), end)
+
+        # Extract the slice that fits within the sequence
+        slice_seqmat = self.seqmat[:, actual_start:actual_end]
+
+        extracted_length = slice_seqmat.shape[1]
+
+        # If no padding requested, just return the slice
+        if padding is None or extracted_length == desired_length:
+            return SeqMat(slice_seqmat)
+
+        # If padding is requested and we have fewer columns than desired, pad the result
+        if extracted_length < desired_length:
+            # Determine how much we need to pad on each side
+            pad_left = max(-start, 0)  # How many columns needed before actual_start
+            pad_right = max(end - len(self), 0)  # How many columns needed after actual_end
+
+            # Determine numeric code for padding nucleotide
+            # Assuming self.char_to_value is available and 'N' is known if padding isn't recognized
+            N_val = self.char_to_value.get(padding, self.char_to_value['N'])
+
+            # Create a new array with the desired length
+            new_seqmat = np.full((self.seqmat.shape[0], desired_length), -1, dtype=self.seqmat.dtype)
+            # Fill the sequence row with N_val
+            new_seqmat[0, :] = N_val
+
+            # Place the extracted slice into the correct position
+            new_seqmat[:, pad_left:pad_left + extracted_length] = slice_seqmat
+            return SeqMat(new_seqmat)
+
+        # If for some reason extracted_length > desired_length (unlikely), just truncate
+        if extracted_length > desired_length:
+            return SeqMat(slice_seqmat[:, :desired_length])
+
+        # Fallback (should not reach here normally)
+        return SeqMat(slice_seqmat)
+
+
+    def _rel_index(self, pos):
+        if pos in self.indices:
+            return np.where(self.seqmat[self.ROW_INDS, :] == pos)[0][0]
+        else:
+            raise IndexError(f"Position {pos} not found in sequence.")
+
+    def _is_same_strand(self, other):
+        """
+        Checks if two SeqMat objects are on the same strand.
+
+        Args:
+            other (SeqMat): The other SeqMat object to compare.
+
+        Returns:
+            bool: True if both are on the same strand, False otherwise.
+        """
+        self_indices = self.seqmat[self.ROW_INDS, :]
+        other_indices = other.seqmat[self.ROW_INDS, :]
+
+        # Determine monotonicity
+        self_increasing = np.all(np.diff(self_indices) >= 0)
+        self_decreasing = np.all(np.diff(self_indices) <= 0)
+        other_increasing = np.all(np.diff(other_indices) >= 0)
+        other_decreasing = np.all(np.diff(other_indices) <= 0)
+
+        # Both must be either increasing or decreasing
+        return (self_increasing and other_increasing) or (self_decreasing and other_decreasing)
+
+    def reverse_complement(self, inplace=True):
+        """
+        Reverse complement the sequence in place.
+        """
+        seqmat = self.seqmat[:, ::-1].copy()
+        seqmat[self.ROW_SEQ, :] = np.vectorize(self.value_complements.get)(seqmat[self.ROW_SEQ])
+
+        if inplace:
+            self.seqmat = seqmat
+            return self
+
+        return SeqMat(seqmat)
+
+    @classmethod
+    def from_seq(cls, seq_dict, alphabet=None):
+        """
+        Create a SeqMat object from a dictionary containing sequence information.
+        """
+        seq = np.array(list(seq_dict["seq"]))
+        inds = seq_dict.get("indices", np.arange(len(seq), dtype=np.int32))
+        superinds = seq_dict.get("superinds", np.zeros(len(seq), dtype=np.int32))
+        mutmark = np.zeros_like(superinds)
+
+        assert len(seq) == len(inds), f"Sequence length {len(seq)} must match indices length {len(inds)}"
+        if not cls._is_monotonic(inds):
+            raise ValueError(f"Sequence indices must be monotonic, got {inds}")
+
+        # Create character-to-value mapping
+        char_to_value = {c: i for i, c in enumerate(ALPHABET.keys())}
+        seq_values = [char_to_value[nt] for nt in seq]
+
+        # Stack sequence matrix
+        seqmat = np.vstack([seq_values, inds, superinds, mutmark]).astype(np.int32)
+        return cls(seqmat)
+
+    @staticmethod
+    def _is_monotonic(inds):
+        return all(x >= y for x, y in zip(inds, inds[1:])) if inds[0] > inds[-1] else all(
+            x <= y for x, y in zip(inds, inds[1:]))
+
+    @property
+    def seq(self):
+        return self.rawseq.replace('-', '')
+
+    @property
+    def rawseq(self):
+        return ''.join([self.value_to_char[int(ind)] for ind in self.seqmat[self.ROW_SEQ, :]])
+
+    @property
+    def indices(self):
+        return self.seqmat[self.ROW_INDS, self.seqmat[self.ROW_SEQ, :] != 5] + (
+                    self.seqmat[self.ROW_SUPERINDS, self.seqmat[self.ROW_SEQ, :] != 5] / 10)
+
+    def mutate(self, mut, inplace=False):
+        """
+        Apply mutations to the sequence matrix.
+        Args:
+            mut (SeqMat): A SeqMat object containing mutations.
+            return_seqmat (bool): If True, return the mutated seqmat; otherwise, return updated sequence.
+
+        Returns:
+            str or np.ndarray: Mutated sequence or sequence matrix based on `return_seqmat`.
+        """
+        ### NEEDS some work to make sure that mutations can continue being added without issue...
+
+        # Ensure strand compatibility
+        if not self._is_same_strand(mut):
+            raise ValueError("Mutation and sequence are not on the same strand.")
+
+        # something to make sure the mutation is contained as one deletion, insertion, or snp or indel
+        ref_seqmat = self.seqmat.copy()
+        mut_seqmat = mut.seqmat
+
+        # Ensure mutation indices exist in the reference
+        if not np.all(np.isin(mut_seqmat[self.ROW_INDS, :], ref_seqmat[self.ROW_INDS, :])):
+            return self
+
+        # Handle the fact that only part of the mutation is in the sequence and isertable
+        if not np.all(np.isin(mut_seqmat[self.ROW_INDS, :], ref_seqmat[self.ROW_INDS, :])):
+            raise ValueError("Some mutation indices are not found in the reference sequence.")
+
+        # Handle replacements
+        temp = mut_seqmat[:, np.where(mut_seqmat[self.ROW_SUPERINDS, :] == 0)[0]]
+        condition = (
+            np.isin(ref_seqmat[self.ROW_INDS, :],
+                    temp[self.ROW_INDS, :])
+        )
+
+        indices = np.where(condition)[0]
+        ref_seqmat[:, indices] = temp[:, :]
+
+        # Handle insertions
+        insertions = np.where(mut_seqmat[self.ROW_SUPERINDS, :] > 0)[0]
+        if insertions.size > 0:
+            ins_seqmat = mut_seqmat[:, insertions]
+            correction = 1 if self.seqmat[self.ROW_INDS, 0] > self.seqmat[self.ROW_INDS, -1] else 0
+            ins_loc = np.where(ref_seqmat[self.ROW_INDS, :] == ins_seqmat[self.ROW_INDS, 0])[0][0] + 1 - correction
+            ref_seqmat = np.insert(ref_seqmat, ins_loc, ins_seqmat.T, axis=1)
+
+        if inplace:
+            self.seqmat = ref_seqmat
+            return self
+
+        return SeqMat(ref_seqmat)
+
+    def orf_seqmat(self, tis_index):
+        temp = self.seqmat[:, self._rel_index(tis_index):]
+        temp = temp[:, temp[0, :] != 5]
+        temp = SeqMat(temp)  # .drop_indices()
+        raw_seq = temp.seq  # Extract the raw sequence
+        pattern = re.compile(r"(?:[NACGT]{3})*?(TAA|TAG|TGA)")
+        match = pattern.match(raw_seq)
+        if match:
+            stop_index = match.end()
+        else:
+            stop_index = len(raw_seq)
+        end_index = stop_index
+        return SeqMat(temp.seqmat[:, :end_index])
+
+    def translate(self, tis_index):
+        """
+        Translates a nucleotide sequence into an amino acid sequence.
+        Ensures the sequence length is divisible by 3 by trimming excess nucleotides.
+
+        Args:
+            sequence (str): Nucleotide sequence (e.g., ACGT).
+
+        Returns:
+            str: Translated amino acid sequence.
+        """
+        # Codon-to-amino acid mapping table (standard genetic code)
+        codon_table = {
+            'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L',
+            'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L',
+            'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M',
+            'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+            'TCT': 'S', 'TCC': 'S', 'TCA': 'S', 'TCG': 'S',
+            'CCT': 'P', 'CCC': 'P', 'CCA': 'P', 'CCG': 'P',
+            'ACT': 'T', 'ACC': 'T', 'ACA': 'T', 'ACG': 'T',
+            'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A',
+            'TAT': 'Y', 'TAC': 'Y', 'TAA': '*', 'TAG': '*',
+            'CAT': 'H', 'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q',
+            'AAT': 'N', 'AAC': 'N', 'AAA': 'K', 'AAG': 'K',
+            'GAT': 'D', 'GAC': 'D', 'GAA': 'E', 'GAG': 'E',
+            'TGT': 'C', 'TGC': 'C', 'TGA': '*', 'TGG': 'W',
+            'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+            'AGT': 'S', 'AGC': 'S', 'AGA': 'R', 'AGG': 'R',
+            'GGT': 'G', 'GGC': 'G', 'GGA': 'G', 'GGG': 'G'
+        }
+        sequence = self.orf_seqmat(tis_index).seq
+
+        # Ensure sequence is uppercase
+        sequence = sequence.upper()
+
+        # Trim sequence to ensure divisibility by 3
+        trimmed_length = len(sequence) - (len(sequence) % 3)
+        sequence = sequence[:trimmed_length]
+
+        # Translate sequence in chunks of 3
+        amino_acids = [codon_table.get(sequence[i:i+3], 'X') for i in range(0, len(sequence), 3)]
+
+        # Join amino acids into a single string
+        return ''.join(amino_acids)
+
+
+    def to_dict(self):
+        return {'seq': self.rawseq, 'indices': self.indices, 'superinds': self.seqmat[self.ROW_SUPERINDS, :]}
+
+class DnaSeqMat(SeqMat):
+    pass
+
+
+class RnaSeqMat(SeqMat):
+    pass
+
+
+class AASeqMat(SeqMat):
+    pass
+
+
+class MutSeqMat(SeqMat):
+    """
+    A subclass of SeqMat designed specifically for mutation sequences.
+
+    Additional Conditions:
+    1. Mutation indices must be consecutive (increasing or decreasing).
+    2. The superinds row must have a maximum value of 10.
+    """
+
+    def __init__(self, seqmat, alphabet=None):
+        super().__init__(seqmat, alphabet)
+
+        # Validate the mutation-specific conditions
+        self._validate_mutation_indices()
+        self.seqmat[-1, :] = 1
+        self.position = min(self.seqmat[self.ROW_INDS, :])
+
+        # self._validate_superinds()
+
+    def _validate_mutation_indices(self):
+        """
+        Validates that the mutation indices are consecutive (increasing or decreasing).
+        """
+        indices = self.seqmat[self.ROW_INDS, :]
+        if not (np.all(abs(np.diff(indices)) <= 1)):
+            raise ValueError(f"Mutation indices must be consecutive. Got: {indices}")
+
+
+    @classmethod
+    def from_mutid(cls, mid):
+        gene, chrom, i, r, a = mid.split(':')
+        if list(set(a))[0] == '-' and len(a) > 1 and len(list(set(a))) == 1:
+            a = '-'
+
+        if list(set(r))[0] == '-' and len(r) > 1 and len(list(set(r))) == 1:
+            r = '-'
+
+        i = int(i)
+
+        if len(a) == len(r) == 1 and a != '-' and r != '-':
+            temp = {'seq': a, 'indices': [i], 'superinds': [0]}
+
+        elif a == '-' and r != '-':
+            # return Allele('-' *len(r), np.arange(i, i+ len(r), dtype=np.int32), [0] * len(r), rev)
+            temp = {'seq': '-'*len(r), 'indices': np.arange(i, i + len(r), dtype=np.int32), 'superinds':  [0] * len(r)}
+
+        elif r == '-' and a != '-':
+            # print(a, np.full(len(a), int(i)), np.arange(1, len(a)+1),)
+            # return Allele(a, np.full(len(a), int(i)), np.arange(1, len(a)+1), rev)
+            temp = {'seq': a, 'indices': np.full(len(a), int(i)), 'superinds':  np.arange(1, len(a)+1)}
+
+        elif a != '-' and r != '-':
+            ind1 = np.concatenate(
+                [np.arange(i, i + len(r), dtype=np.int32), np.full(len(a), len(r) + i - 1, dtype=np.int32)])
+            ind2 = np.concatenate([np.zeros(len(r), dtype=np.int32), np.arange(1, len(a) + 1, dtype=np.int32)])
+            # return Allele('-' * len(r) + a, ind1, ind2, rev)
+            temp = {'seq': '-' * len(r) + a, 'indices': ind1, 'superinds':  ind2}
+
+        return cls.from_seq(temp)
+
+
+    # def _validate_superinds(self):
+    #     """
+    #     Validates that the superinds row has a maximum value of 10.
+    #     """
+    #     superinds = self.seqmat[self.ROW_SUPERINDS, :]
+    #     if np.max(superinds) > 10:
+    #         raise ValueError(f"Superinds row must have a maximum value of 10. Got: {superinds}")
+
+

geney/Transcript.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+from typing import Any, Optional, Union
+import numpy as np
+import copy
+from Bio.Seq import Seq  # Assuming Biopython is used
+from . import unload_pickle, config
+from .SeqMats import SeqMat, MutSeqMat
+from .Fasta_segment import Fasta_segment
+
+class Transcript:
+    """
+    Represents a transcript with associated genomic information such as exons, introns, and sequences.
+
+    A Transcript object is expected to contain attributes loaded from a dictionary `d` representing
+    annotations and metadata. This includes (at least):
+    - transcript_start
+    - transcript_end
+    - rev (boolean indicating if the transcript is on the reverse strand)
+    - chrm (chromosome)
+    - donors
+    - acceptors
+    - cons_vector
+    - cons_seq
+    - transcript_seq
+    - transcript_biotype
+    - primary_transcript
+    - transcript_id
+    - TIS, TTS (if protein-coding)
+    """
+
+    def __init__(self, d: dict[str, Any], organism: str = 'hg38'):
+        """
+        Initialize a Transcript object from a dictionary of attributes and metadata.
+
+        Args:
+            d (dict): Dictionary containing transcript attributes and data.
+            organism (str): Genome build or organism reference (e.g., 'hg38').
+
+        Raises:
+            AssertionError: If required attributes are missing.
+        """
+        # Convert certain attributes to NumPy arrays for consistent processing
+        array_fields = {'acceptors', 'donors', 'cons_vector'}
+        for k, v in d.items():
+            if k in array_fields and v is not None:
+                v = np.array(v)
+            setattr(self, k, v)
+
+        self.organism: str = organism
+
+        # Required attributes to form a valid transcript object
+        required_attrs = ['transcript_start', 'transcript_end', 'rev', 'chrm']
+        missing = [attr for attr in required_attrs if not hasattr(self, attr)]
+        if missing:
+            raise AssertionError(f"Transcript is missing required attributes: {missing}")
+
+        # Default fallback values for optional attributes
+        if not hasattr(self, 'donors') or self.donors is None:
+            self.donors = np.array([])
+        if not hasattr(self, 'acceptors') or self.acceptors is None:
+            self.acceptors = np.array([])
+        if not hasattr(self, 'cons_available'):
+            self.cons_available = False
+
+        # Determine if transcript is protein-coding
+        self.protein_coding: bool = hasattr(self, 'TIS') and hasattr(self, 'TTS')
+
+        # Calculate transcript boundaries
+        self.transcript_upper = max(self.transcript_start, self.transcript_end)
+        self.transcript_lower = min(self.transcript_start, self.transcript_end)
+
+        # Generate pre-mRNA sequence data
+        self.generate_pre_mrna()
+
+        # If consensus data is available and ends with '*', adjust cons_vector and cons_seq
+        if self.cons_available and hasattr(self, 'cons_seq') and hasattr(self, 'cons_vector'):
+            if self.cons_seq.endswith('*') and len(self.cons_seq) == len(self.cons_vector):
+                self.cons_vector = self.cons_vector[:-1]
+                self.cons_seq = self.cons_seq[:-1]
+
+    def __repr__(self) -> str:
+        """Official string representation."""
+        return f"Transcript({getattr(self, 'transcript_id', 'unknown_id')})"
+
+    def __str__(self) -> str:
+        """
+        Unofficial, user-friendly string representation of the transcript.
+
+        Returns:
+            str: A summary of the transcript including ID, type, and primary status.
+        """
+        transcript_biotype = getattr(self, 'transcript_biotype', 'unknown').replace('_', ' ').title()
+        primary = getattr(self, 'primary_transcript', False)
+        return f"Transcript {getattr(self, 'transcript_id', 'unknown_id')}, " \
+               f"Type: {transcript_biotype}, Primary: {primary}"
+
+    def __len__(self) -> int:
+        """
+        Length of the transcript sequence.
+
+        Returns:
+            int: Length of the transcript sequence.
+        """
+        return len(getattr(self, 'transcript_seq', ''))
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Check equality of two transcripts based on their transcript sequences.
+
+        Args:
+            other (object): Another transcript-like object.
+
+        Returns:
+            bool: True if sequences match, False otherwise.
+        """
+        if not isinstance(other, Transcript):
+            return NotImplemented
+        return self.transcript_seq == other.transcript_seq
+
+    def __contains__(self, subvalue: Any) -> bool:
+        """
+        Check if a given subsequence (e.g., another SeqMat) is contained within the pre_mRNA.
+
+        Args:
+            subvalue (Any): The substring (or sub-SeqMat) to search for in the mature mRNA.
+
+        Returns:
+            bool: True if subvalue's indices are all present in the pre_mRNA, False otherwise.
+
+        Notes:
+            This assumes `subvalue` has a `seqmat` attribute and that `subvalue.seqmat[1, :]` represents indices.
+        """
+        if not hasattr(subvalue, 'seqmat'):
+            return False
+        return np.all(np.isin(subvalue.seqmat[1, :], self.pre_mrna.seqmat[1, :]))
+
+    @property
+    def exons(self) -> list[tuple[int, int]]:
+        """
+        Return a list of exon boundary tuples (acceptor, donor).
+
+        Returns:
+            list of (int, int): List of exon boundaries.
+        """
+        exon_starts = np.concatenate(([self.transcript_start], self.acceptors))
+        exon_ends = np.concatenate((self.donors, [self.transcript_end]))
+        return list(zip(exon_starts, exon_ends))
+
+    @property
+    def exons_pos(self) -> list[tuple[int, int]]:
+        """
+        Return exons with positions adjusted for strand orientation.
+
+        Returns:
+            list of (int, int): Exons adjusted for strand orientation.
+        """
+        exon_positions = self.exons
+        if self.rev:
+            # Reverse order and swap coordinates for reverse strand
+            exon_positions = [(end, start) for start, end in exon_positions[::-1]]
+        return exon_positions
+
+    @property
+    def introns(self) -> list[tuple[int, int]]:
+        """
+        Return a list of intron boundaries derived from donors and acceptors.
+
+        Returns:
+            list of (int, int): Intron boundaries.
+        """
+        valid_donors = self.donors[self.donors != self.transcript_end]
+        valid_acceptors = self.acceptors[self.acceptors != self.transcript_start]
+        return list(zip(valid_donors, valid_acceptors))
+
+    @property
+    def introns_pos(self) -> list[tuple[int, int]]:
+        """
+        Return introns with positions adjusted for strand orientation.
+
+        Returns:
+            list of (int, int): Introns adjusted for strand orientation.
+        """
+        intron_positions = self.introns
+        if self.rev:
+            intron_positions = [(end, start) for start, end in intron_positions[::-1]]
+        return intron_positions
+
+    def _fix_and_check_introns(self) -> Transcript:
+        """
+        Ensure acceptors and donors are sorted and unique, and validate exon/intron structures.
+
+        Raises:
+            ValueError: If there are mismatches or ordering issues in exons/introns.
+
+        Returns:
+            Transcript: The current Transcript object (for chaining).
+        """
+        # Ensure uniqueness and correct ordering based on strand
+        self.acceptors = np.unique(self.acceptors)
+        self.donors = np.unique(self.donors)
+
+        if self.rev:
+            self.acceptors = np.sort(self.acceptors)[::-1]
+            self.donors = np.sort(self.donors)[::-1]
+        else:
+            self.acceptors = np.sort(self.acceptors)
+            self.donors = np.sort(self.donors)
+
+        # Validation checks
+        if self.__exon_intron_matchup_flag():
+            raise ValueError("Unequal number of acceptors and donors.")
+
+        if self.__exon_intron_order_flag():
+            raise ValueError("Exon/intron order out of position.")
+
+        if self.__transcript_boundary_flag():
+            raise ValueError("Transcript boundaries must straddle acceptors and donors.")
+
+        return self
+
+    def __exon_intron_matchup_flag(self) -> bool:
+        """Check if acceptors and donors count match."""
+        return len(self.acceptors) != len(self.donors)
+
+    def __exon_intron_order_flag(self) -> bool:
+        """Check for ordering issues in exon boundaries."""
+        return any(start > end for start, end in self.exons_pos)
+
+    def __transcript_boundary_flag(self) -> bool:
+        """Check if boundaries are within the transcript start/end range."""
+        if not len(self.acceptors) and not len(self.donors):
+            return False
+        min_boundary = np.min(np.concatenate((self.acceptors, self.donors)))
+        max_boundary = np.max(np.concatenate((self.acceptors, self.donors)))
+        return (self.transcript_lower > min_boundary) or (self.transcript_upper < max_boundary)
+
+    @property
+    def exonic_indices(self) -> np.ndarray:
+        """
+        Return the indices covering exons in the transcript.
+
+        Returns:
+            np.ndarray: Array of exon indices.
+        """
+        return np.concatenate([np.arange(a, b + 1) for a, b in self.exons_pos])
+
+    def pull_pre_mrna_pos(self) -> dict[str, Any]:
+        """
+        Retrieve the pre-mRNA sequence and indices using a Fasta_segment object.
+
+        Returns:
+            dict: A dictionary with 'seq' and 'indices' keys.
+        """
+        fasta_obj = Fasta_segment()
+        return fasta_obj.read_segment_endpoints(
+            config[self.organism]['CHROM_SOURCE'] / f'chr{self.chrm}.fasta',
+            self.transcript_lower - 1,
+            self.transcript_upper + 1
+        )
+
+    def generate_pre_mrna(self) -> Transcript:
+        """
+        Generate the pre-mRNA sequence for the transcript and store it as `self.pre_mrna`.
+
+        Returns:
+            Transcript: The current Transcript object (for chaining).
+        """
+        pre_mrna = SeqMat.from_seq(self.pull_pre_mrna_pos())
+        if self.rev:
+            pre_mrna.reverse_complement()
+        self.pre_mrna = pre_mrna
+        return self
+
+    def mutate(self, mutation: MutSeqMat, inplace: bool = False) -> Union[Transcript, SeqMat]:
+        """
+        Apply a mutation to the pre_mRNA sequence of this Transcript.
+
+        If the transcript is on the reverse strand (self.rev is True),
+        the mutation is first reverse-complemented to ensure strand compatibility.
+
+        Args:
+            mutation (SeqMat): The mutation to apply. Must be a SeqMat or a compatible object that supports .mutate().
+            inplace (bool): If True, apply the mutation directly to this Transcript's pre_mRNA
+                            and return 'self'. If False, return a new SeqMat with the mutated sequence.
+
+        Returns:
+            Transcript: If inplace=True, returns the updated Transcript object.
+            SeqMat: If inplace=False, returns a new SeqMat object representing the mutated sequence.
+        """
+        # If transcript is reversed, reverse-complement the mutation first
+        if self.rev:
+            mutation.reverse_complement()
+
+        # Attempt the mutation operation
+        mutated_seqmat = self.pre_mrna.mutate(mutation).seqmat
+        if inplace:
+            # Update this Transcript's pre_mRNA and return the Transcript itself
+            self.pre_mrna = SeqMat(mutated_seqmat)
+            return self
+
+        else:
+            # Create a copy of the current Transcript and update its pre_mrna
+            # Assuming you have a way to clone the Transcript; if not, manually recreate it.
+            new_transcript = copy.deepcopy(self)
+            new_transcript.pre_mrna = SeqMat(mutated_seqmat)
+            return new_transcript
+
+    def generate_mature_mrna(self, inplace: bool = True) -> Union[Transcript, SeqMat]:
+        """
+        Generate the mature mRNA by concatenating exon regions from pre_mRNA.
+
+        Args:
+            inplace (bool): If True, set `self.mature_mrna`, else return a new SeqMat.
+
+        Returns:
+            Transcript or SeqMat: The Transcript object (if inplace=True) or a SeqMat (if inplace=False).
+        """
+        self._fix_and_check_introns()
+
+        mature_mrna = SeqMat.empty()
+        pos_mrna = self.pre_mrna
+
+        for exon_start, exon_end in self.exons:
+            # Add each exon region to the mature_mrna
+            mature_mrna += pos_mrna[exon_start:exon_end]
+
+        if inplace:
+            self.mature_mrna = mature_mrna
+            return self
+        return mature_mrna
+
+    @property
+    def orf(self, tis=None):
+        """
+        Return the ORF (Open Reading Frame) SeqMat object, if TIS and TTS are available.
+
+        Returns:
+            SeqMat or self: The ORF SeqMat if TIS/TTS are set, else self.
+        """
+        if not self.protein_coding:
+            print("Cannot create protein without set TIS and TTS values.")
+            return self
+
+        if tis is None:
+            tis = self.TIS
+        return self.mature_mrna.orf_seqmat(tis)
+
+    def clone(self) -> Transcript:
+        """
+        Returns a deep copy of this Transcript instance.
+
+        Returns:
+            Transcript: A new Transcript object that is a deep copy of the current instance.
+        """
+        return copy.deepcopy(self)
+
+    def generate_protein(self, inplace: bool = True, domains: Optional[np.ndarray] = None) -> Union[
+        Transcript, tuple[str, np.ndarray]]:
+        """
+        Translate the ORF into a protein sequence and optionally filter consensus vector by domains.
+
+        Args:
+            inplace (bool): If True, store protein and cons_vector in self. Otherwise, return them.
+            domains (np.ndarray, optional): Array of domain indices.
+
+        Returns:
+            Transcript or (protein: str, cons_vector: np.ndarray): The Transcript object if inplace=True, else the protein and cons_vector.
+        """
+        if not self.protein_coding:
+            print("No protein can be generated without TIS/TTS.")
+            return self if inplace else ("", np.array([]))
+
+        # Translate the ORF to protein
+        protein = str(Seq(self.orf.seq).translate()).replace('*', '')
+
+        # Use existing cons_vector or default to an array of ones
+        self.cons_vector = self.cons_vector if hasattr(self, 'cons_vector') else np.ones(len(protein))
+        self.protein = protein
+        return self

geney/_mutation_utils.py

@@ -0,0 +1,38 @@
+from .Gene import *
+import numpy as np
+
+class Allele(SeqMat):
+    def __init__(self, alt, pos1, pos2, rev):
+        super().__init__(alt, pos1, pos2)
+        self.position = min(pos1)
+        if rev:
+            self.reverse_complement()
+
+    # def _continuous(self, ind):
+    #     return True
+
+
+
+def get_mutation(mut_id, rev=False):
+
+    _, _, i, r, a = mut_id.split(':')
+    i = int(i)
+
+    if len(a) == len(r) == 1 and a != '-' and r != '-':
+        return Allele(a, [i], [0], rev)
+
+    elif a == '-' and r != '-':
+        return Allele('-' *len(r), np.arange(i, i+ len(r), dtype=np.int32), [0] * len(r), rev)
+
+    elif r == '-' and a != '-':
+        # print(a, np.full(len(a), int(i)), np.arange(1, len(a)+1),)
+        return Allele(a, np.full(len(a), int(i)), np.arange(1, len(a)+1), rev)
+
+    elif a != '-' and r != '-':
+        ind1 = np.concatenate(
+            [np.arange(i, i + len(r), dtype=np.int32), np.full(len(a), len(r) + i - 1, dtype=np.int32)])
+        ind2 = np.concatenate([np.zeros(len(r), dtype=np.int32), np.arange(1, len(a) + 1, dtype=np.int32)])
+        return Allele('-' * len(r) + a, ind1, ind2, rev)
+
+
+

geney/oncosplice.py

@@ -1,19 +1,22 @@
-import copy
-
 from Bio import pairwise2
 import re
-import numpy as np
+import hashlib
+from tqdm import tqdm
 import pandas as pd
-from .splicing_utils import find_transcript_missplicing, develop_aberrant_splicing, Missplicing
-from .seqmat_utils import *
-from .mutation_utils import *
+import numpy as np
+from .SeqMats import SeqMat, MutSeqMat
+from .splicing_utils import find_transcript_missplicing_seqs, develop_aberrant_splicing
 from .tis_utils import find_tis
 
+def short_hash_of_list(numbers, length=5):
+    encoded = repr(numbers).encode('utf-8')
+    full_hash = hashlib.sha256(encoded).hexdigest()
+    return full_hash[:length]
+
 def find_continuous_gaps(sequence):
     """Find continuous gap sequences in an alignment."""
     return [(m.start(), m.end()) for m in re.finditer(r'-+', sequence)]
 
-
 def get_logical_alignment(ref_prot, var_prot):
     """
     Aligns two protein sequences and finds the optimal alignment with the least number of gaps.
@@ -272,43 +275,22 @@ def summarize_missplicing_event(pes, pir, es, ne, ir):
         event.append('NE')
     if len(event) >= 1:
         return ','.join(event)
-    # elif len(event) == 1:
-    #     return event[0]
     else:
         return '-'
 
 
 # Annotating
-def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
+def OncospliceAnnotator(reference_transcript, variant_transcript, mut, ref_attributes=[], var_attributes=[]):
     affected_exon, affected_intron, distance_from_5, distance_from_3 = find_splice_site_proximity(np.floor(mut.indices[0]),
                                                                                                   reference_transcript)
 
     report = {}
-
     report['primary_transcript'] = reference_transcript.primary_transcript
     report['transcript_id'] = reference_transcript.transcript_id
-    # report['mut_id'] = mut.mut_id
-    # report['cons_available'] = int(reference_transcript.cons_available)
-    # report['protein_coding'] = reference_transcript.transcript_biotype
-
-    # report['reference_mrna'] = reference_transcript.transcript_seq
-    # report['reference_cds_start'] = reference_transcript.TIS
-    # report['reference_pre_mrna'] = reference_transcript.pre_mrna
-    # report[
-    #     'reference_orf'] = reference_transcript.orf  # pre_mrna[reference_transcript.transcript_indices.index(reference_transcript.TIS):reference_transcript.transcript_indices.index(reference_transcript.TTS)]
     report['reference_protein'] = reference_transcript.protein
-    # report['reference_protein_length'] = len(reference_transcript.protein)
-
-    # report['variant_mrna'] = variant_transcript.transcript_seq
-    # report['variant_cds_start'] = variant_transcript.TIS
-    # report[
-    #     'variant_pre_mrna'] = variant_transcript.pre_mrna  # pre_mrna[variant_transcript.transcript_indices.index(variant_transcript.TIS):variant_transcript.transcript_indices.index(variant_transcript.TTS)]
-    # report['variant_orf'] = variant_transcript.orf
     report['variant_protein'] = variant_transcript.protein
     report['variant_protein_length'] = len(variant_transcript.protein)
-
     descriptions = define_missplicing_events(reference_transcript, variant_transcript)
-    # print(descriptions)
     report['exon_changes'] = '|'.join([v for v in descriptions if v])
     report['splicing_codes'] = summarize_missplicing_event(*descriptions)
     report['affected_exon'] = affected_exon
@@ -318,60 +300,79 @@ def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
     return report
 
 
-def oncosplice(mut_id, splicing_threshold=0.5, protein_coding=True, cons_required=False, primary_transcript=False, window_length=13, organism='hg38', engine='spliceai', domains=None):
-    gene = Gene(mut_id.split(':')[0], organism=organism)
-    reference_gene_proteins = {tid: transcript.generate_pre_mrna().generate_mature_mrna().generate_protein() for tid, transcript in gene.run_transcripts(protein_coding=True)}
-    mutations = [get_mutation(m, rev=gene.rev) for m in mut_id.split('|')]
+def oncosplice(mut_id, splicing_threshold=0.5, protein_coding=True, cons_required=False, primary_transcript=False,
+               window_length=13, organism='hg38', engine='spliceai', domains=None):
+    gene = Gene.from_file(mut_id.split(':')[0], organism=organism)
+    reference_gene_proteins = {
+        transcript.generate_pre_mrna().generate_mature_mrna().generate_protein().protein: transcript.transcript_id for
+        transcript in gene if transcript.transcript_biotype == 'protein_coding'}
 
+    mutations = [MutSeqMat.from_mutid(m) for m in mut_id.split('|')]
     results = []
-    for tid, transcript in gene.run_transcripts(protein_coding=protein_coding, primary_transcript=primary_transcript):
-        if cons_required and not transcript.cons_available:
+    for reference_transcript in tqdm(gene):
+        if (cons_required and not reference_transcript.cons_available) or (
+                protein_coding and not reference_transcript.transcript_biotype == 'protein_coding'):
             continue
 
-        if all(mutation not in transcript for mutation in mutations):
+        current_mutations = [m for m in mutations if m in reference_transcript]
+        if len(current_mutations) == 0:
             continue
 
-        transcript.generate_pre_mrna()
-        transcript.cons_vector = transform_conservation_vector(transcript.cons_vector, window=window_length)
-        transcript.generate_mature_mrna().generate_protein(inplace=True, domains=domains)
-        ref_protein, cons_vector = transcript.protein, transcript.cons_vector
-        reference_transcript = copy.deepcopy(transcript)
+        center = np.mean([m.indices[0] for m in current_mutations]) // 1
 
-        assert len(ref_protein) == len(cons_vector), f"Protein ({len(ref_protein)}) and conservation vector ({len(cons_vector)}) must be same length. {ref_protein}, \n>{cons_vector}\n>{transcript.cons_seq}"
+        mutated_transcript = reference_transcript.clone()
+        for mutation in current_mutations:
+            mutated_transcript.mutate(mutation, inplace=True)
 
-        missplicing = Missplicing(find_transcript_missplicing(transcript, mutations, engine=engine, threshold=splicing_threshold), threshold=splicing_threshold)
-        for mutation in mutations:
-            transcript.pre_mrna += mutation
+        reference_transcript.generate_mature_mrna().generate_protein()
+        reference_transcript.cons_vector = transform_conservation_vector(reference_transcript.cons_vector,
+                                                                         window=window_length)
 
-        for i, new_boundaries in enumerate(develop_aberrant_splicing(transcript, missplicing.aberrant_splicing)):
-            transcript.acceptors = new_boundaries['acceptors']
-            transcript.donors = new_boundaries['donors']
-            transcript.generate_mature_mrna().generate_protein()
+        assert len(reference_transcript.protein) == len(
+            reference_transcript.cons_vector), f"Protein ({len(reference_transcript.protein)}) and conservation vector ({len(reference_transcript.cons_vector)}) must be same length."
 
-            alignment = get_logical_alignment(reference_transcript.protein, transcript.protein)
+        missplicing = find_transcript_missplicing_seqs(
+            reference_transcript.pre_mrna.get_context(center, context=7500, padding='N'),
+            mutated_transcript.pre_mrna.get_context(center, context=7500, padding='N'), reference_transcript.donors,
+            reference_transcript.acceptors, threshold=splicing_threshold, engine=engine)
+        alternative_splicing_paths = develop_aberrant_splicing(reference_transcript, missplicing.aberrant_splicing)
+
+        for i, new_boundaries in enumerate(alternative_splicing_paths):
+            mutated_transcript.acceptors = new_boundaries['acceptors']
+            mutated_transcript.donors = new_boundaries['donors']
+            mutated_transcript.generate_mature_mrna().generate_protein()
+
+            alignment = get_logical_alignment(reference_transcript.protein, mutated_transcript.protein)
             deleted, inserted = find_indels_with_mismatches_as_deletions(alignment.seqA, alignment.seqB)
-            modified_positions = find_modified_positions(len(ref_protein), deleted, inserted)
-            temp_cons = np.convolve(cons_vector * modified_positions, np.ones(window_length)) / window_length
+            modified_positions = find_modified_positions(len(reference_transcript.protein), deleted, inserted)
+            temp_cons = np.convolve(reference_transcript.cons_vector * modified_positions,
+                                    np.ones(window_length)) / window_length
             affected_cons_scores = max(temp_cons)
             percentile = (
-                        sorted(cons_vector).index(next(x for x in sorted(cons_vector) if x >= affected_cons_scores)) / len(
-                    cons_vector))
+                    sorted(reference_transcript.cons_vector).index(
+                        next(x for x in sorted(reference_transcript.cons_vector) if x >= affected_cons_scores)) / len(
+                reference_transcript.cons_vector))
 
-            report = OncospliceAnnotator(reference_transcript, transcript, mutation)
+            report = OncospliceAnnotator(reference_transcript, mutated_transcript, current_mutations[0])
             report['mut_id'] = mut_id
+            report['engine'] = engine
             report['oncosplice_score'] = affected_cons_scores
             report['percentile'] = percentile
-            report['isoform_id'] = i
+            report['isoform_id'] = short_hash_of_list(mutated_transcript.exons)
             report['isoform_prevalence'] = new_boundaries['path_weight']
             report['full_missplicing'] = missplicing.aberrant_splicing
             report['missplicing'] = max(missplicing)
-            report['reference_resemblance'] = reference_gene_proteins.get(transcript.protein, None)
+            report['reference_resemblance'] = reference_gene_proteins.get(mutated_transcript.protein, None)
             results.append(report)
 
     if len(results) == 0:
         return None
 
-    return pd.DataFrame(results)
+    return pd.DataFrame(results)[
+        ['mut_id', 'transcript_id', 'isoform_id', 'primary_transcript', 'missplicing', 'full_missplicing',
+         'exon_changes', 'splicing_codes', 'affected_exon', 'affected_intron', 'mutation_distance_from_5',
+         'mutation_distance_from_3', 'engine', 'reference_resemblance', 'oncosplice_score', 'percentile',
+         'isoform_prevalence', 'reference_protein', 'variant_protein']]
 
 
 import asyncio

geney/splicing_utils.py

@@ -146,7 +146,7 @@ def find_ss_changes(ref_dct, mut_dct, known_splice_sites, threshold=0.5):
 
 
 def find_transcript_missplicing_mutid(mut_id):
-    from geney.seqmat_utils import Gene
+    from geney.Gene import Gene
     transcript = Gene(mut_id.split(':')[0]).transcript().generate_mature_mrna()
     out = find_transcript_missplicing(transcript, [get_mutation(mut_id, rev=transcript.rev)], context=5000, window=2500, threshold=0.5, engine='spliceai', just_ss=True)
     best_delta = 0

{geney-1.2.69.dist-info → geney-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geney
-Version: 1.2.69
+Version: 1.3.2
 Summary: A Python package for gene expression modeling.
 Home-page: https://github.com/nicolaslynn/geney
 Author: Nicolas Lynn
@@ -29,6 +29,8 @@ Requires-Dist: notebook
 Requires-Dist: matplotlib
 Requires-Dist: gffutils
 Requires-Dist: pyfastx
+Requires-Dist: tensorflow
+Requires-Dist: keras
 
 UNKNOWN
 

{geney-1.2.69.dist-info → geney-1.3.2.dist-info}/RECORD

@@ -1,17 +1,21 @@
 geney/Fasta_segment.py,sha256=0zCdzPUbDeM9Rz642woH5Q94pwI46O0fE3H8w0XWebc,11255
+geney/Gene.py,sha256=JGWtfA6-d1W3I9YRASwaF8vaZ6CCuY0KEawQNdloIqY,6259
+geney/SeqMats.py,sha256=jkXmXAs0OpnFeyCfiJcKKpHHSi9JpKgiOIwsu63e1CQ,18557
+geney/Transcript.py,sha256=eRZXVVxDVBbv0l385bnAOBFRBSzBwppXcbBq8KXkwlo,14443
 geney/__init__.py,sha256=eBdDl42N6UhcYeZDjOnv199Z88fI5_8Y6xW8447OKXM,755
+geney/_mutation_utils.py,sha256=dHssUsnii_mf-wuRoMmF13UlD7k3ml_VwQMItTYnXpU,1132
 geney/config_setup.py,sha256=klm_k7Ca_703DpeGBcGoDqz1XwHQhNXENPKjj_xfSQw,608
 geney/data_setup.py,sha256=2RHmuvcGUQbEglXQEZr0C2QPDTQYRZOEm0EcmyfQJgU,12229
 geney/graphic_utils.py,sha256=oMsBpB9YeEn96gGpKh4MmtagJffWZbk-xPrIwHvkFhA,11016
 geney/gtex_utils.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
 geney/immune_utils.py,sha256=ZRni5ttrhpYBnmNr0d0ZatIbNPYs4nmQuoUO00SpsS4,5271
 geney/mutation_utils.py,sha256=C_kv2MB_L8LlhX3W2ooXjJ3uDoJ8zX1WeDtZKoBZJkI,1547
-geney/oncosplice.py,sha256=eWgY2Lcj894UBFnIVhbxiVz5oqASHg-Ot1wFbjlJbI8,21857
+geney/oncosplice.py,sha256=FdvuROk2G7wwLoB5lLzYia8Smw9hHZeVs-J2MUoAwlU,22106
 geney/pangolin_utils.py,sha256=i5j5vEMCWOTIa1mRP2377BAhlUFZjHBzTQBips4lA_4,2934
 geney/power_utils.py,sha256=MehZFUdkJ2EFUot709yPEDxSkXmH5XevMebX2HD768A,7330
 geney/seqmat_utils.py,sha256=wzb3PX5it5bpIFQvcxyzlxfhoJTbHHbsjg0rzh05iVs,19753
 geney/spliceai_utils.py,sha256=PFIhTK8Ihrj-cv5tgRN0UFPYEmC4uxtqXSP9bBLnZRM,3077
-geney/splicing_utils.py,sha256=0DFnBJaEqPQ8_0VPFzsXu_ZxaTlw56e0bcAGVLyIH1Q,19223
+geney/splicing_utils.py,sha256=4xYXy_dIbqdbVfxsEj_OCuM-MsQ24gi4fIv0vQjAYcQ,19215
 geney/survival_utils.py,sha256=KnAzEviMuXh6SnVXId9PgsFLSbgkduTvYoIthxN7FPA,6886
 geney/tcga_utils.py,sha256=D_BNHm-D_K408dlcJm3hzH2c6QNFjQsKvUcOPiQRk7g,17612
 geney/tis_utils.py,sha256=2makfGfVlDFVIbxzXE85AY9jmAjcNmxyIAxjvkRA5LY,7396
@@ -20,7 +24,7 @@ geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 geney/translation_initiation/tis_utils.py,sha256=AF3siFjuQH-Rs44EV-80zHdbxRMvN4woLFSHroWIETc,4448
 geney/translation_initiation/resources/kozak_pssm.json,sha256=pcd0Olziutq-6H3mFWDCD9cujQ_AlZO-iiOvBl82hqE,1165
 geney/translation_initiation/resources/tis_regressor_model.joblib,sha256=IXb4DUDhJ5rBDKcqMk9zE3ECTZZcdj7Jixz3KpoZ7OA,2592025
-geney-1.2.69.dist-info/METADATA,sha256=6Qzw_HkVkPN0J_dFfc8lYuw5rJsIsjKlT_uvybAmltM,948
-geney-1.2.69.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
-geney-1.2.69.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.2.69.dist-info/RECORD,,
+geney-1.3.2.dist-info/METADATA,sha256=aGPdV-x5PcONjV5ylUg8rYhW0eo4Fm2HDOE8dzldpcg,994
+geney-1.3.2.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+geney-1.3.2.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.3.2.dist-info/RECORD,,