genal-python 1.2.7__tar.gz → 1.2.9__tar.gz

{genal_python-1.2.7 → genal_python-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: genal-python
-Version: 1.2.7
+Version: 1.2.9
 Summary: A python toolkit for polygenic risk scoring and mendelian randomization.
 Author-email: Cyprien Rivier <riviercyprien@gmail.com>
 Requires-Python: >=3.8

{genal_python-1.2.7 → genal_python-1.2.9}/genal/Geno.py

@@ -36,6 +36,7 @@ from .association import set_phenotype_func, association_test_func_plink2
 from .extract_prs import extract_snps_func, prs_func
 from .snp_query import async_query_gwas_catalog
 from .constants import STANDARD_COLUMNS, REF_PANEL_COLUMNS, CHECKS_DICT, MR_METHODS_NAMES
+from .colocalization import coloc_abf_func
 
 # Do all the MR steps (query_outcome, harmonize etc) based on CHR/POS and not SNPs
 # Consider reference panels in build 38
@@ -450,11 +451,6 @@ class Geno:
                 
         # Update the SNP column
         data['SNP'] = data['SNP_new'].fillna(data['SNP'])
-        #n_absent = data['SNP_new'].isna().sum()
-        #if n_absent > 0:
-        #    print(f"{n_absent}({n_absent/data.shape[0]*100:.3f}%) are not present in the genetic data.")
-        #else:
-        #    print("All SNPs are present in the genetic data.")
         data.drop(columns = ['SNP_new'], inplace=True)
         
         if replace: self.data = data #Update attribute if replace argument
@@ -495,9 +491,9 @@ class Geno:
             path=None, 
             proxy=False,
             reference_panel="eur",
-            kb=5000,
+            kb=10000,
             r2=0.6,
-            window_snps=5000,
+            window_snps=10000,
             
            ):
         """
@@ -767,9 +763,9 @@ class Geno:
         name=None,
         proxy=True,
         reference_panel="eur",
-        kb=5000,
+        kb=10000,
         r2=0.6,
-        window_snps=5000,
+        window_snps=10000,
     ):
         """
         Prepares dataframes required for Mendelian Randomization (MR) with the SNP information in `data` as exposure.
@@ -896,19 +892,19 @@ class Geno:
             self.cpus,
             subset_data
         )
-        
-        self.MR_results = (res, df_mr, exposure_name, outcome_name)
 
         if not heterogeneity:
             res = res.loc[:,["exposure", "outcome", "method", "nSNP", "b", "se", "pval"]]
-        
-        if odds:
+
+        if odds and not res.empty:
             # Calculate odds ratios and confidence intervals using .loc
             res.loc[:,'OR_95CI'] = res.apply(lambda row: 
                 f"{np.exp(row['b']):.3f} ({np.exp(row['b'] - 1.96*row['se']):.3f}-{np.exp(row['b'] + 1.96*row['se']):.3f})" 
                 if not pd.isna(row['b']) and not pd.isna(row['se']) 
                 else np.nan, axis=1)
-                   
+
+        self.MR_results = (res, df_mr, exposure_name, outcome_name)
+
         return res
     
     def MR_plot(
@@ -1187,6 +1183,103 @@ class Geno:
 
         return mod_table, GlobalTest, OutlierTest, BiasTest
 
+    def colocalize(self, outcome, method="abf", trait1_type=None, trait2_type=None,
+                   sdY1=None, sdY2=None, n1=None, n2=None, p1=1e-4, p2=1e-4, p12=1e-5):
+        """
+        Perform colocalization analysis between two GWAS datasets.
+        
+        Args:
+            outcome: Another Geno object containing the outcome dataset
+            method: Method to use for colocalization (default: "abf")
+            trait1_type: Type of exposure trait ("quant" or "cc")
+            trait2_type: Type of outcome trait ("quant" or "cc")
+            sdY1: Standard deviation of exposure trait (required for quantitative traits)
+            sdY2: Standard deviation of outcome trait (required for quantitative traits)
+            n1: Sample size for exposure (used to estimate sdY1 if not provided)
+            n2: Sample size for outcome (used to estimate sdY2 if not provided)
+            p1: Prior probability SNP associated with exposure
+            p2: Prior probability SNP associated with outcome
+            p12: Prior probability SNP associated with both traits
+        """
+        # Ensure required columns exist in both datasets
+        required_cols = ['BETA', 'SE']
+        for col in required_cols:
+            if col not in self.data.columns:
+                raise ValueError(f"Column {col} must be present in exposure dataset")
+            if col not in outcome.data.columns:
+                raise ValueError(f"Column {col} must be present in outcome dataset")
+            
+        if trait1_type is None:
+            print("trait1_type not specified. Assuming trait 1 is a quantitative trait.")
+            trait1_type = "quant"
+        if trait2_type is None:
+            print("trait2_type not specified. Assuming trait 2 is a quantitative trait.")
+            trait2_type = "quant"
+                
+        # Make copies of the data to avoid modifying the original data
+        data1 = self.data.copy()
+        data2 = outcome.data.copy()
+        
+        # Ensure that the BETA columns are preprocessed
+        check_beta_column(data1, 'BETA', 'Fill')
+        check_beta_column(data2, 'BETA', 'Fill')
+
+        # Adjust EAF column names before merging in case one of the datasets does not have it
+        if 'EAF' in data1.columns:
+            data1.rename(columns={'EAF': 'EAF_1'}, inplace=True)
+        if 'EAF' in data2.columns:
+            data2.rename(columns={'EAF': 'EAF_2'}, inplace=True)
+        
+        # Determine merge strategy based on available columns
+        if all(col in self.data.columns for col in ['CHR', 'POS']) and \
+           all(col in outcome.data.columns for col in ['CHR', 'POS']):
+            print("Merging datasets using CHR and POS")
+
+            #Ensure that the CHR, POS columns are preprocessed
+            check_int_column(data1, "CHR")
+            check_int_column(data1, "POS")
+            check_int_column(data2, "CHR")
+            check_int_column(data2, "POS")
+
+            # Merge the datasets
+            merged_data = pd.merge(data1, data2,
+                                 on=['CHR', 'POS'],
+                                 suffixes=('_1', '_2'))
+            
+        elif 'SNP' in self.data.columns and 'SNP' in outcome.data.columns:
+            print("Merging datasets using SNP IDs")
+
+            # Ensure that the SNP column is preprocessed
+            check_snp_column(data1)
+            check_snp_column(data2)
+
+            # Merge the datasets
+            merged_data = pd.merge(data1, data2,
+                                   on='SNP',
+                                   suffixes=('_1', '_2'))
+        else:
+            raise ValueError("Either CHR/POS or SNP columns must be present in both datasets for merging")
+        
+        # Drop any rows with missing values
+        merged_data = merged_data.dropna()
+        if merged_data.empty:
+            raise ValueError("No overlapping variants found between the datasets")
+        
+        print(f"Using {len(merged_data)} overlapping variants for colocalization analysis")
+            
+        # Call the implementation function
+        return coloc_abf_func(merged_data, 
+                             trait1_type=trait1_type,
+                             trait2_type=trait2_type,
+                             sdY1=sdY1, 
+                             sdY2=sdY2,
+                             n1=n1,
+                             n2=n2,
+                             p1=p1,
+                             p2=p2,
+                             p12=p12)
+
+
     def lift(
         self,
         start="hg19",

{genal_python-1.2.7 → genal_python-1.2.9}/genal/MR_tools.py

@@ -287,6 +287,7 @@ def harmonize_MR(df_exposure, df_outcome, action=2, eaf_threshold=0.42):
             "EAF": "EAF_e",
             "BETA": "BETA_e",
             "SE": "SE_e",
+            "P": "P_e",
         },
         errors="ignore",
     )
@@ -297,12 +298,14 @@ def harmonize_MR(df_exposure, df_outcome, action=2, eaf_threshold=0.42):
             "EAF": "EAF_o",
             "BETA": "BETA_o",
             "SE": "SE_o",
+            "P": "P_o",
         },
         errors="ignore",
     )
+
     df_outcome = df_outcome[
         df_outcome.columns.intersection(
-            ["SNP", "EA_o", "NEA_o", "EAF_o", "BETA_o", "SE_o"]
+            ["SNP", "EA_o", "NEA_o", "EAF_o", "BETA_o", "SE_o", "P_o"]
         )
     ]
 

{genal_python-1.2.7 → genal_python-1.2.9}/genal/__init__.py

@@ -4,7 +4,7 @@ from .tools import default_config, write_config, set_plink, install_plink, delet
 from .geno_tools import Combine_Geno
 from .constants import CONFIG_DIR
 
-__version__ = "1.2.7"
+__version__ = "1.2.9"
 
 config_path = os.path.join(CONFIG_DIR, "config.json")
 

genal_python-1.2.9/genal/colocalization.py

@@ -0,0 +1,159 @@
+import numpy as np
+import pandas as pd
+from numpy import exp, log
+
+
+
+
+def coloc_abf_func(data, trait1_type="quant", trait2_type="quant", 
+                   sdY1=None, sdY2=None, n1=None, n2=None,
+                   p1=1e-4, p2=1e-4, p12=1e-5):
+    """
+    Perform colocalization analysis between two GWAS datasets using approximate Bayes factors.
+    
+    Args:
+        data: DataFrame containing merged GWAS results
+        trait1_type: Type of trait 1 ("quant" or "cc")
+        trait2_type: Type of trait 2 ("quant" or "cc")
+        sdY1: Standard deviation of trait 1 (required for quantitative traits)
+        sdY2: Standard deviation of trait 2 (required for quantitative traits)
+        n1: Sample size for trait 1 (used to estimate sdY if not provided)
+        n2: Sample size for trait 2 (used to estimate sdY if not provided)
+        p1: Prior probability SNP associated with trait 1
+        p2: Prior probability SNP associated with trait 2
+        p12: Prior probability SNP associated with both traits
+    """
+    # Estimate sdY if not provided for quantitative traits
+    if trait1_type == "quant" and sdY1 is None:
+        if 'EAF_1' not in data.columns or n1 is None:
+            print("Neither sdY1 nor EAF and n1 are provided for trait 1. Assuming sdY1 = 1.")
+            sdY1 = 1
+        else:
+            sdY1 = sdY_est(data['SE_1']**2, data['EAF_1'], n1)
+            print(f"Using EAF and n1 to estimate sdY1: {sdY1:.2f}")
+        
+    if trait2_type == "quant" and sdY2 is None:
+        if 'EAF_2' not in data.columns or n2 is None:
+            print("Neither sdY2 nor EAF and n2 are provided for trait 2. Assuming sdY2 = 1.")
+            sdY2 = 1
+        else:
+            sdY2 = sdY_est(data['SE_2']**2, data['EAF_2'], n2)
+            print(f"Using EAF and n2 to estimate sdY2: {sdY2:.2f}")
+    # Calculate Bayes factors for each dataset
+    lABF_1 = approx_bf_estimates(data['BETA_1'], data['SE_1']**2, 
+                                trait_type=trait1_type, sdY=sdY1)
+    lABF_2 = approx_bf_estimates(data['BETA_2'], data['SE_2']**2, 
+                                trait_type=trait2_type, sdY=sdY2)
+    
+    # Adjust priors based on number of SNPs
+    n_snps = len(data)
+    if n_snps * p1 >= 1:
+        p1 = 1 / (n_snps + 1)
+    if n_snps * p2 >= 1:
+        p2 = 1 / (n_snps + 1)
+    if n_snps * p12 >= 1:
+        p12 = 1 / (n_snps + 1)
+    
+    # Calculate posterior probabilities
+    pp = combine_abf(lABF_1, lABF_2, p1, p2, p12)
+    
+    # Add SNP-specific results
+    results_df = data.copy()
+    results_df['lABF_1'] = lABF_1
+    results_df['lABF_2'] = lABF_2
+    results_df['internal.sum.lABF'] = lABF_1 + lABF_2
+    
+    # Calculate SNP-specific PP for H4
+    my_denom_log_abf = logsum(results_df['internal.sum.lABF'])
+    results_df['SNP.PP.H4'] = np.exp(results_df['internal.sum.lABF'] - my_denom_log_abf)
+    
+    return {
+        'summary': {
+            'nsnps': n_snps,
+            **pp
+        },
+        'results': results_df,
+        'priors': {
+            'p1': p1,
+            'p2': p2,
+            'p12': p12
+        }
+    }
+
+def approx_bf_estimates(beta, varbeta, trait_type="quant", sdY=1, effect_priors={'quant': 0.15, 'cc': 0.2}):
+    """
+    Calculate approximate Bayes factors using regression estimates.
+    
+    Args:
+        beta: effect size estimate
+        varbeta: variance of the effect size estimate
+        trait_type: either "quant" for quantitative trait or "cc" for case-control
+        sdY: standard deviation of the trait (for quantitative traits)
+        effect_priors: dictionary with prior effect sizes for quantitative and case-control traits
+        
+    Returns:
+        array: log approximate Bayes factors
+    """
+    z = beta / np.sqrt(varbeta)
+    
+    # Set prior standard deviation based on trait type
+    if trait_type == "quant":
+        sd_prior = effect_priors['quant'] * sdY
+    else:  # case-control
+        sd_prior = effect_priors['cc']
+        
+    r = sd_prior**2 / (sd_prior**2 + varbeta)
+    lABF = 0.5 * (np.log(1 - r) + (r * z**2))
+    return lABF
+
+def logsum(x):
+    """Calculate log of sum of exponentials"""
+    my_max = np.max(x)
+    return my_max + np.log(np.sum(np.exp(x - my_max)))
+
+def logdiff(x, y):
+    """Calculate log of difference of exponentials"""
+    my_max = max(x, y)
+    return my_max + np.log(exp(x - my_max) - np.exp(y - my_max))
+
+def combine_abf(l1, l2, p1, p2, p12):
+    """Calculate posterior probabilities for different hypotheses"""
+    lsum = l1 + l2
+    
+    lH0_abf = 0
+    lH1_abf = np.log(p1) + logsum(l1)
+    lH2_abf = np.log(p2) + logsum(l2)
+    lH3_abf = np.log(p1) + np.log(p2) + logdiff(logsum(l1) + logsum(l2), logsum(lsum))
+    lH4_abf = np.log(p12) + logsum(lsum)
+    
+    all_abf = np.array([lH0_abf, lH1_abf, lH2_abf, lH3_abf, lH4_abf])
+    denom_log_abf = logsum(all_abf)
+    pp_abf = np.exp(all_abf - denom_log_abf)
+    
+    return {
+        'PP.H0.abf': pp_abf[0],
+        'PP.H1.abf': pp_abf[1],
+        'PP.H2.abf': pp_abf[2],
+        'PP.H3.abf': pp_abf[3],
+        'PP.H4.abf': pp_abf[4]
+    }
+
+def sdY_est(vbeta, maf, n):
+    """
+    Estimate trait standard deviation given vectors of variance of coefficients, MAF and sample size.
+    
+    Args:
+        vbeta: vector of variance of coefficients
+        maf: vector of MAF (same length as vbeta)
+        n: sample size
+        
+    Returns:
+        float: estimated standard deviation of Y
+    """
+    oneover = 1/vbeta
+    nvx = 2 * n * maf * (1-maf)
+    # Fit linear regression through origin
+    coef = np.sum(nvx * oneover) / np.sum(oneover**2)
+    if coef < 0:
+        raise ValueError("Estimated sdY is negative - this can happen with small datasets, or those with errors. A reasonable estimate of sdY is required to continue.")
+    return np.sqrt(coef)

{genal_python-1.2.7 → genal_python-1.2.9}/genal/extract_prs.py

@@ -139,7 +139,7 @@ def extract_snps_func(snp_list, name, path=None):
     #Check that at least 1 variant has been extracted. If not, return "FAILED" to warn downstream functions (prs, association_test)
     log_path = output_path + ".log"
     with open(log_path, 'r') as log_file:
-        if "0 variants remaining" in log_file.read():
+        if " 0 variants remaining" in log_file.read():
             print("None of the provided SNPs were found in the genetic data.")
             return "FAILED"
         else:

{genal_python-1.2.7 → genal_python-1.2.9}/genal/proxy.py

@@ -193,9 +193,9 @@ def find_proxies(
     snp_list,
     searchspace=None,
     reference_panel="eur",
-    kb=5000,
+    kb=10000,
     r2=0.6,
-    window_snps=5000,
+    window_snps=10000,
     threads=1
 ):
     """

{genal_python-1.2.7 → genal_python-1.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "genal-python"  # Updated name for PyPI
-version = "1.2.7"
+version = "1.2.9"
 authors = [{name = "Cyprien Rivier", email = "riviercyprien@gmail.com"}]
 description = "A python toolkit for polygenic risk scoring and mendelian randomization."
 readme = "README.md"