geney 1.2.22__py2.py3-none-any.whl → 1.2.24__py2.py3-none-any.whl

geney/splicing_utils.py

@@ -0,0 +1,372 @@
+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
+
+
+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
+
+
+# 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 find_transcript_missplicing(transcript, mutation, context=5000, window=2500, threshold=0.5, engine='spliceai'):
+    ref = transcript.pre_mrna
+    var = ref + mutation
+
+    # print(len(ref.indices))
+    # print(len(var.indices))
+
+
+    center = mutation.position
+    total_context = context + window
+
+    length = ref.seqmat.shape[-1]
+    center_index = ref.rel_pos(center)
+    ref_start_pad = max(0, total_context - center_index)
+    ref_end_pad = max(0, total_context - (length - center_index))
+
+    length = var.seqmat.shape[-1]
+    center_index = var.rel_pos(center)
+    var_start_pad = max(0, total_context - center_index)
+    var_end_pad = max(0, total_context - (length - center_index))
+
+    ref = ref.inspect(center, context=total_context)
+    var = var.inspect(center, context=total_context)
+    #
+    # ref_indices = np.concatenate([np.zeros(ref_start_pad), ref.inspect(center, context = window).indices, np.zeros(ref_end_pad)])
+    # mut_indices = np.concatenate([np.zeros(var_start_pad), var.inspect(center, context = window).indices, np.zeros(var_end_pad)])
+
+    ref_indices = np.concatenate([np.zeros(ref_start_pad), ref.indices, np.zeros(ref_end_pad)])
+    mut_indices = np.concatenate([np.zeros(var_start_pad),  var.indices, np.zeros(var_end_pad)])
+
+    ref_indices = ref_indices[context:-context]
+    mut_indices = mut_indices[context:-context]
+
+    ref_seq = 'N'*ref_start_pad + ref.seq + 'N'*ref_end_pad
+    var_seq = 'N'*var_start_pad + var.seq + 'N'*var_end_pad
+
+    # print(f"PAdding: {ref_start_pad}, {ref_end_pad}")
+    if engine == 'spliceai':
+        from .spliceai_utils import sai_predict_probs, sai_models
+        ref_seq_acceptor_probs, ref_seq_donor_probs = sai_predict_probs(ref_seq, models=sai_models)
+        mut_seq_acceptor_probs, mut_seq_donor_probs = sai_predict_probs(var_seq, models=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, :]
+
+    elif engine == 'pangolin':
+        from .pangolin_utils import pangolin_predict_probs, pang_models
+        ref_seq_donor_probs, ref_seq_acceptor_probs = pangolin_predict_probs(ref_seq, models=pang_models)
+        mut_seq_donor_probs, mut_seq_acceptor_probs = pangolin_predict_probs(var_seq, models=pang_models)
+
+    else:
+        raise ValueError(f"{engine} not implemented")
+
+    visible_donors = np.intersect1d(transcript.donors, ref_indices)
+    visible_acceptors = np.intersect1d(transcript.acceptors, ref_indices)
+
+    assert len(ref_indices) == len(ref_seq_acceptor_probs), f'Reference pos ({len(ref_indices)}) not the same as probs ({len(ref_seq_acceptor_probs)})'
+    assert len(mut_indices) == len(mut_seq_acceptor_probs), f'Mut pos ({len(mut_indices)}) not the same as probs ({len(mut_seq_acceptor_probs)})'
+
+    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=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=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()}
+    temp =  {outk: {int(k) if k.is_integer() else k: v for k, v in outv.items()} for outk, outv in missplicing.items()}
+    return temp
+
+
+class Missplicing:
+    def __init__(self, splicing_dict, threshold=0.5):
+        self.missplicing = splicing_dict
+        self.threshold = threshold
+
+    # def __repr__(self):
+    #     return f'Missplicing({self.modification.mut_id}) --> {self.missplicing}'
+
+    def __str__(self):
+        return self.aberrant_splicing
+
+    def __bool__(self):
+        if self.apply_sai_threshold_alt() is not None:
+            return True
+        return False
+
+    def __iter__(self):
+        vals = [0]
+        for event, details in self.missplicing.items():
+            for e, d in details.items():
+                vals.append(d['delta'])
+        return iter(vals)
+
+    # def __eq__(self, alt_splicing):
+    #     flag, _ = self.check_splicing_difference(self.missplicing, alt_splicing, self.threshold)
+    #     return not flag
+
+    @property
+    def aberrant_splicing(self):
+        return self.apply_sai_threshold(self.threshold)
+
+    def apply_sai_threshold(self, threshold=None):
+        splicing_dict = self.missplicing
+        if not threshold:
+            threshold = self.threshold
+
+        new_dict = {}
+        for event, details in self.missplicing.items():
+            in_dict = {}
+            for e, d in details.items():
+                if abs(d['delta']) >= threshold:
+                    in_dict[e] = d
+                    # return splicing_dict
+            new_dict[event] = in_dict
+        return new_dict
+
+    def apply_sai_threshold_alt(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
+        for event, details in splicing_dict.items():
+            for e, d in details.items():
+                if abs(d['delta']) >= threshold:
+                    return splicing_dict
+        return None
+
+    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 find_transcript_splicing(transcript, engine='spliceai'):
+    ref = transcript.pre_mrna
+    ref_start_pad = 5000
+    ref_end_pad = 5000
+
+    ref_indices = ref.indices
+    ref_seq = 'N' * ref_start_pad + ref.seq + 'N' * ref_end_pad
+    if engine == 'spliceai':
+        from .spliceai_utils import sai_predict_probs, sai_models
+        ref_seq_acceptor_probs, ref_seq_donor_probs = sai_predict_probs(ref_seq, sai_models)
+
+    elif engine == 'pangolin':
+        from .pangolin_utils import pangolin_predict_probs, pang_models
+        ref_seq_donor_probs, ref_seq_acceptor_probs = pangolin_predict_probs(ref_seq, models=pang_models)
+
+    else:
+        raise ValueError(f"{engine} not implemented")
+
+    assert len(ref_seq_donor_probs) == len(ref_indices), f'{len(ref_seq_donor_probs)}  vs. {len(ref_indices)}'
+    donor_probs = {i: p for i, p in list(zip(ref_indices, ref_seq_donor_probs))}
+    donor_probs = dict(sorted(donor_probs.items(), key=lambda item: item[1], reverse=True))
+
+    acceptor_probs = {i: p for i, p in list(zip(ref_indices, ref_seq_acceptor_probs))}
+    acceptor_probs = dict(sorted(acceptor_probs.items(), key=lambda item: item[1], reverse=True))
+    return donor_probs, acceptor_probs
+
+
+def benchmark_splicing(gene, organism='hg38', engine='spliceai'):
+    gene = Gene(gene, organism=organism)
+    transcript = gene.transcript()
+    if len(transcript.introns) == 0:
+        return None, None
+
+    transcript.generate_pre_mrna()
+    predicted_donor_sites, predicted_acceptor_sites = find_transcript_splicing(transcript, engine=engine)
+    num_introns = len(transcript.introns)
+    predicted_donors = list(predicted_donor_sites.keys())[:num_introns]
+    predicted_acceptors = list(predicted_acceptor_sites.keys())[:num_introns]
+    correct_donor_preds = [v for v in predicted_donors if v in transcript.donors]
+    correct_acceptor_preds = [v for v in predicted_acceptors if v in transcript.acceptors]
+    return len(correct_donor_preds) / num_introns, len(correct_acceptor_preds) / num_introns, len(transcript.introns)
+
+
+def missplicing(mut_id, splicing_threshold=0.5, primary_transcript=True, organism='hg38', engine='spliceai'):
+    gene = Gene(mut_id.split(':')[0], organism=organism)
+    mutation = get_mutation(mut_id, rev=gene.rev)
+    results = {}
+
+    for tid, transcript in gene.run_transcripts():
+        # if not transcript.primary_transcript and primary_transcript:
+        #     continue
+        #
+        if mutation not in transcript:
+            continue
+
+        good_tid = tid
+
+        transcript.generate_pre_mrna()
+        results[tid] = Missplicing(find_transcript_missplicing(transcript, mutation, engine=engine),
+                                   threshold=splicing_threshold)
+
+    # if len(results) == 0:
+    #     return None
+    #
+    # if primary_transcript and good_tid in results:
+    #     return results[good_tid]
+    # else:
+    #     return None
+
+    return results
+

geney/utils.py

@@ -15,7 +15,6 @@ def is_monotonic(A):
     return False
 
 
-
 def available_genes(organism='hg38'):
     from geney import config_setup
     annotation_path = config_setup[organism]['MRNA_PATH'] / 'protein_coding'
@@ -52,24 +51,29 @@ def dump_pickle(file_path, payload):
     return None
 
 
-def find_files_by_gene_name(gene_name, organism='hg38'):
-    from geney import config_setup
-    mrna_path = config_setup[organism]['MRNA_PATH'] / 'protein_coding'
-    matching_files = [f for f in mrna_path.glob(f'*_{gene_name}.pkl')]
-    if len(matching_files) > 1:
-        print(f"Multiple files available ({[f.name for f in matching_files]}).")
-    elif len(matching_files) == 0:
-        raise FileNotFoundError(f"No files available for gene {gene_name}.")
-
-    return matching_files[0]
-
-
-def reverse_complement(s: str, complement: dict = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} ) -> str:
-    '''Performs reverse-complement of a sequence. Default is a DNA sequence.'''
-    s_rev = s[::-1]
-    lower = [b.islower() for b in list(s_rev)]
-    bases = [complement.get(base, base) for base in list(s_rev.upper())]
-    rev_compl = ''.join([b.lower() if l else b for l, b in zip(lower, bases)])
-    return rev_compl
 
+def is_monotonic(A):
+    return all(x <= y for x, y in zip(A, A[1:])) or all(x >= y for x, y in zip(A, A[1:]))
+
+
+# def find_files_by_gene_name(gene_name, organism='hg38'):
+#     from geney import config_setup
+#     mrna_path = config_setup[organism]['MRNA_PATH'] / 'protein_coding'
+#     matching_files = [f for f in mrna_path.glob(f'*_{gene_name}.pkl')]
+#     if len(matching_files) > 1:
+#         print(f"Multiple files available ({[f.name for f in matching_files]}).")
+#     elif len(matching_files) == 0:
+#         raise FileNotFoundError(f"No files available for gene {gene_name}.")
+#
+#     return matching_files[0]
+#
+#
+# def reverse_complement(s: str, complement: dict = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} ) -> str:
+#     '''Performs reverse-complement of a sequence. Default is a DNA sequence.'''
+#     s_rev = s[::-1]
+#     lower = [b.islower() for b in list(s_rev)]
+#     bases = [complement.get(base, base) for base in list(s_rev.upper())]
+#     rev_compl = ''.join([b.lower() if l else b for l, b in zip(lower, bases)])
+#     return rev_compl
+#
 

{geney-1.2.22.dist-info → geney-1.2.24.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: geney
-Version: 1.2.22
+Version: 1.2.24
 Summary: A Python package for gene expression modeling.
 Home-page: https://github.com/nicolaslynn/geney
 Author: Nicolas Lynn
 Author-email: nicolasalynn@gmail.com
 License: Free for non-commercial use
+Platform: UNKNOWN
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: Free for non-commercial use
@@ -13,25 +14,21 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python :: 3.9
 Requires-Python: >3.9
-Requires-Dist: numpy ==1.26.4
-Requires-Dist: pandas ==2.2.1
-Requires-Dist: networkx ==3.2.1
-Requires-Dist: viennarna ==2.6.4
-Requires-Dist: tqdm >=4.66.1
-Requires-Dist: spliceai ==1.3.1
-Requires-Dist: biopython ==1.81
-Requires-Dist: tensorflow ==2.15.0
-Requires-Dist: keras ==2.15.0
-Requires-Dist: joblib ==1.3.2
-Requires-Dist: gtfparse ==1.3.0
-Requires-Dist: sh ==2.0.6
-Requires-Dist: termplotlib ==0.3.9
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: networkx
+Requires-Dist: viennarna
+Requires-Dist: tqdm
+Requires-Dist: spliceai
+Requires-Dist: biopython==1.81
+Requires-Dist: gtfparse==1.3.0
+Requires-Dist: sh==2.0.6
 Requires-Dist: torch
 Requires-Dist: lifelines
 Requires-Dist: notebook
 Requires-Dist: matplotlib
-Requires-Dist: dask[complete]
-Requires-Dist: dask-jobqueue
 Requires-Dist: gffutils
 Requires-Dist: pyfastx
 
+UNKNOWN
+

geney-1.2.24.dist-info/RECORD

@@ -0,0 +1,25 @@
+geney/Fasta_segment.py,sha256=0zCdzPUbDeM9Rz642woH5Q94pwI46O0fE3H8w0XWebc,11255
+geney/__init__.py,sha256=eBdDl42N6UhcYeZDjOnv199Z88fI5_8Y6xW8447OKXM,755
+geney/config_setup.py,sha256=VA6mhVGMRadwlpEx4m1wrssmDM8qpfKT21MAijIwjyQ,428
+geney/data_setup.py,sha256=2RHmuvcGUQbEglXQEZr0C2QPDTQYRZOEm0EcmyfQJgU,12229
+geney/graphic_utils.py,sha256=tjm6IDQ1BdfSeuPYzjlqAUHFQoDYH9jXTzJjKFS4Hh4,11078
+geney/gtex_utils.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
+geney/immune_utils.py,sha256=ZRni5ttrhpYBnmNr0d0ZatIbNPYs4nmQuoUO00SpsS4,5271
+geney/mutation_utils.py,sha256=C-K8F8wyN5joI3ZuP-d7IMYTI43YPDXUc3IgAJ07o8Q,1546
+geney/oncosplice.py,sha256=3jJc1-CWubH2ElHEjyQtsr9JYVmfPQEpq7EX-IfY-t8,20806
+geney/pangolin_utils.py,sha256=S2uMjQnnxqWSnfuMaEjo-wq52DVKFiXt__L5VPdtzyU,2939
+geney/power_utils.py,sha256=MehZFUdkJ2EFUot709yPEDxSkXmH5XevMebX2HD768A,7330
+geney/seqmat_utils.py,sha256=4MiN6rGeQMfWK6bXOHGddxBffx8v4sT1THkZe-AceXE,15611
+geney/spliceai_utils.py,sha256=BiTRIfrovX9qo9xup6bFWp0qkvmW9NVPY98Zw8-OaL0,1891
+geney/splicing_utils.py,sha256=pS3jZEpmnDkbT1jjaJh-O6I--Xm22e5dj-GQu7IAZSQ,15943
+geney/survival_utils.py,sha256=2CAkC2LsspicHIdrqsiPnjgvpr5KHDUfLFFqnRbPJqs,5762
+geney/tcga_utils.py,sha256=vXSMf1OxoF_AdE_rMguy_BoYaart_E1t4FFMx2DS1Ak,15585
+geney/utils.py,sha256=WbV1DBllQyvzoDiYkidRiTX5MBpQGr99M4hTUQ0BKo8,2185
+geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geney/translation_initiation/tis_utils.py,sha256=iXrWVijyPe-f8I9rEVGdxNnXBrOGPoKFjmvaOEnQYNE,4446
+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.24.dist-info/METADATA,sha256=sJGrKawFcaFyF1QwLOHn7dNYeznt5f2fKL7NDZvqqq8,948
+geney-1.2.24.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+geney-1.2.24.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.2.24.dist-info/RECORD,,

{geney-1.2.22.dist-info → geney-1.2.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: bdist_wheel (0.44.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

geney-1.2.22.dist-info/RECORD

@@ -1,19 +0,0 @@
-geney/Fasta_segment.py,sha256=0zCdzPUbDeM9Rz642woH5Q94pwI46O0fE3H8w0XWebc,11255
-geney/__init__.py,sha256=knezxgbV2c2gcO2ek2-xxEC15HL4aO1WuoMiYOOvKf8,428
-geney/config_setup.py,sha256=VA6mhVGMRadwlpEx4m1wrssmDM8qpfKT21MAijIwjyQ,428
-geney/data_setup.py,sha256=LTiJMYPgv9KnIgUNw-D57Fu4nxL4OojXMpmdhE8QSYU,12228
-geney/gtex_utils.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
-geney/immune_utils.py,sha256=ZRni5ttrhpYBnmNr0d0ZatIbNPYs4nmQuoUO00SpsS4,5271
-geney/oncosplice.py,sha256=AZm8Vj7z65DokPmeflwoqs2BM11neV9hQLA_Ao4ysnM,78242
-geney/power_utils.py,sha256=MehZFUdkJ2EFUot709yPEDxSkXmH5XevMebX2HD768A,7330
-geney/survival_utils.py,sha256=2CAkC2LsspicHIdrqsiPnjgvpr5KHDUfLFFqnRbPJqs,5762
-geney/tcga_utils.py,sha256=vXSMf1OxoF_AdE_rMguy_BoYaart_E1t4FFMx2DS1Ak,15585
-geney/utils.py,sha256=xJi7fk3g7DkR2rKOb8WePLQNM1ib83rcHecwRdwd5lA,2036
-geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geney/translation_initiation/tis_utils.py,sha256=iXrWVijyPe-f8I9rEVGdxNnXBrOGPoKFjmvaOEnQYNE,4446
-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.22.dist-info/METADATA,sha256=eTTiyuGPZ5lD7jV8YZXSocPyewD3OPwvgeaqiXxuVfo,1163
-geney-1.2.22.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
-geney-1.2.22.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.2.22.dist-info/RECORD,,