geney 1.2.54__py2.py3-none-any.whl → 1.2.56__py2.py3-none-any.whl

geney/oncosplice.py

@@ -9,7 +9,6 @@ from .seqmat_utils import *
 from .mutation_utils import *
 from .tis_utils import find_tis
 
-### Scoring
 def find_continuous_gaps(sequence):
     """Find continuous gap sequences in an alignment."""
     return [(m.start(), m.end()) for m in re.finditer(r'-+', sequence)]
@@ -121,43 +120,6 @@ def transform_conservation_vector(conservation_vector, window=13, factor=4):
     return exp_factors
 
 
-# def find_modified_positions(sequence_length, deletions, insertions, reach_limit=16):
-#     """
-#     Identify unmodified positions in a sequence given deletions and insertions.
-#
-#     :param sequence_length: Length of the sequence.
-#     :param deletions: Dictionary of deletions.
-#     :param insertions: Dictionary of insertions.
-#     :param reach_limit: Limit for considering the effect of insertions/deletions.
-#     :return: Array indicating unmodified positions.
-#     """
-#     unmodified_positions = np.zeros(sequence_length, dtype=float)
-#
-#     for pos, insertion in insertions.items():
-#         # if pos >= sequence_length:
-#         #     pos = sequence_length - 1
-#         #     add_factor = 1
-#
-#         reach = min(len(insertion) // 2, reach_limit)
-#         front_end, back_end = max(0, pos - reach), min(sequence_length - 1, pos + reach)
-#         len_start, len_end = pos - front_end, back_end - pos
-#         try:
-#             gradient_front = np.linspace(0, 1, len_start, endpoint=False)
-#             gradient_back = np.linspace(0, 1, len_end, endpoint=True)[::-1]
-#             combined_gradient = np.concatenate([gradient_front, np.array([1]), gradient_back])
-#             unmodified_positions[front_end:back_end + 1] = combined_gradient
-#
-#         except ValueError as e:
-#             print(
-#                 f"Error: {e} | Lengths: unmodified_positions_slice={back_end - front_end}.")
-#             unmodified_positions[front_end:back_end] = np.zeros(back_end - front_end)
-#
-#     for pos, deletion in deletions.items():
-#         deletion_length = len(deletion)
-#         unmodified_positions[pos:pos + deletion_length] = 1
-#
-#     return unmodified_positions
-
 def find_modified_positions(sequence_length, deletions, insertions, reach_limit=16):
     """
     Identify unmodified positions in a sequence given deletions and insertions.
@@ -251,12 +213,7 @@ def moving_average_conv(vector, window_size, factor=1):
 
     return np.convolve(vector, np.ones(window_size), mode='same') / window_size
 
-
-
-
-
 def find_splice_site_proximity(pos, transcript):
-
     for i, (ex_start, ex_end) in enumerate(transcript.exons):
         if min(ex_start, ex_end) <= pos <= max(ex_start, ex_end):
             return i + 1, None, abs(pos - ex_start), abs(pos - ex_end)
@@ -323,7 +280,7 @@ def summarize_missplicing_event(pes, pir, es, ne, ir):
 
 # Annotating
 def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
-    affected_exon, affected_intron, distance_from_5, distance_from_3 = find_splice_site_proximity(mut.indices[0],
+    affected_exon, affected_intron, distance_from_5, distance_from_3 = find_splice_site_proximity(np.floor(mut.indices[0]),
                                                                                                   reference_transcript)
 
     report = {}
@@ -361,19 +318,17 @@ def OncospliceAnnotator(reference_transcript, variant_transcript, mut):
     return report
 
 
-def oncosplice(mut_id, splicing_threshold=0.5, protein_coding=True, primary_transcript=False, window_length=13, organism='hg38', engine='spliceai', domains=None):
+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('|')]
 
     results = []
     for tid, transcript in gene.run_transcripts(protein_coding=protein_coding, primary_transcript=primary_transcript):
-        if not transcript.cons_available:
+        if cons_required and not transcript.cons_available:
             continue
 
         if all(mutation not in transcript for mutation in mutations):
-            results.append({'transcript_id': transcript.transcript_id})
             continue
 
         transcript.generate_pre_mrna()
@@ -413,15 +368,15 @@ def oncosplice(mut_id, splicing_threshold=0.5, protein_coding=True, primary_tran
             report['reference_resemblance'] = reference_gene_proteins.get(transcript.protein, None)
             results.append(report)
 
-    report = pd.DataFrame(results)
-    return report
-
+    if len(results) == 0:
+        return None
 
-import asyncio
+    return pd.DataFrame(results)
 
 
+import asyncio
 async def oncosplice_prototype(mut_id, splicing_threshold=0.5, protein_coding=True, primary_transcript=False,
-                               window_length=13, organism='hg38', engine='spliceai', use_cons=True):
+                               window_length=13, organism='hg38', engine='spliceai', use_cons=True, require_cons=False):
     import sys, os
     needed_file1 = config[organism]['yoram_path'] / 'rest_api_utils.py'
     needed_file2 = config[organism]['yoram_path'] / 'uniprot_utils.py'
@@ -452,20 +407,17 @@ async def oncosplice_prototype(mut_id, splicing_threshold=0.5, protein_coding=Tr
 
     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(mut_id, rev=gene.rev) for mut_id in mut_id.split('|')]
-
     results = []
     for tid, transcript in gene.run_transcripts(protein_coding=protein_coding, primary_transcript=primary_transcript):
-        if not transcript.cons_available:
+        if require_cons and not transcript.cons_available:
             continue
 
         if all(mutation not in transcript for mutation in mutations):
-            results.append({'transcript_id': transcript.transcript_id})
+            # results.append({'transcript_id': transcript.transcript_id})
             continue
 
         task1 = asyncio.create_task(background_request(tid))
-
         transcript.generate_pre_mrna()
         transcript.cons_vector = transform_conservation_vector(transcript.cons_vector, window=window_length)
         transcript.generate_mature_mrna().generate_protein(inplace=True)
@@ -475,7 +427,7 @@ async def oncosplice_prototype(mut_id, splicing_threshold=0.5, protein_coding=Tr
             cons_vector = np.ones(len(ref_protein))
 
         if sum(cons_vector) == 0:
-            cons_vector = np.ones(len(ref_protein))/len(ref_protein)
+            cons_vector = np.ones(len(ref_protein)) #/len(ref_protein)
 
         reference_transcript = copy.deepcopy(transcript)
 

geney/pangolin_utils.py

@@ -52,12 +52,10 @@ def pangolin_predict_probs(true_seq, models):
     model_nums = [0, 1, 2, 3, 4, 5, 6]
     INDEX_MAP = {0: 1, 1: 2, 2: 4, 3: 5, 4: 7, 5: 8, 6: 10, 7: 11}
 
-    # seq = 'N'*5000 + true_seq + 'N'*5000
     seq = true_seq
     true_seq = true_seq[5000:-5000]
-    acceptor_dinucleotide = np.array([true_seq[i - 2:i] == 'AG' for i in range(len(true_seq))])
-    # donor_dinucleotide = np.array([true_seq[i + 1:i + 3] == 'GT' for i in range(len(true_seq))])
-    donor_dinucleotide = np.array([true_seq[i -2:i] == 'GT' for i in range(len(true_seq))])
+    acceptor_dinucleotide = np.array([true_seq[i - 2:i] == 'AG' for i in range(len(true_seq))]) # np.ones(len(true_seq)) #
+    donor_dinucleotide = np.array([true_seq[i+1:i+3] == 'GT' for i in range(len(true_seq))]) #np.ones(len(true_seq)) #
 
     seq = pang_one_hot_encode(seq).T
     seq = torch.from_numpy(np.expand_dims(seq, axis=0)).float()
@@ -78,4 +76,4 @@ def pangolin_predict_probs(true_seq, models):
     splicing_pred = np.array(scores).max(axis=0)
     donor_probs = [splicing_pred[i] * donor_dinucleotide[i] for i in range(len(true_seq))]
     acceptor_probs = [splicing_pred[i] * acceptor_dinucleotide[i] for i in range(len(true_seq))]
-    return donor_probs, acceptor_probs
+    return donor_probs, acceptor_probs

geney/spliceai_utils.py

@@ -12,8 +12,8 @@ if tf.config.list_physical_devices('GPU'):
 else:
     print("Running on CPU.")
 
-# tf.config.threading.set_intra_op_parallelism_threads(1)
-# tf.config.threading.set_inter_op_parallelism_threads(1)
+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]

geney/splicing_utils.py

@@ -1,128 +1,125 @@
-import networkx as nx
 import numpy as np
 from .mutation_utils import get_mutation
 from .seqmat_utils import Gene
 
-
-class SpliceSite:
-    def __init__(self, pos, ss_type, prob):
-        self.pos = pos
-        self.ss_type = ss_type  # 0 for donors, 1 for acceptors
-        self.prob = prob
-
-class SpliceSiteFactory:
-    @staticmethod
-    def create_splice_site(pos, ss_type, prob):
-        return SpliceSite(pos, ss_type, prob)
-
-def compute_paths_sequential(G, transcript, exon_starts, exon_ends):
-    """
-    Compute paths from start to end and from end to start sequentially, then return the paths with their probabilities.
-    """
-    new_paths = {}
-    prob_sum = 0
-
-    # Combine paths in both directions
-    all_paths = list(nx.all_simple_paths(G, transcript.transcript_start, transcript.transcript_end)) + \
-                list(nx.all_simple_paths(G, transcript.transcript_end, transcript.transcript_start))
-
-    # Compute the probabilities of each path sequentially
-    path_probs = [path_weight_mult(G, path, 'weight') for path in all_paths]
-
-    # Populate new_paths dictionary with computed paths and probabilities
-    for i, (path, curr_prob) in enumerate(zip(all_paths, path_probs)):
-        prob_sum += curr_prob
-        new_paths[i] = {
-            'acceptors': sorted([p for p in path if p in exon_starts and p != transcript.transcript_start], reverse=transcript.rev),
-            'donors': sorted([p for p in path if p in exon_ends and p != transcript.transcript_end], reverse=transcript.rev),
-            'path_weight': curr_prob
-        }
-    return new_paths, prob_sum
+from collections import defaultdict
+
+
+def generate_adjacency_list(acceptors, donors, transcript_start, transcript_end, max_distance=50, rev=False):
+    # Append the transcript end to donors to allow connection to the end point
+    donors.append((transcript_end, 1))
+    acceptors = sorted(acceptors, key=lambda x: (x[0], x[1] if not rev else -x[1]), reverse=rev)
+    donors = sorted(donors, key=lambda x: (x[0], x[1] if not rev else -x[1]), reverse=rev)
+
+    # Initialize adjacency list to store downstream connections
+    adjacency_list = defaultdict(list)
+
+    # Connect each donor to the nearest acceptor(s) within the distance threshold
+    for d_pos, d_prob in donors:
+        running_prob = 1
+        for a_pos, a_prob in acceptors:
+            correct_orientation = (a_pos > d_pos and not rev) or (a_pos < d_pos and rev)
+            distance_valid = abs(a_pos - d_pos) <= max_distance
+            if correct_orientation and distance_valid:
+                in_between_acceptors = sum([d_pos < a < a_pos for a, _ in acceptors]) if not rev else sum([a_pos < a < d_pos for a, _ in acceptors])
+                in_between_donors = sum([d_pos < d < a_pos for d, _ in donors]) if not rev else sum([a_pos < d < d_pos for d, _ in donors])
+                in_between_naturals = 0
+                if in_between_donors == 0 or in_between_acceptors == 0:
+                    adjacency_list[(d_pos, 'donor')].append((a_pos, 'acceptor', a_prob))
+                    running_prob -= a_prob
+
+                else:
+                    if running_prob > 0:
+                        adjacency_list[(d_pos, 'donor')].append((a_pos, 'acceptor', a_prob*running_prob))
+                        running_prob -= a_prob
+                    else:
+                        break
+
+    # Connect each acceptor to the nearest donor(s) within the distance threshold
+    for a_pos, a_prob in acceptors:
+        running_prob = 1
+        for d_pos, d_prob in donors:
+            correct_orientation = (d_pos > a_pos and not rev) or (d_pos < a_pos and rev)
+            distance_valid = abs(d_pos - a_pos) <= max_distance
+            if correct_orientation and distance_valid:
+                in_between_acceptors = sum([a_pos < a < d_pos for a, _ in acceptors]) if not rev else sum([d_pos < a < a_pos for a, _ in acceptors])
+                in_between_donors = sum([a_pos < d < d_pos for d, _ in donors]) if not rev else sum([d_pos < d < a_pos for d, _ in donors])
+                in_between_naturals = 0
+                tag = 'donor' if d_pos != transcript_end else 'transcript_end'
+
+                if in_between_acceptors == 0:
+                    adjacency_list[(a_pos, 'acceptor')].append((d_pos, tag, d_prob))
+                    running_prob -= d_prob
+                else:
+                    if running_prob > 0:
+                        adjacency_list[(a_pos, 'acceptor')].append((d_pos, tag, d_prob*running_prob))
+                        running_prob -= d_prob
+                    else:
+                        break
+
+    # Connect the transcript start to the nearest donor(s) within the distance threshold
+    running_prob = 1
+    for d_pos, d_prob in donors:
+        if ((d_pos > transcript_start and not rev) or (d_pos < transcript_start and rev)) and abs(
+                d_pos - transcript_start) <= max_distance:
+            adjacency_list[(transcript_start, 'transcript_start')].append((d_pos, 'donor', d_prob))
+            running_prob -= d_prob
+            if running_prob <= 0:
+                break
+
+    # Normalize probabilities to ensure they sum up to 1 for each list of connections
+    for k, next_nodes in adjacency_list.items():
+        prob_sum = sum([c for a, b, c in next_nodes])
+        adjacency_list[k] = [(a, b, round(c / prob_sum, 3)) for a, b, c in next_nodes] if prob_sum > 0 else next_nodes
+
+    return adjacency_list
+
+
+def find_all_paths(graph, start, end, path=[], probability=1.0):
+    path = path + [start]  # Add current node to the path
+    if start == end:
+        yield path, probability  # If end is reached, yield the path and its cumulative probability
+        return
+    if start not in graph:
+        return  # If the start node has no outgoing edges, return
+
+    for (next_node, node_type, prob) in graph[start]:
+        # Recur for each connected node, updating the probability
+        yield from find_all_paths(graph, (next_node, node_type), end, path, probability * prob)
+
+
+def prepare_splice_sites(acceptors, donors, aberrant_splicing):
+    acceptors = {p: 1 for p in acceptors}
+    donors = {p: 1 for p in donors}
+
+    for p, v in aberrant_splicing[f'missed_donors'].items():
+        donors[p] = v['absolute']
+
+    for p, v in aberrant_splicing[f'discovered_donors'].items():
+        donors[p] = v['absolute']
+
+    for p, v in aberrant_splicing[f'missed_acceptors'].items():
+        acceptors[p] = v['absolute']
+
+    for p, v in aberrant_splicing[f'discovered_acceptors'].items():
+        acceptors[p] = v['absolute']
+
+    acceptors = {int(k): v for k, v in acceptors.items()}
+    donors = {int(k): v for k, v in donors.items()}
+    return list(acceptors.items()), list(donors.items())
 
 
 def develop_aberrant_splicing(transcript, aberrant_splicing):
-    # Prepare exon start and end dictionaries
-    exon_starts = prepare_splice_sites(transcript.acceptors, transcript.transcript_start, aberrant_splicing, 'acceptors')
-    exon_ends = prepare_splice_sites(transcript.donors, transcript.transcript_end, aberrant_splicing, 'donors')
-
-    # Create SpliceSite nodes and filter based on probability > 0
-    nodes = [
-        SpliceSiteFactory.create_splice_site(pos, 0, prob) for pos, prob in exon_ends.items()
-    ] + [
-        SpliceSiteFactory.create_splice_site(pos, 1, prob) for pos, prob in exon_starts.items()
-    ]
-    nodes = [s for s in nodes if s.prob > 0]
-
-    # Sort nodes based on position, respecting transcript direction
-    nodes.sort(key=lambda x: x.pos, reverse=transcript.rev)
-
-    # Create the directed graph
-    G = create_splice_graph(nodes, transcript.rev)
-
-    # Compute new paths and their probabilities sequentially
-    new_paths, prob_sum = compute_paths_sequential(G, transcript, exon_starts, exon_ends)
-
-    # Normalize probabilities and filter based on threshold
-    new_paths = normalize_and_filter_paths(new_paths, prob_sum)
-
-    return list(new_paths.values())
-
-
-def prepare_splice_sites(transcript_sites, transcript_boundary, aberrant_splicing, site_type):
-    """
-    Prepare and return a dictionary of splice sites (acceptors or donors) including transcript boundaries
-    and aberrant splicing information.
-    """
-    site_dict = {v: 1 for v in transcript_sites}
-    site_dict.update({transcript_boundary: 1})
-    site_dict.update({s: v['absolute'] for s, v in aberrant_splicing[f'missed_{site_type}'].items()})
-    site_dict.update({s: v['absolute'] for s, v in aberrant_splicing[f'discovered_{site_type}'].items()})
-    return site_dict
-
-
-def create_splice_graph(nodes, reverse_direction):
-    """
-    Create and return a directed graph with splice sites as nodes and edges based on splice site type
-    and probability of occurrence.
-    """
-    G = nx.DiGraph()
-    G.add_nodes_from([n.pos for n in nodes])
-
-    for i in range(len(nodes)):
-        trailing_prob = 0
-        in_between = set()
-        curr_node = nodes[i]
-
-        for j in range(i + 1, len(nodes)):
-            next_node = nodes[j]
-            in_between.add(next_node.ss_type)
-
-            if curr_node.ss_type != next_node.ss_type:
-                new_prob = next_node.prob - trailing_prob
-                if new_prob > 0:
-                    G.add_edge(curr_node.pos, next_node.pos, weight=new_prob)
-                    trailing_prob += next_node.prob
-    return G
-
-
-def normalize_and_filter_paths(new_paths, prob_sum):
-    """
-    Normalize path probabilities and filter out paths with a probability less than 0.01.
-    """
-    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.00001}
-    return new_paths
-
-
-def path_weight_mult(G, path, weight):
-    """
-    Calculate the multiplicative weight of the path.
-    """
-    cost = 1
-    for node, nbr in zip(path[:-1], path[1:]):
-        cost *= G[node][nbr][weight]
-    return cost
+    all_acceptors, all_donors = prepare_splice_sites(transcript.acceptors, transcript.donors, aberrant_splicing)
+    adj_list = generate_adjacency_list(all_acceptors, all_donors, transcript_start=transcript.transcript_start,
+                                       transcript_end=transcript.transcript_end, rev=transcript.rev,
+                                       max_distance=100000)
+    end_node = (transcript.transcript_end, 'transcript_end')
+    start_node = (transcript.transcript_start, 'transcript_start')
+    for path, prob in find_all_paths(adj_list, start_node, end_node):
+        yield {'acceptors': [p[0] for p in path if p[1] == 'acceptor'],
+               'donors': [p[0] for p in path if p[1] == 'donor'], 'path_weight': prob}
+
 
 
 # Missplicing Detection

geney/tis_utils.py

@@ -28,26 +28,13 @@ def find_tis(ref_seq, mut_seq, left_context=100, right_context=102):
                                                                                                 right_context=right_context,
                                                                                                 padding='$')
 
-        # 3. If condition 2 is not met, we perform a TIS reaquisition. If condition 2 is met, then we return the reference TIS to be used in the mutated sequence
     if context_conserved:
-        return tis_coords[0]
-
-    # 4. Reaquisition of TIS follows:
-    #### The logic:
-    #  a. We need to find all possible start codon candidates as relative indices
-    #  b. We need to find what proteins each alternative start codon would create
-    #  c. We need to make sure we are only looking at a region around a mutation
-    #  d. We need the titer score rank relative to all titer score reference ranks and relative to the reference score
+        return [(tis_coords[0], 1, 'canonical')]
 
     sc_table = pd.read_pickle(config['titer_path'] / 'titer_tis_scores.pickle')
-    # target_transcript = sc_table[sc_table.transcript_id == ref_id]
-    # if len(target_transcript) == 0:
-    ### reaquire TIS score for ref
-    # pass
-
     ref_seq_tis_context = ref_seq.asymmetric_subseq(tis_coords[0], left_context=left_context,
                                                     right_context=right_context, padding='$')
-    # target_ref_titer_score = target_transcript.tis_score
+
     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])
@@ -56,7 +43,8 @@ def find_tis(ref_seq, mut_seq, left_context=100, right_context=102):
     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]
+
+    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
@@ -66,7 +54,7 @@ def find_tis(ref_seq, mut_seq, left_context=100, right_context=102):
          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
+    return out  #output: [(genomic_coord1, probability, filter_tag), (genomic_coord2, probability, filter_tag)]
 
 
 def seq_matrix(seq_list):

{geney-1.2.54.dist-info → geney-1.2.56.dist-info}/METADATA

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

{geney-1.2.54.dist-info → geney-1.2.56.dist-info}/RECORD

@@ -6,21 +6,21 @@ 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=hPmB9sEPs9lr22BlPGKpQUOd59vUjAttXZ6QKf4A-kg,23534
-geney/pangolin_utils.py,sha256=rVi_U23nhw6wCc44fBeD3sv-FshLTGE1UMMtIYwgr9U,2967
+geney/oncosplice.py,sha256=eWgY2Lcj894UBFnIVhbxiVz5oqASHg-Ot1wFbjlJbI8,21857
+geney/pangolin_utils.py,sha256=NJEdY43L_2lielY1hZOjlak0baHqXTa1ITrvx8Tkg5o,2878
 geney/power_utils.py,sha256=MehZFUdkJ2EFUot709yPEDxSkXmH5XevMebX2HD768A,7330
 geney/seqmat_utils.py,sha256=2cRXT_Ox4IdzCM8x3H2HexxFZzjo5WHs0HZiUQv8fBM,18347
-geney/spliceai_utils.py,sha256=gIGPC8u3J15A7EQrk2Elho5PbF9MmUUNopGGH-eEV8s,1873
-geney/splicing_utils.py,sha256=8qbj81ESNxu9-clEjBV-2xj41p1Wly6NFiGlm0etSeg,15564
+geney/spliceai_utils.py,sha256=21_TaiLW3faRuPegMgsVvIf1G1a03penZSiydQ-hOTA,1869
+geney/splicing_utils.py,sha256=t0vE5KTAdYOYJLa9wjaSJ1jqiHhsDxZs64OxrgR-Sqc,16811
 geney/survival_utils.py,sha256=KnAzEviMuXh6SnVXId9PgsFLSbgkduTvYoIthxN7FPA,6886
 geney/tcga_utils.py,sha256=D_BNHm-D_K408dlcJm3hzH2c6QNFjQsKvUcOPiQRk7g,17612
-geney/tis_utils.py,sha256=vA2ci4gNfwwQZlCjPpO5ehvL2NRVeM7lHI_VyfT-_10,8049
+geney/tis_utils.py,sha256=2makfGfVlDFVIbxzXE85AY9jmAjcNmxyIAxjvkRA5LY,7396
 geney/utils.py,sha256=EsKvBM-Nz2a3_4ZAhF4Dxd4PwT7_6YYKpxEN4LLgg10,2174
 geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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.54.dist-info/METADATA,sha256=C4gCBwzsS6uD4ZqO1lE5Me2BAldGdvBk50hQkp5C528,948
-geney-1.2.54.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
-geney-1.2.54.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.2.54.dist-info/RECORD,,
+geney-1.2.56.dist-info/METADATA,sha256=tHCFJyD9OKjk7GnQToKesLQZyzy0dtO9oBsr0Bjz6rI,948
+geney-1.2.56.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+geney-1.2.56.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.2.56.dist-info/RECORD,,