geney 1.1.2__py2.py3-none-any.whl → 1.1.4__py2.py3-none-any.whl

geney/data_setup.py

@@ -218,7 +218,8 @@ def main():
         'MRNA_PATH': os.path.join(args.basepath, 'annotations'),
         'MISSPLICING_PATH': os.path.join(args.basepath, 'missplicing'),
         'ONCOSPLICE_PATH': os.path.join(args.basepath, 'oncosplice'),
-        'BASE': args.basepath
+        'BASE': args.basepath,
+        'NETCHOP': os.path.join(args.basepath, 'netchop')
     }
     dump_json(config_file, config_paths)
 
@@ -242,6 +243,11 @@ def main():
     fasta_build_path.mkdir()
     split_fasta(fasta_file, fasta_build_path)
 
+    clinvar_url = 'https://ftp.ncbi.nlm.nih.gov/pub/clinvar/vcf_GRCh38/clinvar.vcf.gz'
+    clinvar_file = download_and_ungzip(clinvar_url, base_path)
+    # clinvar_build_path = base_path / f'accessory_data'
+    # clinvar_build_path.mkdir()
+
     ensembl_url = 'https://ftp.ensembl.org/pub/release-111/gtf/homo_sapiens/Homo_sapiens.GRCh38.111.gtf.gz'
     ensembl_file = download_and_ungzip(ensembl_url, base_path)
     ensembl_annotation_path = base_path / f'annotations'

geney/gtex_utils.py

@@ -0,0 +1,68 @@
+import pandas as pd
+from tqdm import tqdm
+
+# Set pandas display options (if necessary)
+pd.options.display.max_rows = 999
+
+# Read metadata
+metadata = pd.read_csv('GTEx_Analysis_v8_Annotations_SampleAttributesDS.txt', delimiter='\t')
+metadata_tissue_mapper = metadata[['SAMPID', 'SMTS']].drop_duplicates().set_index('SAMPID').to_dict()['SMTS']
+
+# Initialize an empty DataFrame for combined results
+combined_df = pd.DataFrame()
+
+# Define chunk size
+tpm_mean = []
+# Process the main data file in chunks
+for chunk in tqdm(pd.read_csv('GTEx_Analysis_2017-06-05_v8_RSEMv1.3.0_transcript_tpm.gct', header=2, chunksize=1000,
+                              delimiter='\t')):
+    # Perform the same operations on the chunk
+    chunk = chunk.set_index(['transcript_id', 'gene_id']).rename(columns=metadata_tissue_mapper)
+    # Append the processed chunk to the combined DataFrame
+    tpm_mean.append(chunk.T.groupby(by=chunk.columns).mean().T)
+
+# Compute the mean TPM per tissue
+tpm_mean = pd.concat(tpm_mean)
+
+
+cancer_projects = {
+    "Adrenal Gland": "ACC",
+    "Bladder": "BLCA",
+    "Brain": ["GBM", "LGG"],  # Note: Brain maps to two projects
+    "Breast": "BRCA",
+    "Colon": "COAD",
+    "Esophagus": "ESCA",
+    "Kidney": ["KICH", "KIRC", "KIRP"],  # Note: Kidney maps to three projects
+    "Liver": "LIHC",
+    "Lung": "LUNG",
+    "Ovary": "OV",
+    "Pancreas": "PAAD",
+    "Prostate": "PRAD",
+    "Skin": "SKCM",
+    "Stomach": "STAD",
+    "Testis": "TGCT",
+    "Uterus": "UCS"
+}
+
+tissue_projects = {
+    "ACC": "Adrenal Gland",
+    "BLCA": "Bladder",
+    "GBM": "Brain",
+    "LGG": "Brain",
+    "BRCA": "Breast",
+    "COAD": "Colon",
+    "ESCA": "Esophagus",
+    "KICH": "Kidney",
+    "KIRC": "Kidney",
+    "KIRP": "Kidney",
+    "LIHC": "Liver",
+    "LUNG": "Lung",
+    "OV": "Ovary",
+    "PAAD": "Pancreas",
+    "PRAD": "Prostate",
+    "SKCM": "Skin",
+    "STAD": "Stomach",
+    "TGCT": "Testis",
+    "UCS": "Uterus"
+}
+

geney/netchop.py

@@ -2,7 +2,7 @@
 import subprocess
 import logging
 import tempfile
-
+from geney import config_setup
 
 class NetChop(object):
     """
@@ -25,12 +25,13 @@ class NetChop(object):
         The i'th list corresponds to the i'th sequence. Each list gives
         the cleavage probability for each position in the sequence.
         """
-        with tempfile.NamedTemporaryFile(suffix=".fsa", mode="w") as input_fd:
+        with tempfile.NamedTemporaryFile(dir=config_setup['NETCHOP'], suffix=".fsa", mode="w") as input_fd:
             for (i, sequence) in enumerate(sequences):
                 input_fd.write("> %d\n" % i)
                 input_fd.write(sequence)
                 input_fd.write("\n")
             input_fd.flush()
+
             try:
                 output = subprocess.check_output(["netChop", input_fd.name])
             except subprocess.CalledProcessError as e:

geney/performance_utils.py

@@ -0,0 +1,138 @@
+import pandas as pd
+import numpy as np
+from sklearn.metrics import precision_score, recall_score, accuracy_score
+from sklearn.metrics import roc_auc_score, roc_curve
+import matplotlib.pyplot as plt
+
+
+# def plot_performance(true_values, predictions):
+#     clinsig_map = {'Benign': 0, 'Pathogenic': 1}
+#     true_values = [clinsig_map[t] for t in true_values]
+#     predictions = scale_predictions(predictions)
+#
+#     fpr, tpr, thresholds_roc = roc_curve(true_values, predictions)
+#
+#     # Calculate Precision-Recall curve
+#     precision, recall, thresholds_pr = precision_recall_curve(true_values, predictions)
+#
+#     # Plotting ROC curve
+#     plt.figure(figsize=(20, 5))
+#
+#     plt.subplot(1, 4, 1)
+#     plt.plot(fpr, tpr)
+#     plt.title('ROC Curve')
+#     plt.xlabel('False Positive Rate')
+#     plt.ylabel('True Positive Rate')
+#
+#     # Plotting Precision-Recall curve
+#     plt.subplot(1, 4, 2)
+#     plt.plot(recall, precision)
+#     plt.title('Precision-Recall Curve')
+#     plt.xlabel('Recall')
+#     plt.ylabel('Precision')
+#
+#     # Plotting Precision vs. Thresholds
+#     plt.subplot(1, 4, 3)
+#     plt.plot(thresholds_pr, precision[:-1])  # Precision and thresholds have off-by-one lengths
+#     plt.title('Precision vs. Threshold')
+#     plt.xlabel('Threshold')
+#     plt.ylabel('Precision')
+#
+#     # Plotting Sample Percentage Captured vs. Thresholds
+#     plt.subplot(1, 4, 4)
+#     # Assuming 'tpr' or another appropriate metric represents the cumulative percentage
+#     plt.plot(thresholds_roc, tpr)  # Update 'tpr' with the correct metric if necessary
+#     plt.title('Cumulative Percentage vs. Threshold')
+#     plt.xlabel('Threshold')
+#     plt.ylabel('Cumulative Percentage of Population')
+#
+#     plt.tight_layout()
+#     plt.show()
+#
+#
+#
+# def plot_auc_curve(y_true, y_pred_proba):
+#     """
+#     Plots the AUC curve.
+#
+#     Args:
+#         y_true (array-like): True labels (0 or 1).
+#         y_pred_proba (array-like): Predicted probabilities for positive class.
+#
+#     Returns:
+#         None
+#     """
+#     fpr, tpr, _ = roc_curve(y_true, y_pred_proba)
+#     auc_value = roc_auc_score(y_true, y_pred_proba)
+#
+#     plt.figure(figsize=(8, 6))
+#     plt.plot(fpr, tpr, label=f"AUC = {auc_value:.2f}")
+#     plt.plot([0, 1], [0, 1], 'k--')
+#     plt.xlabel("False Positive Rate")
+#     plt.ylabel("True Positive Rate")
+#     plt.title("Receiver Operating Characteristic (ROC) Curve")
+#     plt.legend()
+#     plt.show()
+#     return auc_value
+#
+#
+# def optimal_ppv(dataframe, feature_name, plot=False):
+#     """
+#     Calculates the optimal positive predictive value (PPV) for a given feature.
+#
+#     Args:
+#         dataframe (pd.DataFrame): Input dataframe.
+#         feature_name (str): Name of the feature column.
+#
+#     Returns:
+#         float: Optimal PPV.
+#     """
+#     # Assuming 'target' is the binary target column (0 or 1)
+#     threshold_values = pd.qcut(dataframe[feature_name], 100, duplicates='drop')
+#     ppv_values = []
+#
+#     for threshold in threshold_values:
+#         predictions = (dataframe[feature_name] >= threshold).astype(int)
+#         ppv = precision_score(dataframe['target'], predictions)
+#         ppv_values.append(ppv)
+#
+#     optimal_threshold = threshold_values[np.argmax(ppv_values)]
+#     optimal_ppv = max(ppv_values)
+#     if plot:
+#         plt.figure(figsize=(8, 6))
+#         plt.scatter(threshold_values, ppv_values)
+#         plt.xlabel("Threshold")
+#         plt.ylabel("Positive Predictive Value (PPV)")
+#         plt.title("Optimal Positive Predictive Value (PPV)")
+#         plt.show()
+#
+#     return optimal_ppv, optimal_threshold
+#
+#
+# def measure_prediction_quality(prediction_vector, quality_vector):
+#     """
+#     Measure the quality of the predictions using the quality_vector as the characteristic to check.
+#     """
+#     pass
+#
+#
+#
+# def create_ppv_vector(prediction_vector, true_value_vector):
+#     """
+#     Create a vector of positive predictive values (PPV) for the prediction_vector using the true_value_vector as the true values.
+#     """
+#     df = pd.DataFrame({'prediction': prediction_vector, 'true_value': true_value_vector})
+#     df.sort_values('prediction', ascending=True, inplace=True)
+#     df['bin'] = pd.qcut(df['prediction'], 100, labels=False, duplicates=True, retbins=True)
+#     for bin in df.bin.unique():
+#         temp_df = df[df.bin >= bin].
+#
+#
+# def group_retention(predictions, predictor):
+#     # first i need to get the ratio of values that are retained at particular values
+#     predictions.sort_values(predictor, inplace=True)
+#     _, thresholds = pd.qcut(predictions[predictor], 100, duplicates='drop')
+#     tracker = []
+#     for th in thresholds:
+#
+#

geney/survival.py

@@ -64,7 +64,7 @@ class SurvivalAnalysis:
                                  df[col].nunique() > 1]]  # and df[col].value_counts(normalize=True).min() >= 0.01]]
         return df
 
-    def kaplan_meier_analysis(self, df, control_label='CV', target_label='Epistasis', feature='group', plot=False):
+    def kaplan_meier_analysis(self, df, control_label='CV', target_label='Epistasis', feature='group', plot=False, time_cap=False):
         # Can only be performed on features with two unique values
         cap_time = df.groupby(feature).duration.max().min()
         # df['duration'] = df['duration'].clip(upper=cap_time)
@@ -98,7 +98,8 @@ class SurvivalAnalysis:
             plt.title('Kaplan-Meier Survival Curves')
             plt.xlabel('Time')
             plt.ylabel('Survival Probability')
-            plt.xlim([0, cap_time])
+            if time_cap:
+                plt.xlim([0, cap_time])
             plt.show()
 
         results['p_value'] = p_value

geney/survival_utils.py

@@ -0,0 +1,124 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+from scipy.integrate import trapz
+from geney.utils import unload_pickle, unload_json, contains
+from lifelines.exceptions import ConvergenceError
+from lifelines import KaplanMeierFitter
+from lifelines.statistics import logrank_test
+from lifelines import CoxPHFitter
+
+pd.set_option('display.max_columns', None)
+pd.options.mode.chained_assignment = None
+
+
+def prepare_clinical_data(df=None):
+    if df is None:
+        CLINICAL_DATA_FILE = Path('/tamir2/yoramzar/Projects/Cancer_mut/Explore_data/reports/df_p_all.pkl')
+        df = unload_pickle(CLINICAL_DATA_FILE)
+
+    df.rename(columns={'patient_uuid': 'case_id'}, inplace=True)
+    cols = list(df.columns)
+    cols_days_to_followup = [col for col in cols if 'days_to_followup' in col] + [col for col in cols if 'days_to_last_followup' in col]
+    cols_days_to_know_alive = [col for col in cols if 'days_to_know_alive' in col] + [col for col in cols if 'days_to_last_known_alive' in col]
+    cols_days_to_death = [col for col in cols if 'days_to_death' in col]
+    cols_duration = cols_days_to_followup + cols_days_to_know_alive + cols_days_to_death
+    col_vital_status = 'days_to_death'
+    event_col_label = 'event'
+    duration_col_label = 'duration'
+    df.insert(1, event_col_label, df.apply(lambda x: int(not np.isnan(x[col_vital_status])), axis=1))
+    df.insert(1, duration_col_label, df.apply(lambda x: max([x[col] for col in cols_duration if not np.isnan(x[col])], default=-1), axis=1))
+    df[duration_col_label] /= 365
+    df = df.query(f"{duration_col_label}>=0.0")[['duration', 'event', 'case_id', 'chemotherapy', 'hormone_therapy', 'immunotherapy', 'targeted_molecular_therapy', 'Proj_name']]
+    # df.to_csv('/tamir2/nicolaslynn/data/tcga_metadata/tcga_clinical_data.csv')
+    return df
+
+
+class SurvivalAnalysis:
+    def __init__(self, clindf=None):
+        self.clindf = prepare_clinical_data(clindf)
+        self.treatment_features = ['chemotherapy', 'hormone_therapy', 'immunotherapy', 'targeted_molecular_therapy']
+        self.df = self.clindf.copy()
+        self.df['group'] = 0
+        self.df.fillna(0, inplace=True)
+        self.treatment_features = ['chemotherapy', 'hormone_therapy', 'immunotherapy', 'targeted_molecular_therapy']
+
+    def generate_clinical_dataframe(self, target_cases, control_cases=None, inplace=False, features_of_interest=[]):
+        df = self.df.copy()
+        df.loc[df[df.case_id.isin(target_cases)].index, 'group'] = 2
+        if control_cases is not None:
+            df.loc[df[df.case_id.isin(control_cases)].index, 'group'] = 1
+
+        df = df[df.group > 0]
+        df.group -= 1
+        core_features = ['duration', 'event']
+        df = df[core_features + features_of_interest]
+
+        for col in self.treatment_features:
+            if col not in df:
+                continue
+            df.loc[df[col] > 0, col] = 1
+
+        df = df[core_features + [col for col in features_of_interest if
+                                 df[col].nunique() > 1]]  # and df[col].value_counts(normalize=True).min() >= 0.01]]
+        return df
+
+    def kaplan_meier_analysis(self, df, control_label='CV', target_label='Epistasis', feature='group', plot=False, time_cap=False):
+        # Can only be performed on features with two unique values
+        cap_time = df.groupby(feature).duration.max().min()
+        # df['duration'] = df['duration'].clip(upper=cap_time)
+        auc_vals = []
+        results = pd.Series()
+        count = 0
+        for val in [0, 1]:
+            g = df[df[feature] == val]
+            kmf = KaplanMeierFitter()
+            label = f"{control_label} ({len(g)} cases)" if val == 0 else f"{target_label} ({len(g)} cases)"
+            if val == 0:
+                results[control_label] = len(g)
+            else:
+                results[target_label] = len(g)
+
+            kmf.fit(g['duration'], g['event'], label=label)
+            surv_func = kmf.survival_function_
+            auc = trapz(surv_func[label], surv_func.index)
+            auc_vals.append(auc)
+            if plot:
+                if count == 0:
+                    ax = kmf.plot()
+                else:
+                    kmf.plot(ax=ax)
+                count += 1
+        p_value = self.log_rank(df[df[feature] == 1], df[df[feature] == 0])
+
+        if plot:
+            ax.text(0.5, 0.85, f'p-value: {p_value:.4f}', transform=ax.transAxes, fontsize=12,
+                    horizontalalignment='center')
+            plt.title('Kaplan-Meier Survival Curves')
+            plt.xlabel('Time')
+            plt.ylabel('Survival Probability')
+            if time_cap:
+                plt.xlim([0, cap_time])
+            plt.show()
+
+        results['p_value'] = p_value
+        results['auc_target'] = auc_vals[-1]
+        if len(auc_vals) > 1:
+            results['auc_delta'] = auc_vals[-1] - auc_vals[0]
+            results['auc_control'] = auc_vals[0]
+
+        return results
+
+    def log_rank(self, group1, group2):
+        return logrank_test(group1['duration'], group2['duration'],
+                            event_observed_A=group1['event'],
+                            event_observed_B=group2['event']).p_value
+
+    def perform_cox_analysis(self, df, features_of_interest):
+        # Very simple... will return a series with p values for each feature
+        try:
+            return CoxPHFitter().fit(df[features_of_interest + ['duration', 'event']], 'duration', 'event').summary.p
+        except ConvergenceError:
+            print("Convergence Error")
+            return pd.Series()

geney/tcga_utils.py

@@ -2,6 +2,7 @@
 import pandas as pd
 import random
 from pathlib import Path
+
 class TCGACase:
     def __init__(self, df):
         # Here we get a dataframe of mutations within a gene
@@ -109,6 +110,7 @@ class TCGAGene:
 
         else:
             df = df[df.Variant_Type.isin(['SNP', 'INS', 'DEL'])]
+            df = df.astype({'Start_Position': int})
 
             if include_filter is not None:
                 df = df[df.FILTER == include_filter]
@@ -138,36 +140,43 @@ class TCGAGene:
             df = df[~df.FILTER.str.contains(filter)]
         return df.case_id.unique().tolist()
 
-    def get_patient_muts(self, case_id=None):
+    def get_patient_muts(self, case_id=None, read_ratio=0, exclude_filters=None):
         if case_id is None:
             case_id = random.choice(self.affected_cases())
         return self.df[self.df.case_id == case_id]
 
+    def get_patients_affected(self, mut_id, read_ratio=0, exclude_filters=None):
+        # returns all patients affected by ALL the mutatins in mut_id
+        pass
+
+    def get_patients_unaffected(self, mut_id, must_contain_all=False, read_ratio=0, exclude_filters=None):
+        # returns all patients not affected by ALL the mutation in mut id (patients containg individual mutations only allowed) unless must_contain_all= True
+        pass
+
+    def split_patients(self, mut_id, strict=True):
+        # returns two lists: all patients affected by a mutation and all patients with none of the mutations (or the mutations but not togehter)
+        pass
+
+
+    def arrange_patients_by_project(self, mut_id):
+        # returns all the patients affected by a mutation grouped by cancer project
+        pass
+
+
+    def total_prevalence(self, mut_id):
+        pass
+
+    def project_prevalence(self, mut_id):
+        pass
+
+    def project_counts(self, mut_id):
+        pass
+
+
+
+
+
 
-class TCGAMut:
-    def __init__(self, mut_id):
-        self.num_muts = mut_id.count('|') + 1
-        data = []
-        for mut in mut_id.split('|'):
-            data.append(mut.split(':'))
-        data = pd.DataFrame(data, columns=['Gene_name', 'Chromosome', 'Start_Position', 'Reference_Allele',
-                                           'Tumor_Seq_Allele2'])
-        data.Chromosome = data.apply(lambda row: f'chr{row.Chromosome}', axis=1)
-        data = data.astype({'Start_Position': int})
-        self.gene = data.Gene_name.unique().tolist()[0]
-        self.df = data
-
-    def find_affected_patients(self, read_ratio=0, exclude_filters=None):
-        gene = TCGAGene(self.gene, exclude_filters=exclude_filters).df
-        gene = gene[gene.ratio >= read_ratio]
-        return pd.merge(self.df, gene,
-                        on=['Gene_name', 'Chromosome', 'Start_Position', 'Reference_Allele', 'Tumor_Seq_Allele2'])
-
-    def find_affected_patients_list(self, read_ratio=0, exclude_filters=None):
-        df = self.find_affected_patients(read_ratio=read_ratio, exclude_filters=exclude_filters)
-        case_count = df.case_id.value_counts()
-        case_count = case_count[case_count == self.num_muts]
-        return case_count.index.tolist()
 
 
 

{geney-1.1.2.dist-info → geney-1.1.4.dist-info}/METADATA

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

{geney-1.1.2.dist-info → geney-1.1.4.dist-info}/RECORD

@@ -4,15 +4,18 @@ geney/__init__.py,sha256=r-Yvpo_Tc236DcsqsFyexT21iVoYCVl9zoJj5pFuWEE,407
 geney/benchmark_clinvar.py,sha256=LLl77e95Qbg9Kd-m2yL8ilmzubSz9SKogeARwssT4Ks,5532
 geney/compare_sets.py,sha256=TcgL57V7BUPxBoW9lv3xr8qK2Acmykn85Ev3avicQr8,2977
 geney/config_setup.py,sha256=SePeooA4RWAtR_KAT1-W1hkD3MT5tH6YMyp80t_RNPQ,385
-geney/data_setup.py,sha256=cNLoWez4Fe6ES57PKtpdQJBSuZyHksDeANkI8FraPTk,10425
+geney/data_setup.py,sha256=DZeksRPr2ZT7bszMo33W0r3OwmqHokVXtZ4gx5Lu_Mo,10725
 geney/gtex.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
-geney/netchop.py,sha256=mgKe9Yv2m1SlZUmIXBVNtH-rP5PtBn9SlEi9lE1L0SE,2821
+geney/gtex_utils.py,sha256=asL2lHyU5KsbWpV096vkf1Ka7hSo_RRfZqw7p5nERmE,1919
+geney/netchop.py,sha256=25oEkGp9NveEMX4owOTDPm6KU4LsALEcK_jk9TqTQRQ,2881
 geney/oncosplice.py,sha256=Fyc_UtAhV3Pv0vk8V55rO_jnb2Dwj5sW98KVwP3PHwU,68964
 geney/oncosplice_pipeline.py,sha256=hpGqFHOdn8i8tvvs1-t3-G9Ko18zInwoDXBJbbrfbC4,68036
+geney/performance_utils.py,sha256=FQt7rA4r-Wuq3kceCxsSuMfj3wU1tMG8QnbL59aBohs,4700
 geney/power_utils.py,sha256=WRpqMnqUv1xrAeTduAUhx6YpSEJQci7bC2od12JcVtE,7267
-geney/survival.py,sha256=94d53XeFSZy4ZK-C0u0lkauFwZVnww2JL7kBB0aJDDA,5527
+geney/survival.py,sha256=gNKZGcwxDZ00ixVBHf3ZdjbY_AHQOCU9kKpBC_dokbM,5572
+geney/survival_utils.py,sha256=gNKZGcwxDZ00ixVBHf3ZdjbY_AHQOCU9kKpBC_dokbM,5572
 geney/tcga_annotations.py,sha256=DjRl6Pk5VAOL1yhbt8SXD6FZhYbcYNu3FtXYMeveGB0,15016
-geney/tcga_utils.py,sha256=cX9hbDX-qECyCMSYaBL8r1FWWuju08jQvlPT3q13B3Y,15777
+geney/tcga_utils.py,sha256=XrLI8RzmXhyabvL24sMrqQM3KNusmU1_kyKYdkv6lpo,15591
 geney/utils.py,sha256=YOe22gA0Oew9_QEym7ivM9sb7t3wNeHTeiSDBmvOPso,1984
 geney/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geney/analyzers/benchmark_clinvar.py,sha256=ZAxvZ-Ue5T6au5mGbk8clfvbAYl13NIY7U92KzL0lXI,5531
@@ -40,7 +43,7 @@ geney/translation_initiation/resources/kozak_pssm.json,sha256=pcd0Olziutq-6H3mFW
 geney/translation_initiation/resources/tis_regressor_model.joblib,sha256=IXb4DUDhJ5rBDKcqMk9zE3ECTZZcdj7Jixz3KpoZ7OA,2592025
 geney/translation_termination/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geney/translation_termination/tts_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geney-1.1.2.dist-info/METADATA,sha256=o9RBIxjheWrogT4Tp-Do6ySJWhN-7oXedvtiV0KE1RQ,1130
-geney-1.1.2.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
-geney-1.1.2.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.1.2.dist-info/RECORD,,
+geney-1.1.4.dist-info/METADATA,sha256=3nh_1Zr0M9_nDw7i6UhARNMjeY7-Vs4C1gfYJTVhkqI,1130
+geney-1.1.4.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+geney-1.1.4.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.1.4.dist-info/RECORD,,