geney 1.3.79__py2.py3-none-any.whl → 1.4.1__py2.py3-none-any.whl

geney/_tis_utils.py

@@ -0,0 +1,172 @@
+import numpy as np
+import pandas as pd
+import os
+from scipy.stats import percentileofscore
+import shelve
+from Bio.Align import PairwiseAligner
+from geney import config
+
+p = PairwiseAligner()
+
+
+def find_tis(reference_mrna, mutated_mrna, ref_tis_pos, left_context=100, right_context=102):
+    '''
+        mature_mrna: row 0 --> encoded nucleotides
+                     row 1 --> genomic indices
+                     row 2 --> super positions (incase of insertions or deletions
+                                row1+row2 = conhesive & monotonic genomic indices
+                     row 3 --> binary mutated position or not
+        mature_mrna.seq
+        mature_mrna.indices
+    '''
+    tis_coords = ref_seq.mature_mrna.asymmetric_indices(ref_seq.TIS, left_context=0, right_context=3)
+    ref_seq, mut_seq = ref_seq.mature_mrna, mut_seq.mature_mrna
+
+    # 1. Is the start codon (the indices) conserved in the mut sequence?
+    assert all(a in ref_seq.seqmat[1, :] for a in
+               tis_coords), f"Start codon indices specified not found in the reference sequence."
+    tis_conserved = all(a in mut_seq.seqmat[1, :] for a in tis_coords)
+
+    # 2. If condition 1 is passed, is the context around that start codon the same in both the reference and the mutated?
+    context_conserved = False
+    if tis_conserved:
+        context_conserved = ref_seq.asymmetric_subseq(tis_coords[0], left_context=left_context,
+                                                      right_context=right_context,
+                                                      padding='$') == mut_seq.asymmetric_subseq(tis_coords[0],
+                                                                                                left_context=left_context,
+                                                                                                right_context=right_context,
+                                                                                                padding='$')
+
+    if context_conserved:
+        return [(tis_coords[0], 1, 'canonical')]
+
+    sc_table = pd.read_pickle(config['titer_path'] / 'titer_tis_scores.pickle')
+    ref_seq_tis_context = ref_seq.asymmetric_subseq(tis_coords[0], left_context=left_context,
+                                                    right_context=right_context, padding='$')
+
+    ref_titer_score = retrieve_titer_score(ref_seq_tis_context)
+    ref_titer_rank = percentileofscore(sc_table['tis_score'], ref_titer_score)
+    ref_protein = ref_seq.translate(tis_coords[0])
+
+    candidate_positions = np.array([mut_seq.seq[i:i + 3] in TITER_acceptable_TISs for i in range(len(mut_seq.seq))])
+    candidate_positions = np.array(
+        [p.align(ref_protein, mut_seq.translate(mut_seq.seqmat[1, i])).score if candidate_positions[i] == True else 0
+         for i in range(len(ref_seq.seq))])
+
+    candidate_positions = candidate_positions > sorted(candidate_positions)[-5] # implement correct logic
+    candidate_positions = np.array([retrieve_titer_score(
+        mut_seq.asymmetric_subseq(tis_coords[0], left_context=left_context, right_context=right_context,
+                                  padding='$')) if candidate_positions[i] > 0 else False for i in
+                                    range(len(ref_seq.seq))])
+    candidate_positions = np.array(
+        [percentileofscore(sc_table.tis_score, candidate_positions[i]) if candidate_positions[i] != False else 100 for i
+         in range(len(ref_seq.seq))])
+    best_position = np.where(candidate_positions == min(candidate_positions))[0][0]
+    out = mut_seq.seqmat[1, best_position]
+    return out  #output: [(genomic_coord1, probability, filter_tag), (genomic_coord2, probability, filter_tag)]
+
+
+def seq_matrix(seq_list):
+    tensor = np.zeros((len(seq_list), 203, 8))
+    for i in range(len(seq_list)):
+        seq = seq_list[i]
+        j = 0
+        for s in seq:
+            if s == 'A' and (j < 100 or j > 102):
+                tensor[i][j] = [1, 0, 0, 0, 0, 0, 0, 0]
+            if s == 'T' and (j < 100 or j > 102):
+                tensor[i][j] = [0, 1, 0, 0, 0, 0, 0, 0]
+            if s == 'C' and (j < 100 or j > 102):
+                tensor[i][j] = [0, 0, 1, 0, 0, 0, 0, 0]
+            if s == 'G' and (j < 100 or j > 102):
+                tensor[i][j] = [0, 0, 0, 1, 0, 0, 0, 0]
+            if s == '$':
+                tensor[i][j] = [0, 0, 0, 0, 0, 0, 0, 0]
+            if s == 'A' and (j >= 100 and j <= 102):
+                tensor[i][j] = [0, 0, 0, 0, 1, 0, 0, 0]
+            if s == 'T' and (j >= 100 and j <= 102):
+                tensor[i][j] = [0, 0, 0, 0, 0, 1, 0, 0]
+            if s == 'C' and (j >= 100 and j <= 102):
+                tensor[i][j] = [0, 0, 0, 0, 0, 0, 1, 0]
+            if s == 'G' and (j >= 100 and j <= 102):
+                tensor[i][j] = [0, 0, 0, 0, 0, 0, 0, 1]
+            j += 1
+    return tensor
+
+
+def build_titer_model(TITER_path=config['hg38']['titer_path']):
+    print('Building TITER model...')
+    from tensorflow.keras.constraints import MaxNorm
+    from tensorflow.keras.layers import Conv1D, MaxPool1D, LSTM, Dropout, Flatten, Dense, Activation
+    from tensorflow.keras import Sequential, Input
+
+    model = Sequential()
+    model.add(Input(shape=(203, 8)))
+    model.add(Conv1D(filters=128,
+                     kernel_size=3,
+                     padding='valid',
+                     kernel_constraint=MaxNorm(3),
+                     activation='relu'))
+    model.add(MaxPool1D(3))
+    model.add(Dropout(rate=0.21370950078747658))
+    model.add(LSTM(units=256,
+                   return_sequences=True))
+    model.add(Dropout(rate=0.7238091317104384))
+    model.add(Flatten())
+    model.add(Dense(1))
+    model.add(Activation('sigmoid'))
+
+    model.compile(loss='binary_crossentropy',
+                  optimizer='nadam',
+                  metrics=['accuracy'])
+
+    models = []
+
+    # Load weights into multiple instances of the model
+    for i in range(32):
+        model_copy = Sequential(model.layers)  # Create a new model instance with the same architecture
+        weights_path = os.path.join(TITER_path, f"bestmodel_{i}.hdf5")
+
+        if os.path.exists(weights_path):
+            model_copy.load_weights(weights_path)  # Load weights into the new model instance
+            models.append(model_copy)
+            # print(f"Loaded model {i} with weights from {weights_path}")
+        else:
+            print(f"Warning: Weights file {weights_path} not found")
+
+    return models
+
+
+def calculate_titer_score(candidate_seq, titer_model=None):  # , prior):
+    if titer_model is None:
+        titer_model = TITER_MODEL
+    processed_seq = seq_matrix([candidate_seq])  # Wrap in list to keep dimensions consistent
+    # prior = np.array([prior]).reshape(1, 1)
+    analyzed_score = np.zeros((1, 1))
+
+    # Iterate through the models (assuming 32 models) and calculate the score
+    for i in range(32):
+        y_pred = titer_model[i].predict(processed_seq, verbose=0)
+        analyzed_score += y_pred  # * prior
+    print(analyzed_score)
+    return analyzed_score[0][0]
+
+
+def retrieve_titer_score(sequence, filename='sequences_shelve.db'):
+    # Open the shelf (acts like a dictionary, stored in a file)
+    with shelve.open(filename) as db:
+        # Check if sequence is already in the shelf
+        if sequence in db:
+            return db[sequence]
+        else:
+            # If not, run the function, store the result, and return it
+            value = calculate_titer_score(sequence, TITER_MODEL)
+            db[sequence] = value
+            return value
+
+
+TITER_acceptable_TISs = ['ATG', 'CTG', 'ACG', 'TTG', 'GTG']
+codon_tis_prior = {'ATG': 3.5287101354987644, 'CTG': 1.746859242328512, 'ACG': 1.3535552403706805,
+                   'TTG': 1.1364995562364615, 'GTG': 1.218573747658257}
+stop_codons = ['TAA', 'TAG', 'TGA']
+TITER_MODEL = build_titer_model()

geney/immune_utils.py

@@ -1,7 +1,7 @@
 import subprocess
 import logging
 import tempfile
-from geney import config_setup
+from geney import _config_setup
 import re
 from io import StringIO
 import pandas as pd

geney/pipelines.py

@@ -0,0 +1,66 @@
+# Home of the frequently used pipelines that everyone needs
+import pandas as pd
+from datetime import datetime
+
+from .Gene import Gene
+from .utils.mutation_utils import MutationalEvent
+from .SpliceSimulator import SpliceSimulator
+from .Oncosplice import Oncosplice
+from .utils.TranscriptLibrary import TranscriptLibrary
+
+
+def max_splicing_delta(mut_id, transcript_id=None, splicing_engine='spliceai'):
+    m = MutationalEvent(mut_id)
+    assert m.compatible(), 'Mutations in event are incompatible'
+    reference_transcript = Gene.from_file(
+        m.gene).transcript(transcript_id).generate_pre_mrna().generate_mature_mrna().generate_protein()
+    tl = TranscriptLibrary(reference_transcript, m)
+    splicing_results = tl.predict_splicing(m.position, engine=splicing_engine, inplace=True).get_event_columns('event')
+    ss = SpliceSimulator(splicing_results, tl.event, feature='event', max_distance=100_000_000)
+    return ss.max_splicing_delta('event_prob')
+
+
+def oncosplice_pipeline_single_transcript(mut_id, transcript_id=None, splicing_engine='spliceai', ):
+    m = MutationalEvent(mut_id)
+    assert m.compatible(), 'Mutations in event are incompatible'
+    reference_transcript = Gene.from_file(
+        m.gene).transcript(transcript_id).generate_pre_mrna().generate_mature_mrna().generate_protein()
+    tl = TranscriptLibrary(reference_transcript, m)
+    splicing_results = tl.predict_splicing(m.position, engine=splicing_engine, inplace=True).get_event_columns('event')
+    ss = SpliceSimulator(splicing_results, tl.event, feature='event', max_distance=100_000_000)
+
+    base_report = pd.Series({'mut_id': mut_id,
+                             'gene': m.gene,
+                             'transcript_id': reference_transcript.transcript_id,
+                             'primary_transcript': reference_transcript.primary_transcript,
+                             'splicing_engine': splicing_engine,
+                             'time_of_execution': datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
+
+    ss_metadata = ss.report(m.positions[0])
+    report = []
+    for variant_transcript, isoform_metadata in ss.get_viable_transcripts(metadata=True):
+        onco = Oncosplice(reference_transcript.protein, variant_transcript.protein, reference_transcript.cons_vector)
+        report.append(pd.concat([base_report, ss_metadata, isoform_metadata, onco.get_analysis_series()]))
+    return pd.DataFrame(report)
+
+
+def oncosplice_pipeline_all_transcripts(mut_id, splicing_engine='spliceai'):
+    m = MutationalEvent(mut_id)
+    assert m.compatible(), 'Mutations in event are incompatible'
+    reports = []
+    for transcript_id in Gene.from_file(m.gene).transcripts.keys():
+        reports.append(oncosplice_pipeline_single_transcript(mut_id, transcript_id, splicing_engine=splicing_engine))
+    return pd.concat(reports, axis=1)
+
+
+def get_tcga_annotations(mut_ids):
+    pass
+
+
+
+def generate_epitopes():
+    pass
+
+
+
+

geney/power_utils.py

@@ -5,7 +5,7 @@ from dask.distributed import Client, wait
 import os
 from tqdm import tqdm
 from pathlib import Path
-from geney import config_setup
+from geney import _config_setup
 from geney.utils import contains, available_genes
 import warnings
 import gc

geney/utils/Fasta_segment.py

@@ -0,0 +1,260 @@
+__all__ = ['Fasta_segment']
+
+import os
+import numpy as np
+
+class Fasta_segment():
+    '''
+    Efficient reads of a segments starting from a given offset
+    from a FASTA file.
+
+    ================================================================
+    This class can be used ONLY for Fasta files where ALL sequence
+    rows (excluding headers) are of the same length !!
+    ================================================================
+
+    In case of a FASTA with multiple sequences (multiple headers), the header name
+    of the corresponding sequence must be provided. The header name is the string
+    that proceeds the character ">".
+    For example, the header name ofthe header:
+
+    ">NC_000011.10 Homo sapiens chromosome 11, GRCh38.p13 Primary Assembly"
+
+    is "NC_000011.10".
+
+    In case of a FASTA with a single sequence (single header), the header name
+    is not required.
+
+    The class reads only the segment into memory and not the all FASTA sequence.
+    This can be used, for example, to read a segment from a FASTA file
+    that contains a chromosome of the human genome.
+    '''
+    def __init__(self, files_info=None) -> None:
+        '''
+        files_info (optional input) is a dictionary:
+        For a FASTA with multiple headers, the key is a fasta file name and
+        the header name as follows: "<fasta file name>:<header name>".
+        For a FASTA with a single header the key is simply the file name (the header
+        can also be provided, in which case the key will include it as well, however this is not required).
+        The value is a dictionary that contains basic statistics of the fasta file.
+        Keys of files_info[file] are:
+            'init_loc': offset of the first NT in file (0 indicated the first NT)
+            'l_size': number of NTs per line excluding \n,
+            'line_size': number of NTs per line including \n.
+            'file_size': total number of NTs in file, excluding \n (and excluding the header). This is
+                         available only for FASTA files with a single header.
+
+            For example: files_info = {'file1.fas': {'init_loc': 70, 'l_size': 80, 'line_size': 81, 'file_size': 240},
+                               'file2.fas:NC_000011.10': {'init_loc': 70, 'l_size': 80, 'line_size': 81}}
+
+        '''
+        self.files_info = files_info if files_info else {}
+
+    def __repr__(self) -> str:
+        return f"Fasta_segment([files_info])"
+
+    def __str__(self) -> str:
+        return f"Efficient reads of segments from FASTA files.\n"
+
+    def __len__(self) -> int:
+        return len(self.files_info)
+
+    def show_processed_files(self) -> list:
+        return list(self.files_info.keys())
+
+    def show_files_info(self) -> None:
+        print(self.str_files_info())
+
+    def str_files_info(self) -> str:
+        s = ''
+        for k in self.files_info.keys():
+            s += f"{k}:\n"
+            for ki, vi in self.files_info[k].items():
+                s += f"\t{ki}: {vi}\n"
+
+        return s
+
+    def read_segment(self, file: str, offset: int, size: int) -> str:
+        '''
+        Reads a segment from a FASTA with a single sequence (single header).
+        file - FASTA file name
+        offset - 0 based offset of the start segment in file (from the first sequence NT).
+                 For example, value of 1 indicates starting from the second NT in the file.
+        size - number of NTs in a segment to read.
+        '''
+        if not os.path.exists(file):
+            print(f"Error: file {file} does not exists !!")
+            return ""
+
+        with open(file, 'rt') as fp:
+            if file in self.files_info:
+                l_size = self.files_info[file]['l_size']
+                line_size = self.files_info[file]['line_size']
+                init_loc = self.files_info[file]['init_loc']
+            else:
+                init_loc, line_size, l_size = self.__compute_file_stats(fp)
+                self.files_info[file] = {'init_loc': init_loc, 'l_size': l_size, 'line_size': line_size}
+
+            offset_num_lines, offset_in_line = offset // l_size, np.mod(offset, l_size)
+            # accounting for extra characters due to multiple \n that will be discarded
+            add_for_newline = ((offset + size -1) // l_size) - offset_num_lines
+            fp.seek(init_loc + offset_num_lines *line_size + offset_in_line)
+            return fp.read(size + add_for_newline).replace('\n', '')
+
+    def read_segment_endpoints(self, file: str, start_loc: int, end_loc: int):
+        seq = Fasta_segment().read_segment(file, start_loc - 1, end_loc - start_loc + 1).upper()
+        # indices = list(range(start_loc, end_loc + 1))
+        indices = np.arange(start_loc, end_loc + 1)
+        assert len(seq) == len(
+            indices), f'reference data not compatible; {len(seq)}, {len(indices)}, start: {start_loc}, end: {end_loc}, {file}'
+        return {"nucleotides": seq, "index": indices}
+
+    def __compute_file_stats(self, fp) -> tuple:
+        '''
+        Computs the stats that are needed to read a segment from
+        a FASTA file with a single sequence.
+        '''
+        # account for a header (if exists) in the first line of the file
+        fp.seek(0, os.SEEK_SET)
+        if fp.read(1) == ">":
+            fp.readline()
+            init_loc = fp.tell()
+        else:
+            init_loc = 0
+
+        # init_loc is the location (0-based) of the first NT in file
+        fp.seek(init_loc)
+        fp.readline()  # advance handle to begining of second line
+        line_size = fp.tell() - init_loc # number of NTs per line, including the \n
+        return init_loc, line_size, line_size -1
+
+
+    def total_num_chars(self, file: str) -> int:
+        '''
+        Returns the total number of characters (NTs) in a FASTA
+        file (excluding the header and \n) without reading the all file.
+
+        This function supports only Fasta with a single headr.
+        Support for FASTAs with multiple headers is TBD.
+        '''
+        if file in self.files_info:
+            return self.files_info[file]['file_size']
+        else:
+            return self.__compute_total_num_NTs(file)
+
+
+    def __compute_total_num_NTs(self, file: str) -> int:
+        '''
+        Computes the total number of characters (NTs) in a FASTA
+        file (excluding the header and \n) and updates self.files_info.
+        '''
+        with open(file, 'rt') as fp:
+            init_loc, line_size, l_size = self.__compute_file_stats(fp)
+
+            # check if last character is new line
+            last_loc = fp.seek(0, os.SEEK_END)
+            fp.seek(fp.tell() - 1, os.SEEK_SET)
+            last_char = fp.read()
+
+        delta = last_loc -init_loc
+        q, r = divmod(delta, line_size)
+        num_chars = delta - q # remove counts of new lines
+        if q== 1 and r == 0 and (last_char != '\n'):
+            num_chars += 1  # if only one line in file and last character is not newline add one
+
+        self.files_info[file] = {'init_loc': init_loc,
+                                 'l_size': l_size,
+                                 'line_size': line_size,
+                                 'file_size': num_chars}
+
+        return num_chars
+
+    def multiple_headers_read_segment(self, file: str, header_name: str, offset: int, size: int) -> str:
+        '''
+        Reades from a FASTA with multiple sequences (multiple headers).
+        The offset and size here are relative to the sequence with header name header_name.
+
+        For example, for header_name='name1', offset=3, size=4, the return sequence is of size 4 NTs, starting
+        from offset 3 of the sequence that follows the header with header name header_name.
+        '''
+        init_loc = None
+        token = file + ':' + header_name
+        with open(file, 'rt') as fp:
+            if token in self.files_info:
+                l_size = self.files_info[token]['l_size']
+                line_size = self.files_info[token]['line_size']
+                init_loc = self.files_info[token]['init_loc']
+            else:
+                line = fp.readline()
+                while line:
+                    if line[0] == '>':
+                        # header name
+                        name = line.split()[0][1:]
+                        if name == header_name:
+                            init_loc = fp.tell()  # file offset of the first NT of the corresponding sequence
+                            break
+
+                    line = fp.readline()
+
+                if init_loc is None:
+                    print(f"Did not find header name {header_name} in file {file} !!")
+                    return ''
+                else:
+                    fp.seek(init_loc)
+                    fp.readline()
+                    line_size = fp.tell() - init_loc
+                    l_size = line_size - 1
+                    self.files_info[token] = {'init_loc': init_loc, 'l_size': l_size, 'line_size': line_size}
+
+            offset_num_lines, offset_in_line = offset // l_size, np.mod(offset, l_size)
+            # accounting for extra characters due to multiple \n that will be discarded
+            add_for_newline = ((offset + size - 1) // l_size) - offset_num_lines
+            fp.seek(init_loc + offset_num_lines * line_size + offset_in_line)
+            return fp.read(size + add_for_newline).replace('\n', '')
+
+    def fasta_gen(self, file: str, segment_size: int, init_offset: int = 0, jump_size: int = 0) -> str:
+        '''
+        Fasta generator.
+        Returns an iterator for reading segments of size segment_size NTs, separated by
+        jump_size NTs, starting from an offset (0-based) init_offset.
+
+        To read segments consecutively, set jump_size to 0 (which is the default value).
+        '''
+        try:
+            with open(file, 'rt') as fp:
+                # handeling the header
+                fp.seek(0, os.SEEK_SET)
+                if fp.read(1) == ">":
+                    fp.readline()
+                    init_loc = fp.tell()
+                else:
+                    init_loc = 0
+
+                # computing number of characters (including \n) per line
+                fp.seek(init_loc)
+                fp.readline()
+                line_size = fp.tell() - init_loc  # number of NTs per line, including the \n
+                ext_newlines = segment_size // line_size  # number of \n in a segment_size read with offset 0
+                jump_newlines = jump_size // line_size  # same for jump_size
+
+                # starting from init_offset (accounting for \n)
+                fp.seek(init_loc + init_offset + (init_offset // line_size))
+
+                while True:
+                    segment = fp.read(segment_size + ext_newlines).replace('\n', '')
+                    # might need another single read as ext_newlines assumed reading from beginning of the line
+                    if len(segment) < segment_size:
+                        segment += fp.read(1).replace('\n', '')
+
+                    if segment != '':
+                        yield segment.replace('\n', '')
+                    else:
+                        break  # raise StopIteration
+
+                    # jump to next segment (the jump is excluding \n)
+                    if fp.read(jump_size + jump_newlines).count('\n') > jump_newlines:
+                        fp.seek(fp.tell() + 1)
+
+        except IOError as err:
+            print(f"Error: {file} not found !! ({err})")
+