geney 1.1.10__py2.py3-none-any.whl → 1.1.12__py2.py3-none-any.whl

geney/immune_utils.py

@@ -0,0 +1,127 @@
+import subprocess
+import logging
+import tempfile
+from geney import config_setup
+import pandas as pd
+
+
+class NetChop(object):
+    """
+    Wrapper around netChop tool. Assumes netChop is in your PATH.
+    """
+    def predict_epitopes(self, sequences, threshold=0.5, min_len=8):
+        """
+        Return netChop predictions for each position in each sequence.
+
+        Parameters
+        -----------
+        sequences : list of string
+            Amino acid sequences to predict cleavage for
+
+        Returns
+        -----------
+        list of list of float
+
+        The i'th list corresponds to the i'th sequence. Each list gives
+        the cleavage probability for each position in the sequence.
+        """
+        with tempfile.NamedTemporaryFile(dir=config_setup['NETCHOP'], suffix=".fsa", mode="w") as input_fd:
+            for (i, sequence) in enumerate(sequences):
+                _ = input_fd.write("> %d\n" % i)
+                _ = input_fd.write(sequence)
+                _ = input_fd.write("\n")
+            input_fd.flush()
+            try:
+                output = subprocess.check_output(["netchop", str(input_fd.name)])
+            except subprocess.CalledProcessError as e:
+                logging.error("Error calling netChop: %s:\n%s" % (e, e.output))
+                raise
+        parsed = self.parse_netchop(output)
+        return parsed
+        #
+        # assert len(parsed) == len(sequences), \
+        #     "Expected %d results but got %d" % (
+        #         len(sequences), len(parsed))
+        # assert [len(x) for x in parsed] == [len(x) for x in sequences]
+        # filtered_proteosomes = []
+        # for scores, seq in list(zip(parsed, sequences)):
+        #     proteosome = self.chop_protein(seq, [s > threshold for s in scores])
+        #     filtered_proteosomes.append([e for e in proteosome if len(e) > min_len])
+        # return filtered_proteosomes
+    @staticmethod
+    def parse_netchop(netchop_output):
+        """
+        Parse netChop stdout.
+        """
+        line_iterator = iter(netchop_output.decode().split("\n"))
+        scores = []
+        for line in line_iterator:
+            if "pos" in line and 'AA' in line and 'score' in line:
+                scores.append([])
+                if "----" not in next(line_iterator):
+                    raise ValueError("Dashes expected")
+                line = next(line_iterator)
+                while '-------' not in line:
+                    score = float(line.split()[3])
+                    scores[-1].append(score)
+                    line = next(line_iterator)
+        return scores
+    def chop_protein(self, seq, pos):
+        # Generate subsequences using list comprehension and slicing
+        start = 0
+        subsequences = [seq[start:(start := i+1)] for i, marker in enumerate(pos) if marker == 1]
+        # Check if the last part needs to be added
+        if start < len(seq):
+            subsequences.append(seq[start:])
+        return subsequences
+    def generate_cut_sequences(self, char_sequence, cut_probabilities):
+        """
+        Generate all possible cut sequences and their abundance values,
+        considering only those sequences where the probabilities of all cut sites
+        between the two ends are zero.
+
+        :param char_sequence: A string representing the sequence of characters.
+        :param cut_probabilities: A list of probabilities for each position in the sequence.
+        :return: A list of tuples, where each tuple contains a cut sequence and its abundance value.
+        """
+        if len(char_sequence) != len(cut_probabilities):
+            raise ValueError("Character sequence and cut probabilities must have the same length.")
+        cut_sequences = []
+        # Generate all possible cuts
+        for i in range(len(char_sequence)):
+            for j in range(i + 1, len(char_sequence) + 1):
+                # Check if probabilities of all cut sites between i and j are zero
+                if sum(cut_probabilities[i + 1:j - 1]) < 1:
+                    cut_sequence = char_sequence[i:j]
+                    abundance_value = cut_probabilities[i] * cut_probabilities[j - 1] - sum(
+                        cut_probabilities[i + 1:j - 1])
+                    cut_sequences.append({'seq': cut_sequence, 'abundance': abundance_value})
+        return pd.DataFrame(cut_sequences)
+
+
+import re
+import StringIO
+import pandas as pd
+
+def run_mhc(sequences):
+    with tempfile.NamedTemporaryFile(dir='/tamir2/nicolaslynn/temp', suffix=".pep", mode="w") as input_fd:
+        for (i, sequence) in enumerate(sequences):
+            _ = input_fd.write(sequence)
+            _ = input_fd.write("\n")
+        input_fd.flush()
+        try:
+            out = subprocess.check_output(
+                ["netMHCpan", "-p", "-BA", str(input_fd.name)])
+        except subprocess.CalledProcessError as e:
+            logging.error("Error calling netChop: %s:\n%s" % (e, e.output))
+            raise
+    out = out.decode('utf-8')
+    out = out.split(
+        '\n---------------------------------------------------------------------------------------------------------------------------\n')
+    out = out[1] + '\n' + out[2]
+    out = re.sub(r'[ ]+', ',', out)
+    out = out.replace('\n,', '\n')
+    return pd.read_csv(StringIO(out)).drop(columns=['Unnamed: 0'])
+
+
+

geney/oncosplice.py

@@ -261,6 +261,1034 @@ class Gene:
             yield Transcript(self.transcripts[tid], variations=self.variations)
 
 
+class Transcript:
+    def __init__(self, d=None, variations=None):
+        self.transcript_id = None
+        self.transcript_start = None                # transcription
+        self.transcript_end = None                  # transcription
+        self.transcript_upper = None
+        self.transcript_lower = None
+        self.transcript_biotype = None              # metadata
+        self.acceptors, self.donors = [], []        # splicing
+        self.TIS, self.TTS = None, None             # translation
+        self.transcript_seq, self.transcript_indices = '', []  # sequence data
+        self.rev = None                             # sequence data
+        self.chrm = ''                              # sequence data
+        self.pre_mrna = ''                          # sequence data
+        self.orf = ''                               # sequence data
+        self.protein = ''                           # sequence data
+        self.log = ''                               # sequence data
+        self.primary_transcript = None              # sequence data
+        self.cons_available = False                 # metadata
+        self.cons_seq = ''
+        self.cons_vector = ''
+        self.variations = None
+        if variations:
+            self.variations = Variations(variations)
+
+        if d:
+            self.load_from_dict(d)
+
+
+        if self.transcript_biotype == 'protein_coding' and variations is None:
+            self.generate_protein()
+
+        else:
+            self.generate_pre_mrna()
+
+        if '*' in self.cons_seq:
+            self.cons_seq = self.cons_seq.replace('*', '')
+            self.cons_vector = np.array(self.cons_vector[:-1])
+
+        if self.cons_seq == self.protein and len(self.cons_vector) == len(self.cons_seq):
+            self.cons_available = True
+
+        if self.cons_available == False:
+            self.cons_vector = np.ones(len(self.protein))
+
+
+    def __repr__(self):
+        return 'Transcript(transcript_id={tid})'.format(tid=self.transcript_id)
+
+    def __len__(self):
+        return len(self.transcript_seq)
+
+    def __str__(self):
+        return 'Transcript {tid}, Transcript Type: ' \
+               '{protein_coding}, Primary: {primary}'.format(
+            tid=self.transcript_id, protein_coding=self.transcript_biotype.replace('_', ' ').title(),
+            primary=self.primary_transcript)
+
+    def __eq__(self, other):
+        return self.transcript_seq == other.transcript_seq
+
+    def __contains__(self, subvalue):
+        '''
+        :param subvalue: the substring to search for in the mature mrna transcript
+        :return: wehether or not the substring is seen in the mature transcript or not
+        '''
+        if isinstance(subvalue, str):
+            return subvalue in self.transcript_seq
+        elif isinstance(subvalue, int):
+            return subvalue in self.transcript_indices
+        elif isinstance(subvalue, Variations):
+            return all([self.transcript_lower <= p <= self.transcript_upper for p in subvalue.positions])
+
+        else:
+            print(
+                "Pass an integer to check against the span of the gene's coordinates or a string to check against the "
+                "pre-mRNA sequence.")
+            return False
+
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        for k, v in self.__dict__.items():
+            setattr(result, k, deepcopy(v, memo))
+        return result
+
+    def load_from_dict(self, data):
+        '''
+        :param data: data is a dictionary containing the needed data to construct the transcript
+        :return: itself
+        '''
+        for k, v in data.items(): # add a line here that ensure the dictionary key is a valid item
+            setattr(self, k, v)
+
+        self.transcript_upper, self.transcript_lower = max(self.transcript_start, self.transcript_end), min(self.transcript_start, self.transcript_end)
+        self.__arrange_boundaries()#.generate_mature_mrna(inplace=True)
+        return self
+
+    @property
+    def exons(self):
+        '''
+        :return: a list of tuples where the first position is the acceptor and the second position is the donor
+        '''
+        return list(zip([self.transcript_start] + self.acceptors, self.donors + [self.transcript_end]))
+
+    @property
+    def exons_pos(self):
+        temp = self.exons
+        if self.rev:
+            temp = [(b, a) for a, b in temp[::-1]]
+        return temp
+
+    @property
+    def introns(self):
+        '''
+        :return:  a list of tuples where each first position is a bondary of the first intron, and the second position is the boundary of the end of the intron
+        '''
+        return list(zip([v for v in self.donors if v != self.transcript_end],
+                        [v for v in self.acceptors if v != self.transcript_start]))
+
+    @property
+    def introns_pos(self):
+        temp = self.introns
+        if self.rev:
+            temp = [(b, a) for a, b in temp[::-1]]
+        return temp
+
+
+    def reset_acceptors(self, acceptors):
+        '''
+        :param acceptors: resetting and then reordering the list of acceptors or donors
+        :return: itself
+        '''
+        self.acceptors = acceptors
+        return self
+
+    def reset_donors(self, donors):
+        '''
+        :param donors: resetting and then reordering the list of acceptors or donors
+        :return: itself
+        '''
+        self.donors = donors
+        return self
+
+    def reset_transcription_start(self, pos):
+        '''
+        :param pos: resetting and then reordering the list of acceptors or donors
+        :return: itself
+        '''
+        self.transcription_start = pos
+        return self
+
+
+    def reset_transcription_end(self, pos):
+        '''
+        :param pos: resetting and then reordering the list of acceptors or donors
+        :return: itself
+        '''
+        self.transcription_end = pos
+        return self
+
+    def organize(self):
+        '''
+        In the case that transcript boundaries or exon boundaires are changed, this needs to be run to ensure the bluepritns are ordered the the mRNA is reobtained.
+        :return:
+        '''
+        self.__arrange_boundaries().generate_mature_mrna(inplace=True)
+        self.transcript_upper, self.transcript_lower = max(self.transcript_start, self.transcript_end), min(self.transcript_start, self.transcript_end)
+
+        # if self.__exon_coverage_flag():
+        #     raise ValueError(f"Length of exon coverage does not match transcript length.")
+        if self.__exon_intron_matchup_flag():
+            raise ValueError(f"Unequal number of acceptors and donors.")
+        if self.__exon_intron_order_flag():
+            raise ValueError(f"Exons / intron order out of position.")
+        if self.__transcript_boundary_flag():
+            raise ValueError(f"Transcript boundaries must straddle acceptors and donors.")
+        return self
+
+    def __arrange_boundaries(self):
+        # self.acceptors.append(self.transcript_start)
+        # self.donors.append(self.transcript_end)
+        self.acceptors = list(set(self.acceptors))
+        self.donors = list(set(self.donors))
+        self.acceptors.sort(reverse=self.rev)
+        self.donors.sort(reverse=self.rev)
+        return self
+
+
+    def __exon_coverage_flag(self):
+        if sum([abs(a - b) + 1 for a, b in self.exons]) != len(self):
+            return True
+        else:
+            return False
+
+    def __exon_intron_matchup_flag(self):
+        if len(self.acceptors) != len(self.donors):
+            return True
+        else:
+            return False
+    def __exon_intron_order_flag(self):
+        for b in self.exons_pos:
+            if b[0] > b[1]:
+                return True
+        else:
+            return False
+    def __transcript_boundary_flag(self):
+        if len(self.acceptors) == 0 and len(self.donors) == 0:
+            return False
+
+        if self.transcript_lower > min(self.acceptors + self.donors) or self.transcript_upper < max(self.acceptors + self.donors):
+            return True
+        else:
+            return False
+
+
+    @property
+    def exonic_indices(self):
+        return [lst for lsts in [list(range(a, b + 1)) for a, b in self.exons_pos] for lst in lsts]
+
+
+    # Related to transcript seq generation
+    def pull_pre_mrna_pos(self):
+        fasta_obj = Fasta_segment()
+        return fasta_obj.read_segment_endpoints(config_setup['CHROM_SOURCE'] / f'chr{self.chrm}.fasta',
+                                                self.transcript_lower,
+                                                self.transcript_upper)
+
+    def generate_pre_mrna_pos(self):
+        # *_pos functions do not set values into the object.
+        seq, indices = self.pull_pre_mrna_pos()
+        if self.variations:
+            for mutation in self.variations.variants:
+                seq, indices = generate_mut_variant(seq, indices, mut=mutation)
+        return seq, indices
+
+    def generate_pre_mrna(self, inplace=True):
+        pre_mrna, pre_indices = self.__pos2sense(*self.generate_pre_mrna_pos())
+        self.pre_mrna = pre_mrna
+        self.pre_indices = pre_indices
+        if inplace:
+            return self
+        return pre_mrna, pre_indices
+
+    def __pos2sense(self, mrna, indices):
+        if self.rev:
+            mrna = reverse_complement(mrna)
+            indices = indices[::-1]
+        return mrna, indices
+
+    def __sense2pos(self, mrna, indices):
+        if self.rev:
+            mrna = reverse_complement(mrna)
+            indices = indices[::-1]
+        return mrna, indices
+
+    def generate_mature_mrna_pos(self, reset=True):
+        mature_mrna_pos, mature_indices_pos = '', []
+        if reset:
+            pre_seq_pos, pre_indices_pos = self.generate_pre_mrna_pos()
+            self.pre_mrna, _ = self.__pos2sense(pre_seq_pos, pre_indices_pos)
+        else:
+            pre_seq_pos, pre_indices_pos = self.__sense2pos(self.pre_mrna, self.pre_indices)
+
+        for i, j in self.exons_pos:
+            rel_start, rel_end = pre_indices_pos.index(i), pre_indices_pos.index(j)
+            mature_mrna_pos += pre_seq_pos[rel_start:rel_end + 1]
+            pre_indices_pos.extend(pre_indices_pos[rel_start:rel_end + 1])
+        return mature_mrna_pos, pre_indices_pos
+
+    def generate_mature_mrna(self, inplace=True):
+        if inplace:
+            self.transcript_seq, self.transcript_indices = self.__pos2sense(*self.generate_mature_mrna_pos())
+            return self
+        return self.__pos2sense(*self.generate_mature_mrna_pos())
+
+    def generate_protein(self, inplace=True, reset=True):
+        if reset:
+            self.generate_mature_mrna()
+
+        if not self.TIS or self.TIS not in self.transcript_indices:
+            return ''
+
+        rel_start = self.transcript_indices.index(self.TIS)
+        orf = self.transcript_seq[rel_start:]
+        first_stop_index = next((i for i in range(0, len(orf) - 2, 3) if orf[i:i + 3] in {"TAG", "TAA", "TGA"}), len(orf)-3)
+        while first_stop_index % 3 != 0:
+            first_stop_index -= 1
+
+        orf = orf[:first_stop_index + 3]
+        protein = str(Seq(orf).translate()).replace('*', '')
+        if inplace:
+            self.orf = orf
+            self.protein = protein
+            if self.protein != self.cons_seq:
+                self.cons_available = False
+            return self
+        return protein
+
+
+
+## Missplicing construction
+def develop_aberrant_splicing(transcript, aberrant_splicing):
+    exon_starts = {v: 1 for v in transcript.acceptors}
+    exon_starts.update({transcript.transcript_start: 1})
+    exon_starts.update({s: v['absolute'] for s, v in aberrant_splicing['missed_acceptors'].items()})
+    exon_starts.update({s: v['absolute'] for s, v in aberrant_splicing['discovered_acceptors'].items()})
+
+    exon_ends = {v: 1 for v in transcript.donors}
+    exon_ends.update({transcript.transcript_end: 1})
+    exon_ends.update({s: v['absolute'] for s, v in aberrant_splicing['missed_donors'].items()})
+    exon_ends.update({s: v['absolute'] for s, v in aberrant_splicing['discovered_donors'].items()})
+
+    nodes = [SpliceSite(pos=pos, ss_type=0, prob=prob) for pos, prob in exon_ends.items()] + \
+            [SpliceSite(pos=pos, ss_type=1, prob=prob) for pos, prob in exon_starts.items()]
+
+    nodes = [s for s in nodes if s.prob > 0]
+    nodes.sort(key=lambda x: x.pos, reverse=transcript.rev)
+
+    G = nx.DiGraph()
+    G.add_nodes_from([n.pos for n in nodes])
+
+    for i in range(len(nodes)):
+        trailing_prob, in_between = 0, []
+        for j in range(i + 1, len(nodes)):
+            curr_node, next_node = nodes[i], nodes[j]
+            spread = curr_node.ss_type in in_between
+            in_between.append(next_node.ss_type)
+            if curr_node.ss_type != next_node.ss_type:
+                if spread:
+                    new_prob = next_node.prob - trailing_prob
+                    if new_prob <= 0:
+                        break
+                    G.add_edge(curr_node.pos, next_node.pos)
+                    G.edges[curr_node.pos, next_node.pos]['weight'] = new_prob
+                    trailing_prob += next_node.prob
+                else:
+                    G.add_edge(curr_node.pos, next_node.pos)
+                    G.edges[curr_node.pos, next_node.pos]['weight'] = next_node.prob
+                    trailing_prob += next_node.prob
+
+    new_paths, prob_sum = {}, 0
+    for i, path in enumerate(nx.all_simple_paths(G, transcript.transcript_start, transcript.transcript_end)):
+        curr_prob = path_weight_mult(G, path, 'weight')
+        prob_sum += curr_prob
+        new_paths[i] = {
+            'acceptors': sorted([p for p in path if p in exon_starts.keys() and p != transcript.transcript_start],
+                                reverse=transcript.rev),
+            'donors': sorted([p for p in path if p in exon_ends.keys() and p != transcript.transcript_end],
+                             reverse=transcript.rev),
+            'path_weight': curr_prob}
+
+    for i, path in enumerate(nx.all_simple_paths(G, transcript.transcript_end, transcript.transcript_start)):
+        curr_prob = path_weight_mult(G, path, 'weight')
+        prob_sum += curr_prob
+        new_paths[i] = {
+            'acceptors': sorted([p for p in path if p in exon_starts.keys() and p != transcript.transcript_start],
+                                reverse=transcript.rev),
+            'donors': sorted([p for p in path if p in exon_ends.keys() and p != transcript.transcript_end],
+                             reverse=transcript.rev),
+            'path_weight': curr_prob}
+
+
+    for i, d in new_paths.items():
+        d['path_weight'] = round(d['path_weight'] / prob_sum, 3)
+    new_paths = {k: v for k, v in new_paths.items() if v['path_weight'] > 0.01}
+    return list(new_paths.values())
+
+
+def path_weight_mult(G, path, weight):
+    multigraph = G.is_multigraph()
+    cost = 1
+    if not nx.is_path(G, path):
+        raise nx.NetworkXNoPath("path does not exist")
+    for node, nbr in nx.utils.pairwise(path):
+        if multigraph:
+            cost *= min(v[weight] for v in G[node][nbr].values())
+        else:
+            cost *= G[node][nbr][weight]
+    return cost
+
+@dataclass
+class SpliceSite(object):
+    pos: int
+    ss_type: int
+    prob: float
+
+    def __post_init__(self):
+        pass
+
+    def __lt__(self, other):
+        return self.pos < other.pos
+
+    def __str__(self):
+        print(f"({self.ss_type}, {self.pos}, {self.prob})")
+
+
+# Missplicing Detection
+def find_ss_changes(ref_dct, mut_dct, known_splice_sites, threshold=0.5):
+    '''
+    :param ref_dct:  the spliceai probabilities for each nucleotide (by genomic position) as a dictionary for the reference sequence
+    :param mut_dct:  the spliceai probabilities for each nucleotide (by genomic position) as a dictionary for the mutated sequence
+    :param known_splice_sites: the indices (by genomic position) that serve as known splice sites
+    :param threshold: the threshold for detection (difference between reference and mutated probabilities)
+    :return: two dictionaries; discovered_pos is a dictionary containing all the positions that meat the threshold for discovery
+            and deleted_pos containing all the positions that meet the threshold for missing and the condition for missing
+    '''
+
+    new_dict = {v: mut_dct.get(v, 0) - ref_dct.get(v, 0) for v in
+                list(set(list(ref_dct.keys()) + list(mut_dct.keys())))}
+
+    discovered_pos = {k: {'delta': round(float(v), 3), 'absolute': round(float(mut_dct[k]), 3)} for k, v in
+                      new_dict.items() if v >= threshold and k not in known_splice_sites}   # if (k not in known_splice_sites and v >= threshold) or (v > 0.45)}
+
+    deleted_pos = {k: {'delta': round(float(v), 3), 'absolute': round(float(mut_dct.get(k, 0)), 3)} for k, v in
+                   new_dict.items() if -v >= threshold and k in known_splice_sites}      #if k in known_splice_sites and v <= -threshold}
+
+    return discovered_pos, deleted_pos
+
+def run_spliceai_seq(seq, indices, threshold=0):
+    seq = 'N' * 5000 + seq + 'N' * 5000
+    ref_seq_probs_temp = sai_predict_probs(seq, sai_models)
+    ref_seq_acceptor_probs, ref_seq_donor_probs = ref_seq_probs_temp[0, :], ref_seq_probs_temp[1, :]
+    acceptor_indices = {a: b for a, b in list(zip(indices, ref_seq_acceptor_probs)) if b >= threshold}
+    donor_indices = {a: b for a, b in list(zip(indices, ref_seq_donor_probs)) if b >= threshold}
+    return acceptor_indices, donor_indices
+
+
+def run_spliceai_transcript(mutations, transcript_data, sai_mrg_context=5000, min_coverage=2500, sai_threshold=0.5):
+    positions = mutations.positions
+    end_positions = [m.start + len(m.ref) for m in mutations.variants]
+    positions.extend(end_positions)
+
+    seq_start_pos = min(positions) - sai_mrg_context - min_coverage
+    seq_end_pos = max(positions) + sai_mrg_context + min_coverage
+
+    fasta_obj = Fasta_segment()
+    ref_seq, ref_indices = fasta_obj.read_segment_endpoints(
+        config_setup['CHROM_SOURCE'] / f'chr{mutations.chrom}.fasta',
+        seq_start_pos,
+        seq_end_pos)
+
+    transcript_start, transcript_end, rev = transcript_data.transcript_lower, transcript_data.transcript_upper, transcript_data.rev
+
+    # visible_donors = np.intersect1d(transcript_data.donors, ref_indices)
+    # visible_acceptors = np.intersect1d(transcript_data.acceptors, ref_indices)
+
+    start_pad = ref_indices.index(transcript_start) if transcript_start in ref_indices else 0
+    end_cutoff = ref_indices.index(transcript_end) if transcript_end in ref_indices else len(ref_indices)
+    end_pad = len(ref_indices) - end_cutoff
+    ref_seq = 'N' * start_pad + ref_seq[start_pad:end_cutoff] + 'N' * end_pad
+    ref_indices = [-1] * start_pad + ref_indices[start_pad:end_cutoff] + [-1] * end_pad
+    mut_seq, mut_indices = ref_seq, ref_indices
+
+    for mut in mutations:
+        mut_seq, mut_indices = generate_mut_variant(seq=mut_seq, indices=mut_indices, mut=mut)
+
+    if mut_seq == ref_seq:
+        print("Even in SpliceAI?!")
+
+    ref_indices = ref_indices[sai_mrg_context:-sai_mrg_context]
+    mut_indices = mut_indices[sai_mrg_context:-sai_mrg_context]
+    copy_mut_indices = mut_indices.copy()
+
+    visible_donors = np.intersect1d(transcript_data.donors, ref_indices)
+    visible_acceptors = np.intersect1d(transcript_data.acceptors, ref_indices)
+
+    if rev:
+        ref_seq = reverse_complement(ref_seq)
+        mut_seq = reverse_complement(mut_seq)
+        ref_indices = ref_indices[::-1]
+        mut_indices = mut_indices[::-1]
+
+    ref_seq_probs_temp = sai_predict_probs(ref_seq, sai_models)
+    mut_seq_probs_temp = sai_predict_probs(mut_seq, sai_models)
+
+    ref_seq_acceptor_probs, ref_seq_donor_probs = ref_seq_probs_temp[0, :], ref_seq_probs_temp[1, :]
+    mut_seq_acceptor_probs, mut_seq_donor_probs = mut_seq_probs_temp[0, :], mut_seq_probs_temp[1, :]
+
+    assert len(ref_indices) == len(ref_seq_acceptor_probs), 'Reference pos not the same'
+    assert len(mut_indices) == len(mut_seq_acceptor_probs), 'Mut pos not the same'
+
+    iap, dap = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_acceptor_probs))},
+                               {p: v for p, v in list(zip(mut_indices, mut_seq_acceptor_probs))},
+                               visible_acceptors,
+                               threshold=sai_threshold)
+
+    assert len(ref_indices) == len(ref_seq_donor_probs), 'Reference pos not the same'
+    assert len(mut_indices) == len(mut_seq_donor_probs), 'Mut pos not the same'
+
+    idp, ddp = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_donor_probs))},
+                               {p: v for p, v in list(zip(mut_indices, mut_seq_donor_probs))},
+                               visible_donors,
+                               threshold=sai_threshold)
+
+    ref_acceptors = {a: b for a, b in list(zip(ref_indices, ref_seq_acceptor_probs))}
+    ref_donors = {a: b for a, b in list(zip(ref_indices, ref_seq_donor_probs))}
+
+    lost_acceptors = {int(p): {'absolute': np.float64(0), 'delta': round(float(-ref_acceptors[p]), 3)} for p in visible_acceptors if p not in mut_indices and p not in dap}
+    lost_donors = {int(p): {'absolute': np.float64(0), 'delta': round(float(-ref_donors[p]), 3)} for p in visible_donors if p not in mut_indices and p not in ddp}
+    dap.update(lost_acceptors)
+    ddp.update(lost_donors)
+
+    missplicing = {'missed_acceptors': dap, 'missed_donors': ddp, 'discovered_acceptors': iap, 'discovered_donors': idp}
+    missplicing = {outk: {float(k): v for k, v in outv.items()} for outk, outv in missplicing.items()}
+    return {outk: {int(k) if k.is_integer() else k: v for k, v in outv.items()} for outk, outv in missplicing.items()}
+
+
+# def run_spliceai(mutations, gene_data, sai_mrg_context=5000, min_coverage=2500, sai_threshold=0.5):
+#     positions = mutations.positions
+#     seq_start_pos = min(positions) - sai_mrg_context - min_coverage
+#     seq_end_pos = max(positions) + sai_mrg_context + min_coverage
+#
+#     fasta_obj = Fasta_segment()
+#     ref_seq, ref_indices = fasta_obj.read_segment_endpoints(
+#         config_setup['CHROM_SOURCE'] / f'chr{mutations.chrom}.fasta',
+#         seq_start_pos,
+#         seq_end_pos)
+#
+#     gene_start, gene_end, rev = gene_data.gene_start, gene_data.gene_end, gene_data.rev
+#
+#     mrna_acceptors = sorted(list(set([lst for lsts in
+#                                       [mrna.get('acceptors', []) for mrna in gene_data.transcripts.values() if
+#                                        mrna['transcript_biotype'] == 'protein_coding'] for lst in lsts])))
+#
+#     mrna_donors = sorted(list(set([lst for lsts in
+#                                    [mrna.get('donors', []) for mrna in gene_data.transcripts.values() if
+#                                     mrna['transcript_biotype'] == 'protein_coding'] for lst in lsts])))
+#
+#     visible_donors = np.intersect1d(mrna_donors, ref_indices)
+#     visible_acceptors = np.intersect1d(mrna_acceptors, ref_indices)
+#
+#     start_pad = ref_indices.index(gene_start) if gene_start in ref_indices else 0
+#     end_cutoff = ref_indices.index(gene_end) if gene_end in ref_indices else len(ref_indices)  # - 1
+#     end_pad = len(ref_indices) - end_cutoff
+#     ref_seq = 'N' * start_pad + ref_seq[start_pad:end_cutoff] + 'N' * end_pad
+#     ref_indices = [-1] * start_pad + ref_indices[start_pad:end_cutoff] + [-1] * end_pad
+#     mut_seq, mut_indices = ref_seq, ref_indices
+#
+#     for mut in mutations:
+#         mut_seq, mut_indices = generate_mut_variant(seq=mut_seq, indices=mut_indices, mut=mut)
+#
+#     ref_indices = ref_indices[sai_mrg_context:-sai_mrg_context]
+#     mut_indices = mut_indices[sai_mrg_context:-sai_mrg_context]
+#
+#     copy_mut_indices = mut_indices.copy()
+#     if rev:
+#         ref_seq = reverse_complement(ref_seq)
+#         mut_seq = reverse_complement(mut_seq)
+#         ref_indices = ref_indices[::-1]
+#         mut_indices = mut_indices[::-1]
+#
+#     ref_seq_probs_temp = sai_predict_probs(ref_seq, sai_models)
+#     mut_seq_probs_temp = sai_predict_probs(mut_seq, sai_models)
+#
+#     ref_seq_acceptor_probs, ref_seq_donor_probs = ref_seq_probs_temp[0, :], ref_seq_probs_temp[1, :]
+#     mut_seq_acceptor_probs, mut_seq_donor_probs = mut_seq_probs_temp[0, :], mut_seq_probs_temp[1, :]
+#
+#     assert len(ref_indices) == len(ref_seq_acceptor_probs), 'Reference pos not the same'
+#     assert len(mut_indices) == len(mut_seq_acceptor_probs), 'Mut pos not the same'
+#
+#     iap, dap = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_acceptor_probs))},
+#                                {p: v for p, v in list(zip(mut_indices, mut_seq_acceptor_probs))},
+#                                visible_acceptors,
+#                                threshold=sai_threshold)
+#
+#     assert len(ref_indices) == len(ref_seq_donor_probs), 'Reference pos not the same'
+#     assert len(mut_indices) == len(mut_seq_donor_probs), 'Mut pos not the same'
+#
+#     idp, ddp = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_donor_probs))},
+#                                {p: v for p, v in list(zip(mut_indices, mut_seq_donor_probs))},
+#                                visible_donors,
+#                                threshold=sai_threshold)
+#
+#     # lost_acceptors = {p: {'absolute': 0, 'delta': -1} for p in gene_data.acceptors if not contains(copy_mut_indices, p)}
+#     # lost_donors = {p: {'absolute': 0, 'delta': -1} for p in gene_data.donors if not contains(copy_mut_indices, p)}
+#     # dap.update(lost_acceptors)
+#     # ddp.update(lost_donors)
+#     missplicing = {'missed_acceptors': dap, 'missed_donors': ddp, 'discovered_acceptors': iap, 'discovered_donors': idp}
+#     missplicing = {outk: {float(k): v for k, v in outv.items()} for outk, outv in missplicing.items()}
+#
+#     return {outk: {int(k) if k.is_integer() else k: v for k, v in outv.items()} for outk, outv in missplicing.items()}
+#
+
+class PredictSpliceAI:
+    def __init__(self, mutation, gene_data,
+                threshold=0.5, force=False,  save_results=False, sai_mrg_context=5000, min_coverage=2500):
+        self.modification = mutation
+        self.threshold = threshold
+        self.transcript_id = gene_data.transcript_id
+        self.spliceai_db = config_setup['MISSPLICING_PATH'] / f'spliceai_epistatic'
+        self.missplicing = {}
+
+        if self.prediction_file_exists() and not force: # need to do a check for the filename length
+            self.missplicing = self.load_sai_predictions()
+
+        if not self.missplicing:
+        # else:
+            # if isinstance(gene_data, Gene):
+            #     self.missplicing = run_spliceai(self.modification, gene_data=gene_data, sai_mrg_context=sai_mrg_context, min_coverage=min_coverage, sai_threshold=0.1)
+            #     if save_results:
+            #         self.save_sai_predictions()
+            #
+            # elif isinstance(gene_data, Transcript):
+            self.missplicing = run_spliceai_transcript(self.modification, transcript_data=gene_data, sai_mrg_context=sai_mrg_context, min_coverage=min_coverage, sai_threshold=0.1)
+            if save_results:
+                self.save_sai_predictions()
+
+
+    def __repr__(self):
+        return f'Missplicing({self.modification.mut_id}) --> {self.missplicing}'
+
+    def __str__(self):
+        return self.aberrant_splicing
+    def __bool__(self):
+        for event, details in self.aberrant_splicing.items():
+            if details:
+                return True
+        return False
+
+    def __eq__(self, alt_splicing):
+        flag, _ = check_splicing_difference(self.missplicing, alt_splicing, self.threshold)
+        return not flag
+
+    def __iter__(self):
+        penetrances = [abs(d_in['delta']) for d in self.missplicing.values() for d_in in d.values()] + [0]
+        return iter(penetrances)
+
+    @property
+    def aberrant_splicing(self):
+        return self.apply_sai_threshold(self.missplicing, self.threshold)
+
+    @property
+    def prediction_file(self):
+        return self.spliceai_db / self.modification.gene / self.modification.file_identifier_json
+
+    def prediction_file_exists(self):
+        return self.prediction_file.exists()
+
+    def load_sai_predictions(self):
+        missplicing = unload_json(self.prediction_file)
+        if self.transcript_id in missplicing:
+            missplicing = missplicing[self.transcript_id]
+        else:
+            return {}
+
+        missplicing = {outk: {float(k): v for k, v in outv.items()} for outk, outv in missplicing.items()}
+        missplicing = {outk: {int(k) if k.is_integer() or 'missed' in outk else k: v for k, v in outv.items()} for
+                       outk, outv in
+                       missplicing.items()}
+        return missplicing
+
+    def save_sai_predictions(self):
+        self.prediction_file.parent.mkdir(parents=True, exist_ok=True)
+        if self.prediction_file_exists():
+            missplicing = unload_json(self.prediction_file)
+            missplicing[self.transcript_id] = self.missplicing
+
+        else:
+            missplicing = {self.transcript_id: self.missplicing}
+
+        # print(missplicing)
+        dump_json(self.prediction_file, missplicing)
+
+    def apply_sai_threshold(self, splicing_dict=None, threshold=None):
+        splicing_dict = self.missplicing if not splicing_dict else splicing_dict
+        threshold = self.threshold if not threshold else threshold
+        new_dict = {}
+        for event, details in splicing_dict.items():
+            for e, d in details.items():
+                if abs(d['delta']) >= threshold:
+                    return splicing_dict
+            # new_dict[event] = {}        #{k: v for k, v in details.items() if abs(v['delta']) >= threshold}
+        return new_dict
+
+
+    def apply_sai_threshold_primary(self, splicing_dict=None, threshold=None):
+        splicing_dict = self.missplicing if not splicing_dict else splicing_dict
+        threshold = self.threshold if not threshold else threshold
+        new_dict = {}
+        for event, details in splicing_dict.items():
+            new_dict_in = {}
+            for e, d in details.items():
+                if abs(d['delta']) >= threshold:
+                    new_dict_in[e] = d
+            new_dict[event] = new_dict_in
+        return new_dict
+
+    def get_max_missplicing_delta(self):
+        max_delta = 0
+        for event, details in self.missplicing.items():
+            for e, d in details.items():
+                if abs(d['delta']) > max_delta:
+                    max_delta = abs(d['delta'])
+        return max_delta
+
+
+def check_splicing_difference(missplicing1, missplicing2, threshold=None):
+    flag = False
+    true_differences = {}
+    for event in ['missed_acceptors', 'missed_donors']:
+        td = {}
+        dct1 = missplicing1[event]
+        dct2 = missplicing2[event]
+        for k in list(set(list(dct1.keys()) + list(dct2.keys()))):
+            diff = abs(dct1.get(k, {'delta': 0})['delta']) - abs(dct2.get(k, {'delta': 0})['delta'])
+            if abs(diff) >= threshold:
+                flag = True
+                td[k] = diff
+        true_differences[event] = td
+
+    for event in ['discovered_acceptors', 'discovered_donors']:
+        td = {}
+        dct1 = missplicing1[event]
+        dct2 = missplicing2[event]
+        for k in list(set(list(dct1.keys()) + list(dct2.keys()))):
+            diff = abs(dct1.get(k, {'delta': 0})['delta']) - abs(dct2.get(k, {'delta': 0})['delta'])
+            if abs(diff) >= threshold:
+                flag = True
+                td[k] = diff
+        true_differences[event] = td
+
+    return flag, true_differences
+
+
+# Annotating
+def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
+    affected_exon, affected_intron, distance_from_5, distance_from_3 = find_splice_site_proximity(mut,
+                                                                                                  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
+    report['affected_intron'] = affected_intron
+    report['mutation_distance_from_5'] = distance_from_5
+    report['mutation_distance_from_3'] = distance_from_3
+    return report
+
+from Bio.Seq import Seq
+from Bio import pairwise2
+from dataclasses import dataclass
+from copy import deepcopy
+import re
+import pandas as pd
+from pathlib import Path
+import numpy as np
+from geney import config_setup
+import networkx as nx
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+import seaborn as sns
+from collections import namedtuple
+
+
+from geney.utils import find_files_by_gene_name, reverse_complement, unload_pickle, contains, unload_json, dump_json #, is_monotonic
+from geney.Fasta_segment import Fasta_segment
+
+#### SpliceAI Modules
+import tensorflow as tf
+from keras.models import load_model
+from pkg_resources import resource_filename
+from spliceai.utils import one_hot_encode
+
+tf.config.threading.set_intra_op_parallelism_threads(1)
+tf.config.threading.set_inter_op_parallelism_threads(1)
+
+sai_paths = ('models/spliceai{}.h5'.format(x) for x in range(1, 6))
+sai_models = [load_model(resource_filename('spliceai', x)) for x in sai_paths]
+
+def is_monotonic(A):
+    x, y = [], []
+    x.extend(A)
+    y.extend(A)
+    x.sort()
+    y.sort(reverse=True)
+    if (x == A or y == A):
+        return True
+    return False
+
+def sai_predict_probs(seq: str, models: list) -> list:
+    '''
+    Predicts the donor and acceptor junction probability of each
+    NT in seq using SpliceAI.
+
+    Let m:=2*sai_mrg_context + L be the input seq length. It is assumed
+    that the input seq has the following structure:
+
+          seq = |<sai_mrg_context NTs><L NTs><sai_mrg_context NTs>|
+
+    The returned probability matrix is of size 2XL, where
+    the first row is the acceptor probability and the second row
+    is the donor probability. These probabilities corresponds to the
+    middel <L NTs> NTs of the input seq.
+    '''
+    x = one_hot_encode(seq)[None, :]
+    y = np.mean([models[m].predict(x, verbose=0) for m in range(5)], axis=0)
+    return y[0, :, 1:].T
+
+
+### Variant Modules
+class Mutation:
+    def __init__(self, mid):
+        '''
+
+        :param mid: mutation id in the format of gene:chrom:pos:ref:alt
+        Needs only to store the following properties for a given mutation
+        gene: the name of the gene
+        chrom: the chromosome refernece
+        start: the position of the mutation
+        file_identifier: some filename that can be used to store related data
+        vartype: the variant type
+
+        We want to be able to compare mutations based on location.
+        '''
+
+        self.mut_id = mid
+
+        gene, chrom, pos, ref, alt = mid.split(':')
+        self.gene = gene
+        self.chrom = chrom.strip('chr')
+        self.start = int(pos)
+
+        self.file_identifier = self.mut_id.replace(':', '_')
+        self.file_identifier_short = f'{self.start}_{ref[:6]}_{alt[:6]}'
+
+        self.ref = ref if ref != '-' else ''
+        self.alt = alt if alt != '-' else ''
+
+        if len(self.ref) == len(self.alt) == 1:
+            self.vartype = 'SNP'
+
+        elif len(self.ref) == len(self.alt) > 1:
+            self.vartype = 'SUB'
+        elif self.ref and not self.alt:
+            self.vartype = 'DEL'
+        elif self.alt and not self.ref:
+            self.vartype = 'INS'
+        else:
+            self.vartype = 'INDEL'
+
+    def __str__(self):
+        return self.mut_id
+
+    def __repr__(self):
+        return f"Mutation({self.mut_id})"
+
+    def __lt__(self, other):
+        return self.start < other.start
+
+class Variations:
+    '''
+    Unlike a mutation, here we have an epistatic set, or a series of mtuations that are separated by '|' characters
+    For such events we want to store them
+    '''
+    def __init__(self, epistatic_set):
+        self.variants = sorted([Mutation(m) for m in epistatic_set.split('|')])
+        self.mut_id = epistatic_set
+        self.start = self.variants[0].start
+        self.positions = [v.start for v in self.variants]
+        self.gene = self.variants[0].gene
+        self.chrom = self.variants[0].chrom.strip('chr')
+        self.file_identifier = f'{self.gene}_{self.chrom}' + '_' + '_'.join(
+            [v.file_identifier_short for v in self.variants])
+        self.range = max(self.positions) - min(self.positions)
+
+    def __str__(self):
+        return '|'.join([m.mut_id for m in self.variants])
+
+    def __repr__(self):
+        return f"Variation({', '.join([m.mut_id for m in self.variants])})"
+
+    def __iter__(self):
+        self.current_index = 0
+        return self
+
+    def __next__(self):
+        if self.current_index < len(self.variants):
+            x = self.variants[self.current_index]
+            self.current_index += 1
+            return x
+        raise StopIteration
+
+    @property
+    def file_identifier_json(self):
+        return Path(self.file_identifier + '.json')
+
+    @property
+    def as_dict(self):
+        return {m.start: m.alt for m in self.variants}
+
+    def verify(self):
+        if len(set(self.positions)) != len(self.variants):
+            return False
+        return True
+
+
+def generate_mut_variant(seq: str, indices: list, mut: Mutation):
+    offset = 1 if not mut.ref else 0
+    check_indices = list(range(mut.start, mut.start + len(mut.ref) + offset))
+    check1 = all([contains(list(filter((-1).__ne__, indices)), m) for m in check_indices])
+    if not check1:
+        print(
+            f"Mutation {mut} not within transcript bounds: {min(list(filter((-1).__ne__, indices)))} - {max(indices)}.")
+
+        return seq, indices
+
+    rel_start, rel_end = indices.index(mut.start) + offset, indices.index(mut.start) + offset + len(mut.ref)
+    acquired_seq = seq[rel_start:rel_end]
+    check2 = acquired_seq == mut.ref
+    if not check2:
+        print(f'Reference allele ({mut.ref}) does not match genome_build allele ({acquired_seq}).')
+
+    if len(mut.ref) == len(mut.alt) > 0:
+        temp_indices = list(range(mut.start, mut.start + len(mut.ref)))
+    # elif len(mut.ref) > 0 and len(mut.alt) > 0:
+    #     temp_indices = [indices[indices.index(mut.start)] + v / 1000 for v in list(range(0, len(mut.alt)))]
+    else:
+        temp_indices = [indices[indices.index(mut.start)] + v / 1000 for v in list(range(1, len(mut.alt) + 1))]
+
+    new_indices = indices[:rel_start] + temp_indices + indices[rel_end:]
+    new_seq = seq[:rel_start] + mut.alt + seq[rel_end:]
+
+    assert len(new_seq) == len(new_indices), f'Error in preserving sequence lengths during variant modification: {mut}, {len(new_seq)}, {len(new_indices)}'
+    assert is_monotonic(list(filter((-1).__ne__, new_indices))), f'Modified nucleotide indices are not monotonic.'
+    return new_seq, new_indices
+
+
+
+class Gene:
+    def __init__(self, gene_name, variation=None):
+        self.gene_name = gene_name
+        self.gene_id = ''
+        self.rev = None
+        self.chrm = ''
+        self.gene_start = 0
+        self.gene_end = 0
+        self.transcripts = {}
+        self.load_from_file(find_files_by_gene_name(gene_name))
+        self.variations = variation
+        self.primary_tid = None
+        tids = [k for k, v in self.transcripts.items() if v['primary_transcript'] and v['transcript_biotype'] == 'protein_coding']
+        if tids:
+            self.primary_tid = tids[0]
+        else:
+            self.primary_tid = list(self.transcripts.keys())[0]
+
+    def __repr__(self):
+        return f'Gene(gene_name={self.gene_name})'
+
+    def __len__(self):
+        return len(self.transcripts)
+
+    def __str__(self):
+        return '{gname}, {ntranscripts} transcripts'.format(gname=self.gene_name, ntranscripts=self.__len__())
+
+    def __copy__(self):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        result.__dict__.update(self.__dict__)
+        return result
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        for k, v in self.__dict__.items():
+            setattr(result, k, deepcopy(v, memo))
+        return result
+
+    def __getitem__(self, index):
+        return Transcript(list(self.transcripts.values())[index])
+
+    def load_from_file(self, file_name):
+        if not file_name.exists():
+            raise FileNotFoundError(f"File '{file_name}' not found.")
+        self.load_from_dict(dict_data=unload_pickle(file_name))
+        return self
+
+    def load_from_dict(self, dict_data=None):
+        for k, v in dict_data.items():
+            setattr(self, k, v)
+        return self
+
+    def transcript(self, tid=None):
+        if tid is None:
+            tid = self.primary_tid
+
+        if tid not in self.transcripts:
+            raise AttributeError(f"Transcript '{tid}' not found in gene '{self.gene_name}'.")
+        return Transcript(self.transcripts[tid])
+
+    def run_transcripts(self, primary_transcript=False, protein_coding=False):
+        for tid, annotations in self.transcripts.items():
+            if primary_transcript and not annotations['primary_transcript']:
+                continue
+            if protein_coding and annotations['transcript_biotype'] != 'protein_coding':
+                continue
+
+            yield Transcript(self.transcripts[tid], variations=self.variations)
+
+
 class Transcript:
     def __init__(self, d=None, variations=None):
         self.transcript_id = None
@@ -720,6 +1748,9 @@ def run_spliceai_transcript(mutations, transcript_data, sai_mrg_context=5000, mi
     for mut in mutations:
         mut_seq, mut_indices = generate_mut_variant(seq=mut_seq, indices=mut_indices, mut=mut)
 
+    if mut_seq == ref_seq:
+        print("Even in SpliceAI?!")
+
     ref_indices = ref_indices[sai_mrg_context:-sai_mrg_context]
     mut_indices = mut_indices[sai_mrg_context:-sai_mrg_context]
     copy_mut_indices = mut_indices.copy()
@@ -1024,6 +2055,11 @@ def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
     return report
 
 
+# def find_splice_site_proximity(mut, transcript):
+#     for i, (ex_start, ex_end) in enumerate(transcript.exons):
+#         if min(ex_start, ex_end) <= mut.start <= max(ex_start, ex_end):
+#
+
 def find_splice_site_proximity(mut, transcript):
     for i, (ex_start, ex_end) in enumerate(transcript.exons):
         if min(ex_start, ex_end) <= mut.start <= max(ex_start, ex_end):
@@ -1347,8 +2383,12 @@ def oncosplice(mut_id, sai_threshold=0.5, protein_coding=True, primary_transcrip
     for variant in mutated_gene.run_transcripts(protein_coding=protein_coding, primary_transcript=primary_transcript):
         reference = reference_gene.transcript(variant.transcript_id)
         if mutation not in reference or reference.protein == '' or len(reference.protein) < window_length:
+            print("exit flag 1")
             continue
 
+        if reference.pre_mrna == variant.pre_mrna:
+            print("WHAT THE FUCK?")
+
         cons_vector = transform_conservation_vector(reference.cons_vector, window=window_length)
         # if per_transcript_missplicing:
         missplicing_obj = PredictSpliceAI(mutation, reference, threshold=sai_threshold, force=force_spliceai, save_results=save_spliceai_results)

geney/power_utils.py

@@ -65,6 +65,7 @@ def launch_dask_cluster(memory_size="3GB", num_workers=10, queue="tamirQ",
                 log_directory=log_directory,
                 job_script_prologue=[f"cd {config_setup['BASE']}"]
             )
+
         else:
             dask_cluster = PBSCluster(
                 cores=1,

geney/survival_utils.py

@@ -82,13 +82,15 @@ class SurvivalAnalysis:
 
             kmf.fit(g['duration'], g['event'], label=label)
             surv_func = kmf.survival_function_
-            auc = trapz(surv_func[label], surv_func.index)
+            filtered_surv_func = surv_func[surv_func.index <= cap_time]
+            auc = np.trapz(filtered_surv_func[label], filtered_surv_func.index)
+            # auc = trapz(surv_func[label], surv_func.index)
             auc_vals.append(auc)
             if plot:
                 if count == 0:
-                    ax = kmf.plot()
+                    ax = kmf.plot_survival_function()
                 else:
-                    kmf.plot(ax=ax)
+                    kmf.plot_survival_function(ax=ax)
                 count += 1
         p_value = self.log_rank(df[df[feature] == 1], df[df[feature] == 0])
 

geney/tcga_utils.py

@@ -157,12 +157,10 @@ class TCGAGene:
         # returns two lists: all patients affected by a mutation and all patients with none of the mutations (or the mutations but not togehter)
         pass
 
-
     def arrange_patients_by_project(self, mut_id):
         # returns all the patients affected by a mutation grouped by cancer project
         pass
 
-
     def total_prevalence(self, mut_id):
         pass
 

{geney-1.1.10.dist-info → geney-1.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geney
-Version: 1.1.10
+Version: 1.1.12
 Summary: A Python package for gene expression modeling.
 Home-page: https://github.com/nicolaslynn/geney
 Author: Nicolas Lynn

{geney-1.1.10.dist-info → geney-1.1.12.dist-info}/RECORD

@@ -7,15 +7,16 @@ geney/config_setup.py,sha256=SePeooA4RWAtR_KAT1-W1hkD3MT5tH6YMyp80t_RNPQ,385
 geney/data_setup.py,sha256=DZeksRPr2ZT7bszMo33W0r3OwmqHokVXtZ4gx5Lu_Mo,10725
 geney/gtex.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
 geney/gtex_utils.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
+geney/immune_utils.py,sha256=elxjQyB52lYXrrt3sX6vtYlr_pTFEeCFzmEMP2qlPwA,5300
 geney/netchop.py,sha256=AMiy9YsdTmX4B3k3Y5Yh7EmoGAojM1O3AzhPKOiB--g,3050
-geney/oncosplice.py,sha256=Fyc_UtAhV3Pv0vk8V55rO_jnb2Dwj5sW98KVwP3PHwU,68964
+geney/oncosplice.py,sha256=BZMK3TzwKqObih79b1KNKMHvyJhB8W6Tj_kawmPFrqE,112110
 geney/oncosplice_pipeline.py,sha256=hpGqFHOdn8i8tvvs1-t3-G9Ko18zInwoDXBJbbrfbC4,68036
 geney/performance_utils.py,sha256=FQt7rA4r-Wuq3kceCxsSuMfj3wU1tMG8QnbL59aBohs,4700
-geney/power_utils.py,sha256=WRpqMnqUv1xrAeTduAUhx6YpSEJQci7bC2od12JcVtE,7267
+geney/power_utils.py,sha256=6InuDm1jSrsgR-F_LmdMTbuQwty2OdYjwfGGaAPhaRI,7268
 geney/survival.py,sha256=gNKZGcwxDZ00ixVBHf3ZdjbY_AHQOCU9kKpBC_dokbM,5572
-geney/survival_utils.py,sha256=gNKZGcwxDZ00ixVBHf3ZdjbY_AHQOCU9kKpBC_dokbM,5572
+geney/survival_utils.py,sha256=2CAkC2LsspicHIdrqsiPnjgvpr5KHDUfLFFqnRbPJqs,5762
 geney/tcga_annotations.py,sha256=DjRl6Pk5VAOL1yhbt8SXD6FZhYbcYNu3FtXYMeveGB0,15016
-geney/tcga_utils.py,sha256=XrLI8RzmXhyabvL24sMrqQM3KNusmU1_kyKYdkv6lpo,15591
+geney/tcga_utils.py,sha256=uAjejr7F-XqcXS5uANGlsHLOlzMmGo4CTbWhMO0E318,15589
 geney/utils.py,sha256=YOe22gA0Oew9_QEym7ivM9sb7t3wNeHTeiSDBmvOPso,1984
 geney/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geney/analyzers/benchmark_clinvar.py,sha256=ZAxvZ-Ue5T6au5mGbk8clfvbAYl13NIY7U92KzL0lXI,5531
@@ -43,7 +44,7 @@ geney/translation_initiation/resources/kozak_pssm.json,sha256=pcd0Olziutq-6H3mFW
 geney/translation_initiation/resources/tis_regressor_model.joblib,sha256=IXb4DUDhJ5rBDKcqMk9zE3ECTZZcdj7Jixz3KpoZ7OA,2592025
 geney/translation_termination/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geney/translation_termination/tts_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geney-1.1.10.dist-info/METADATA,sha256=Et_H-jo1c9eYsqEnjk1_gVLRtJYzS9-RXs8RE7Z-u6c,1131
-geney-1.1.10.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
-geney-1.1.10.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.1.10.dist-info/RECORD,,
+geney-1.1.12.dist-info/METADATA,sha256=YuSzsBvZGYcsKL7zcekpodsJUAkFqulI-aJ-_cC8JSU,1131
+geney-1.1.12.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+geney-1.1.12.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.1.12.dist-info/RECORD,,