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

geney/oncosplice.py

@@ -361,67 +361,64 @@ 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):
-    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:
-            continue
-
-        if all(mutation not in transcript for mutation in mutations):
-            results.append({'transcript_id': transcript.transcript_id})
-            continue
-
-        transcript.generate_pre_mrna()
-        transcript.cons_vector = transform_conservation_vector(transcript.cons_vector, window=window_length)
-        transcript.generate_mature_mrna().generate_protein(inplace=True, domains=domains)
-        ref_protein, cons_vector = transcript.protein, transcript.cons_vector
-        reference_transcript = copy.deepcopy(transcript)
-
-        assert len(ref_protein) == len(cons_vector), f"Protein ({len(ref_protein)}) and conservation vector ({len(cons_vector)}) must be same length. {ref_protein}, \n>{cons_vector}\n>{transcript.cons_seq}"
-
-        missplicing = Missplicing(find_transcript_missplicing(transcript, mutations, engine=engine, threshold=splicing_threshold), threshold=splicing_threshold)
-        for mutation in mutations:
-            transcript.pre_mrna += mutation
-
-        for i, new_boundaries in enumerate(develop_aberrant_splicing(transcript, missplicing.aberrant_splicing)):
-            transcript.acceptors = new_boundaries['acceptors']
-            transcript.donors = new_boundaries['donors']
-            transcript.generate_mature_mrna().generate_protein()
-
-            alignment = get_logical_alignment(reference_transcript.protein, transcript.protein)
-            deleted, inserted = find_indels_with_mismatches_as_deletions(alignment.seqA, alignment.seqB)
-            modified_positions = find_modified_positions(len(ref_protein), deleted, inserted)
-            temp_cons = np.convolve(cons_vector * modified_positions, np.ones(window_length)) / window_length
-            affected_cons_scores = max(temp_cons)
-            percentile = (
-                        sorted(cons_vector).index(next(x for x in sorted(cons_vector) if x >= affected_cons_scores)) / len(
-                    cons_vector))
-
-            report = OncospliceAnnotator(reference_transcript, transcript, mutation)
-            report['mut_id'] = mut_id
-            report['oncosplice_score'] = affected_cons_scores
-            report['percentile'] = percentile
-            report['isoform_id'] = i
-            report['isoform_prevalence'] = new_boundaries['path_weight']
-            report['full_missplicing'] = missplicing.aberrant_splicing
-            report['missplicing'] = max(missplicing)
-            report['reference_resemblance'] = reference_gene_proteins.get(transcript.protein, None)
-            results.append(report)
-
-    report = pd.DataFrame(results)
-    return report
+# def oncosplice(mut_id, splicing_threshold=0.5, protein_coding=True, cons_required=False, primary_transcript=False, window_length=13, organism='hg38', engine='spliceai', domains=None):
+#     gene = Gene(mut_id.split(':')[0], organism=organism)
+#     reference_gene_proteins = {tid: transcript.generate_pre_mrna().generate_mature_mrna().generate_protein() for tid, transcript in gene.run_transcripts(protein_coding=True)}
+#     mutations = [get_mutation(m, rev=gene.rev) for m in mut_id.split('|')]
+#
+#     results = []
+#     for tid, transcript in gene.run_transcripts(protein_coding=protein_coding, primary_transcript=primary_transcript):
+#         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()
+#         transcript.cons_vector = transform_conservation_vector(transcript.cons_vector, window=window_length)
+#         transcript.generate_mature_mrna().generate_protein(inplace=True, domains=domains)
+#         ref_protein, cons_vector = transcript.protein, transcript.cons_vector
+#         reference_transcript = copy.deepcopy(transcript)
+#
+#         assert len(ref_protein) == len(cons_vector), f"Protein ({len(ref_protein)}) and conservation vector ({len(cons_vector)}) must be same length. {ref_protein}, \n>{cons_vector}\n>{transcript.cons_seq}"
+#
+#         missplicing = Missplicing(find_transcript_missplicing(transcript, mutations, engine=engine, threshold=splicing_threshold), threshold=splicing_threshold)
+#         for mutation in mutations:
+#             transcript.pre_mrna += mutation
+#
+#         for i, new_boundaries in enumerate(develop_aberrant_splicing(transcript, missplicing.aberrant_splicing)):
+#             transcript.acceptors = new_boundaries['acceptors']
+#             transcript.donors = new_boundaries['donors']
+#             transcript.generate_mature_mrna().generate_protein()
+#
+#             alignment = get_logical_alignment(reference_transcript.protein, transcript.protein)
+#             deleted, inserted = find_indels_with_mismatches_as_deletions(alignment.seqA, alignment.seqB)
+#             modified_positions = find_modified_positions(len(ref_protein), deleted, inserted)
+#             temp_cons = np.convolve(cons_vector * modified_positions, np.ones(window_length)) / window_length
+#             affected_cons_scores = max(temp_cons)
+#             percentile = (
+#                         sorted(cons_vector).index(next(x for x in sorted(cons_vector) if x >= affected_cons_scores)) / len(
+#                     cons_vector))
+#
+#             report = OncospliceAnnotator(reference_transcript, transcript, mutation)
+#             report['mut_id'] = mut_id
+#             report['oncosplice_score'] = affected_cons_scores
+#             report['percentile'] = percentile
+#             report['isoform_id'] = i
+#             report['isoform_prevalence'] = new_boundaries['path_weight']
+#             report['full_missplicing'] = missplicing.aberrant_splicing
+#             report['missplicing'] = max(missplicing)
+#             report['reference_resemblance'] = reference_gene_proteins.get(transcript.protein, None)
+#             results.append(report)
+#
+#     report = pd.DataFrame(results)
+#     return report
 
 
 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 +449,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 +469,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/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-1.2.54.dist-info → geney-1.2.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geney
-Version: 1.2.54
+Version: 1.2.55
 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.55.dist-info}/RECORD

@@ -6,12 +6,12 @@ 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=-_b0ZSxWa-bSYDoVMt605lJlx8-rXf0WsKsFrMoF6Vg,23707
+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/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
@@ -20,7 +20,7 @@ geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 geney/translation_initiation/tis_utils.py,sha256=AF3siFjuQH-Rs44EV-80zHdbxRMvN4woLFSHroWIETc,4448
 geney/translation_initiation/resources/kozak_pssm.json,sha256=pcd0Olziutq-6H3mFWDCD9cujQ_AlZO-iiOvBl82hqE,1165
 geney/translation_initiation/resources/tis_regressor_model.joblib,sha256=IXb4DUDhJ5rBDKcqMk9zE3ECTZZcdj7Jixz3KpoZ7OA,2592025
-geney-1.2.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.55.dist-info/METADATA,sha256=bMKlTktE8jhYNpbxWMnp6Z168gk4NafThjukv45vYI4,948
+geney-1.2.55.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+geney-1.2.55.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.2.55.dist-info/RECORD,,