gwaslab 3.5.1__py3-none-any.whl → 3.5.3__py3-none-any.whl

gwaslab/__init__.py

@@ -46,3 +46,4 @@ from gwaslab.util_ex_process_h5 import process_vcf_to_hfd5
 from gwaslab.util_ex_run_susie import _run_susie_rss as run_susie_rss
 from gwaslab.io_read_tabular import _read_tabular as read_tabular
 from gwaslab.util_in_meta import meta_analyze
+from gwaslab.viz_plot_scatter_with_reg import scatter

gwaslab/g_Sumstats.py

@@ -389,6 +389,12 @@ class Sumstats():
             self.data =flipallelestats(self.data,log=self.log,**flipallelestats_args)
             
             gc.collect()
+            
+        if (ref_seq is not None or ref_infer is not None) and (ref_rsid_tsv is not None or ref_rsid_vcf is not None):
+
+            self.data = fixID(self.data, log=self.log, **{"fixid":True, "fixsep":True, "overwrite":True})
+
+            gc.collect()
         
         #####################################################
         if ref_rsid_tsv is not None:
@@ -833,4 +839,4 @@ class Sumstats():
     def to_format(self, path, build=None, verbose=True, **kwargs):
         if build is None:
             build = self.meta["gwaslab"]["genome_build"]
-        _to_format(self.data, path, log=self.log, verbose=verbose, meta=self.meta, build=build, **kwargs)
+        _to_format(self.data, path, log=self.log, verbose=verbose, meta=self.meta, build=build, **kwargs)

gwaslab/g_version.py

@@ -15,8 +15,8 @@ def _get_version():
 def gwaslab_info():
     # version meta information
     dic={
-   "version":"3.5.1",
-   "release_date":"20241120"
+   "version":"3.5.3",
+   "release_date":"20241217"
     }
     return dic   
 

gwaslab/io_process_args.py

@@ -1,23 +1,40 @@
 import copy
-def _merge_and_sync_dic(list_of_dics:list, default:dict) -> dict:
-    temp = copy.copy(default)
-    for dic in list_of_dics:
-        if isinstance(dic, dict):
-            temp.update(dic)
-    return temp
 
 def _list_func_args(func):
     return func.__code__.co_varnames
 
 def _extract_kwargs(prefix:str, default:dict, kwargs:dict) -> dict:
+    # prefix: keyword
+    # default: default dict
+    # kwargs: all local kwargs  + args + kwargs
+
     extracted = []
+    extracted_single=dict()
     for key,value in kwargs.items():
+        # kwargs or args
         if key=="kwargs" or key=="args":
             for key_nested,value_nested in kwargs[key].items():
                 if prefix in key_nested and "arg" in key_nested:
-                    extracted.append(value_nested)
+
+                    if len(key_nested.split("_"))<3:
+                        extracted.append(value_nested)
+                    ##
+                    ## prefix_arg_fontsize
+                    else:
+                        print(key_nested.split("_")[-1], value)
+                        extracted_single[key_nested.split("_")[-1]] = value_nested
         else:
+            # local kwargs
             if prefix in key and "arg" in key:
                 extracted.append(value)
+    if len(extracted_single.keys()) >0:
+        extracted.append(extracted_single)
     merged_arg = _merge_and_sync_dic(extracted, default)
-    return merged_arg
+    return merged_arg
+
+def _merge_and_sync_dic(list_of_dics:list, default:dict) -> dict:
+    temp = copy.copy(default)
+    for dic in list_of_dics:
+        if isinstance(dic, dict):
+            temp.update(dic)
+    return temp

gwaslab/io_to_formats.py

@@ -28,6 +28,7 @@ from gwaslab.util_in_filter_value import _extract
 def _to_format(sumstats,
               path="./sumstats",
               fmt="gwaslab",   
+              tab_fmt="tsv",
               extract=None,
               exclude=None,
               cols=None,
@@ -39,7 +40,6 @@ def _to_format(sumstats,
               n=None,
               no_status=False,
               output_log=True,
-              to_csvargs=None,
               float_formats=None,
               xymt_number=False,
               xymt=None,
@@ -47,20 +47,30 @@ def _to_format(sumstats,
               meta=None,
               ssfmeta=False,
               md5sum=False,
+              gzip=True,
               bgzip=False,
               tabix=False,
               tabix_indexargs={},
+              to_csvargs=None,
+              to_tabular_kwargs=None,
               log=Log(),
               verbose=True):
     
-    if  to_csvargs is None:
-        to_csvargs = {}
+    if to_csvargs is None:
+        to_csvargs=dict()
+    if tabix_indexargs is None:
+        tabix_indexargs=dict()
+    if to_tabular_kwargs is None:
+        to_tabular_kwargs=dict()
     if  float_formats is None:
-        float_formats={}
+        float_formats=dict()
     if cols is None:
         cols=[]
     if xymt is None:
         xymt = ["X","Y","MT"]
+    non_gzip_tab_fmt = ["parquet"]
+    non_md5sum_tab_fmt = ["parquet"]
+
     onetime_log = copy.deepcopy(log)
 
     #######################################################################################################
@@ -154,6 +164,7 @@ def _to_format(sumstats,
         tofmt(output,
               path=path,
               fmt=fmt,
+              tab_fmt=tab_fmt,
               cols=cols,
               suffix=suffix,
               build=build,
@@ -164,9 +175,13 @@ def _to_format(sumstats,
                 chr_prefix=chr_prefix,
                 meta=meta,
                 ssfmeta=ssfmeta,
+                gzip=gzip,
                 bgzip=bgzip,
+                non_gzip_tab_fmt=non_gzip_tab_fmt,
+                non_md5sum_tab_fmt=non_md5sum_tab_fmt,
                 tabix=tabix,
                 tabix_indexargs=tabix_indexargs,
+                to_tabular_kwargs=to_tabular_kwargs,
                 md5sum=md5sum,
                 xymt_number=xymt_number,
                 xymt=xymt)
@@ -186,6 +201,7 @@ def tofmt(sumstats,
           path=None,
           suffix=None,
           fmt=None,
+          tab_fmt="csv",
           cols=[],
           xymt_number=False,
           xymt=["X","Y","MT"],
@@ -194,15 +210,16 @@ def tofmt(sumstats,
           ssfmeta=False,
           md5sum=False,
           bgzip=False,
+          gzip=True,
+          non_gzip_tab_fmt=None,
+          non_md5sum_tab_fmt=None,
           tabix=False,
-          tabix_indexargs={},
+          tabix_indexargs=None,
           verbose=True,
           no_status=False,
           log=Log(),
-          to_csvargs=None):
-    
-    if to_csvargs is None:
-        to_csvargs=dict()
+          to_csvargs=None,
+          to_tabular_kwargs=None):
     
     if fmt in ["ssf"]: 
         xymt_number=True
@@ -336,36 +353,86 @@ def tofmt(sumstats,
         _bgzip_tabix_md5sum(path, fmt, bgzip, md5sum, tabix, tabix_indexargs, log, verbose)
     
     ####################################################################################################################
-    elif fmt in get_formats_list():      
+    elif fmt in get_formats_list() :      
         # tabular 
         log.write(" -"+fmt+" format will be loaded...",verbose=verbose)
         meta_data,rename_dictionary = get_format_dict(fmt,inverse=True)
         print_format_info(fmt=fmt, meta_data=meta_data,rename_dictionary=rename_dictionary,verbose=verbose, log=log, output=True)
         
-        yaml_path = path + "."+suffix+".tsv-meta.yaml"
-        path = path + "."+suffix+".tsv.gz"
+        # determine if gzip or not / create path for output
+        if gzip ==True and tab_fmt not in non_gzip_tab_fmt:
+            path = path + "."+suffix+".{}.gz".format(tab_fmt)
+        else:
+            path = path + "."+suffix+".{}".format(tab_fmt)
+
+        yaml_path = path + "."+suffix+".{}-meta.yaml".format(tab_fmt)
         log.write(" -Output path:",path, verbose=verbose) 
-        
+
         sumstats,to_csvargs = _configure_output_cols_and_args(sumstats, rename_dictionary, cols, no_status, path, meta_data, to_csvargs, log, verbose)
         
         log.write(" -Writing sumstats to: {}...".format(path),verbose=verbose)
-        try:
-            fast_to_csv(sumstats, path, to_csvargs=to_csvargs, compress=True, write_in_chunks=True)
-        except:
-            log.write(f"Error in using fast_to_csv. Falling back to original implementation.",verbose=verbose)
-            sumstats.to_csv(path, index=None, **to_csvargs)
-
-        if md5sum == True: 
-            md5_value = md5sum_file(path,log,verbose)
-        else:
-            md5_value = calculate_md5sum_file(path)
         
+        #if tab_fmt=="tsv" or tab_fmt=="csv":
+        #    try:
+        #        log.write(f"  -Fast to csv mode...",verbose=verbose)
+        #        fast_to_csv(sumstats, path, to_csvargs=to_csvargs, compress=True, write_in_chunks=True)
+        #    except:
+        #        log.write(f"Error in using fast_to_csv. Falling back to original implementation.",verbose=verbose)
+        #        sumstats.to_csv(path, index=None, **to_csvargs)
+#
+        #elif tab_fmt=="parquet":
+        #    sumstats.to_parquet(path, index=None, **to_tabular_kwargs)
+        _write_tabular(sumstats,rename_dictionary, path, tab_fmt, to_csvargs, to_tabular_kwargs, log, verbose)
+        
+        if tab_fmt not in non_md5sum_tab_fmt and "@" not in path:
+            if md5sum == True: 
+                # write a md5sum file
+                md5_value = md5sum_file(path,log,verbose)
+            else:
+                # calculate md5sum without saveing a file
+                md5_value = calculate_md5sum_file(path)
+        else:
+            md5_value = "NA"
+
         ## update ssf-style meta data and export to yaml file
         _configure_ssf_meta(sumstats, fmt, ssfmeta, meta, meta_data, path, md5_value, yaml_path, log, verbose)
         
         return sumstats  
     
 ####################################################################################################################
+def _write_tabular(sumstats,rename_dictionary, path, tab_fmt, to_csvargs, to_tabular_kwargs, log, verbose):
+    chr_header = rename_dictionary["CHR"]
+    if tab_fmt=="tsv" or tab_fmt=="csv":
+        try:
+            log.write(f"  -Fast to csv mode...",verbose=verbose)
+            if "@" in path:
+                log.write(f"  -@ detected: writing each chromosome to a single file...",verbose=verbose)
+                log.write("  -Chromosomes:{}...".format(list(sumstats["CHR"].unique())),verbose=verbose)
+                for single_chr in list(sumstats["CHR"].unique()):
+                    single_path = path.replace("@",single_chr)
+
+                    fast_to_csv(sumstats.loc[sumstats[chr_header]==single_chr,:],
+                                 single_path, 
+                                 to_csvargs=to_csvargs, compress=True, write_in_chunks=True)
+            else:
+                fast_to_csv(sumstats, path, to_csvargs=to_csvargs, compress=True, write_in_chunks=True)
+        except:
+            log.write(f"Error in using fast_to_csv. Falling back to original implementation.",verbose=verbose)
+            if "@" in path:
+                log.write(f"  -@ detected: writing each chromosome to a single file...",verbose=verbose)
+                log.write("  -Chromosomes:{}...".format(list(sumstats["CHR"].unique())),verbose=verbose)
+                for single_chr in list(sumstats["CHR"].unique()):
+                    single_path = path.replace("@",single_chr)
+
+                    sumstats.loc[sumstats[chr_header]==single_chr,:].to_csv(path, index=None, **to_csvargs)
+            else:
+                sumstats.to_csv(path, index=None, **to_csvargs)
+
+    elif tab_fmt=="parquet":
+        sumstats.to_parquet(path, index=None, **to_tabular_kwargs)
+
+
+
 def fast_to_csv(dataframe, path, to_csvargs=None, compress=True, write_in_chunks=True):
         df_numpy = dataframe.to_numpy()
 

gwaslab/viz_aux_annotate_plot.py

@@ -31,6 +31,7 @@ def annotate_single(
     arm_scale_d,
     arm_offset,
     anno_adjust,
+    anno_xshift,
     anno_fixed_arm_length,
     maxy,
     anno_fontsize,
@@ -158,6 +159,8 @@ def annotate_single(
             if anno_fixed_arm_length is not None:
                 xytext=(row["i"],row["scaled_P"] + 0.2 + anno_fixed_arm_length)
 
+            if anno_xshift is not None:
+                xytext = (xytext[0] +(anno_xshift*y_span), xytext[1])
             ################################################################################################################################
             # if not changing the directions of some annotation arror arms 
             if anno_count not in anno_d.keys():

gwaslab/viz_aux_chromatin.py

@@ -99,7 +99,7 @@ def _plot_chromatin_state(region_chromatin_files,
             color=color_dict_i[row["STATE_i"]]
             ax.plot([offset_i + row["START"] ,offset_i + row["END"]],
                     [i*0.1,i*0.1],
-                    c=color/255,linewidth=points_for_01,solid_capstyle="butt")
+                    c=color/255,linewidth=points_for_01,solid_capstyle="butt",rasterized=True)
     
     ## add stripe label
     if len(region_chromatin_labels) == len(region_chromatin_files):

gwaslab/viz_aux_quickfix.py

@@ -1,6 +1,8 @@
 import pandas as pd
 import numpy as np
 from gwaslab.g_Log import Log
+from matplotlib import ticker
+import matplotlib.pyplot as plt
 from gwaslab.bd_common_data import get_chr_to_number
 from gwaslab.bd_common_data import get_number_to_chr
 from math import ceil
@@ -350,7 +352,7 @@ def _cut(series, mode,cutfactor,cut,skip, ylabels, cut_log, verbose, lines_to_pl
                 #sumstats.loc[sumstats["scaled_P"]>cut,"scaled_P"] = (sumstats.loc[sumstats["scaled_P"]>cut,"scaled_P"]-cut)/cutfactor +  cut
                 
                 maxy = (maxticker-cut)/cutfactor + cut
-    
+
     return series, maxy, maxticker, cut, cutfactor,ylabels,lines_to_plot
 
 #def _cut_line(level, mode,cutfactor,cut,skip, ylabels, cut_log, verbose, log):
@@ -379,10 +381,9 @@ def _set_yticklabels(cut,
     log.write(" -Processing Y tick lables...",verbose=verbose)
     # if no cut
     if cut == 0: 
-            ax1.set_ylim(skip, ceil(maxy*1.2) )
-
+            ax1.set_ylim((skip, ceil(maxy*1.2)) )
     # if cut     
-    if cut:
+    if cut!=0:
         # add cut line
         
         cutline = ax1.axhline(y=cut, linewidth = sc_linewidth,linestyle="--",color=cut_line_color,zorder=1)
@@ -432,14 +433,15 @@ def _set_yticklabels(cut,
         else:
             ax1.set_yticks(ticks1+ticks2)
             ax1.set_yticklabels(tickslabel1+tickslabel2,fontsize=fontsize,family=font_family)
-        ax1.set_ylim(bottom = skip)
     
     if ylabels is not None:  
         ax1.set_yticks(ylabels_converted)
         ax1.set_yticklabels(ylabels,fontsize=fontsize,family=font_family)
     
+    ylim_top = ax1.get_ylim()[1]
+    ax1.set_ybound(lower=skip,upper=ylim_top)
     ax1.tick_params(axis='y', labelsize=fontsize)
-    
+
     return ax1
 
 def _jagged_y(cut,skip,ax1,mode,mqqratio,jagged_len,jagged_wid, log=Log(), verbose=True):

gwaslab/viz_aux_save_figure.py

@@ -51,7 +51,8 @@ def get_default_path(keyword,fmt="png"):
                         "miami":"miami",
                         "esc":"effect_size_comparision",
                         "afc":"allele_frequency_comparision",
-                        "gwheatmap":"genome_wide_heatmap"
+                        "gwheatmap":"genome_wide_heatmap",
+                        "scatter":"scatter"
                         }
     prefix = path_dictionary[keyword]
     count = 1

gwaslab/viz_plot_mqqplot.py

@@ -25,6 +25,7 @@ from gwaslab.viz_plot_qqplot import _plot_qq
 from gwaslab.hm_harmonize_sumstats import auto_check_vcf_chr_dict
 from gwaslab.viz_plot_regional2 import _plot_regional
 from gwaslab.viz_plot_regional2 import process_vcf
+from gwaslab.viz_plot_regional2 import _get_lead_id
 from gwaslab.viz_aux_quickfix import _get_largenumber
 from gwaslab.viz_aux_quickfix import _quick_fix_p_value
 from gwaslab.viz_aux_quickfix import _quick_fix_pos
@@ -107,6 +108,7 @@ def mqqplot(insumstats,
           region_flank_factor = 0.05,
           region_anno_bbox_args = None,
           region_marker_shapes=None,
+          region_legend_marker=True,
           cbar_title='LD $r^{2}$ with variant',
           cbar_fontsize = None,
           cbar_font_family = None,
@@ -138,6 +140,7 @@ def mqqplot(insumstats,
           anno_source = "ensembl",
           anno_gtf_path=None,
           anno_adjust=False,
+          anno_xshift=None,
           anno_max_iter=100,
           arrow_kwargs=None,
           arm_offset=None,
@@ -233,7 +236,7 @@ def mqqplot(insumstats,
     if "dpi" not in fig_args.keys():
         fig_args["dpi"] = dpi
     if region_anno_bbox_args is None:
-        region_anno_bbox_args = dict()
+        region_anno_bbox_args = {"ec":"None","fc":"None"}
     if anno_set is None:
         anno_set=list()
     if anno_alias is None:
@@ -264,7 +267,7 @@ def mqqplot(insumstats,
         
     if region_marker_shapes is None:
         # 9 shapes
-        region_marker_shapes = ['o', 's','^','D','*','P','X','h','8']
+        region_marker_shapes = ['o', '^','s','D','*','P','X','h','8']
     if region_grid_line is None:
         region_grid_line = {"linewidth": 2,"linestyle":"--"}
     if region_lead_grid_line is None:
@@ -626,7 +629,8 @@ def mqqplot(insumstats,
             sumstats["chr_hue"]=sumstats["LD"]
                 
         ## default seetings
-        
+        # assign to_plot for scatter plot
+        to_plot = None
         palette = sns.color_palette(colors,n_colors=sumstats[chrom].nunique())  
 
         legend = None
@@ -639,7 +643,18 @@ def mqqplot(insumstats,
             legend=None
             linewidth=1
             if len(region_ref) == 1:
+                # hide lead variants -> add back in region plot 
                 palette = {100+i:region_ld_colors[i] for i in range(len(region_ld_colors))}
+                scatter_args["markers"]= {(i+1):m for i,m in enumerate(region_marker_shapes[:2])}
+                if region_ref[0] is None:
+                    id_to_hide = sumstats["scaled_P"].idxmax()
+                    to_plot = sumstats.drop(id_to_hide, axis=0)
+                else:
+                    #id_to_hide = sumstats[sumstats["SNPID"]==region_ref[0],"scaled_P"].idxmax()
+                    id_to_hide = _get_lead_id(sumstats, region_ref, log=log, verbose=verbose)
+                    if id_to_hide is not None:
+                        to_plot = sumstats.drop(id_to_hide, axis=0)
+                style="SHAPE"
             else:
                 palette = {}
                 region_color_maps = []
@@ -652,21 +667,24 @@ def mqqplot(insumstats,
                         # 1 + 5 + 1
                         region_ld_colors_single = [region_ld_colors[0]] + output_hex_colors + [output_hex_colors[-1]]
                     region_color_maps.append(region_ld_colors_single)
-                # gradient colors
+                
+                # gradient color dict
                 for i, hex_colors in enumerate(region_color_maps):
                     for j, hex_color in enumerate(hex_colors):
                         palette[(i+1)*100 + j ] = hex_color
 
                 edgecolor="none"
+                # create a marker shape dict
                 scatter_args["markers"]= {(i+1):m for i,m in enumerate(region_marker_shapes[:len(region_ref)])}
                 style="SHAPE"
 
-            
+        
         ## if highlight 
         highlight_i = pd.DataFrame()
         if len(highlight) >0:
+            to_plot = sumstats
             log.write(" -Creating background plot...",verbose=verbose)
-            plot = sns.scatterplot(data=sumstats, x='i', y='scaled_P',
+            plot = sns.scatterplot(data=to_plot, x='i', y='scaled_P',
                                hue='chr_hue',
                                palette=palette,
                                legend=legend,
@@ -678,7 +696,7 @@ def mqqplot(insumstats,
             if pd.api.types.is_list_like(highlight[0]) and highlight_chrpos==False:
                 for i, highlight_set in enumerate(highlight):
                     log.write(" -Highlighting set {} target loci...".format(i+1),verbose=verbose)
-                    sns.scatterplot(data=sumstats.loc[sumstats["HUE"]==i], x='i', y='scaled_P',
+                    sns.scatterplot(data=to_plot.loc[to_plot["HUE"]==i], x='i', y='scaled_P',
                         hue="HUE",
                         palette={i:highlight_color[i%len(highlight_color)]},
                         legend=legend,
@@ -687,10 +705,10 @@ def mqqplot(insumstats,
                         sizes=(marker_size[0]+1,marker_size[1]+1),
                         linewidth=linewidth,
                         zorder=3+i,ax=ax1,edgecolor=edgecolor,**scatter_args)  
-                highlight_i = sumstats.loc[~sumstats["HUE"].isna(),"i"].values
+                highlight_i = to_plot.loc[~to_plot["HUE"].isna(),"i"].values
             else:
                 log.write(" -Highlighting target loci...",verbose=verbose)
-                sns.scatterplot(data=sumstats.loc[sumstats["HUE"]==0], x='i', y='scaled_P',
+                sns.scatterplot(data=to_plot.loc[to_plot["HUE"]==0], x='i', y='scaled_P',
                     hue="HUE",
                     palette={0:highlight_color},
                     legend=legend,
@@ -701,7 +719,7 @@ def mqqplot(insumstats,
                     zorder=3,ax=ax1,edgecolor=edgecolor,**scatter_args)  
                 # for annotate
                 if highlight_chrpos==False:
-                    highlight_i = sumstats.loc[sumstats[snpid].isin(highlight),"i"].values
+                    highlight_i = to_plot.loc[to_plot[snpid].isin(highlight),"i"].values
                 else:
                     highlight_i = []
         
@@ -739,7 +757,8 @@ def mqqplot(insumstats,
                 s = "s"
                 hue = 'chr_hue'
                 hue_norm=None
-                to_plot = sumstats
+                if to_plot is None:
+                    to_plot = sumstats
                 log.write(" -Creating background plot...",verbose=verbose)
                 plot = sns.scatterplot(data=to_plot, x='i', y='scaled_P',
                        hue=hue,
@@ -814,6 +833,7 @@ def mqqplot(insumstats,
                                 region_title=region_title,
                                 region_title_args=region_title_args,
                                 region_ld_legend = region_ld_legend,
+                                region_legend_marker=region_legend_marker,
                                 region_ld_threshold = region_ld_threshold,
                                 region_ld_colors = region_ld_colors,
                                 palette = palette,
@@ -996,6 +1016,7 @@ def mqqplot(insumstats,
                                 arm_scale_d=arm_scale_d,
                                 arm_offset=arm_offset,
                                 anno_adjust=anno_adjust,
+                                anno_xshift=anno_xshift,
                                 anno_fixed_arm_length=anno_fixed_arm_length,
                                 maxy=maxy,
                                 anno_fontsize= anno_fontsize,
@@ -1396,14 +1417,19 @@ def _process_xtick(ax1, chrom_df, xtick_chr_dict, fontsize, font_family, log=Log
 
 def _process_ytick(ax1, fontsize, font_family, ax4, log=Log(),verbose=True):
     log.write(" -Processing Y labels...",verbose=verbose)
-    ax1_yticklabels = ax1.get_yticklabels()
+    #ax1_yticklabels = ax1.get_yticklabels()
+    #print(ax1_yticklabels)
+    #plt.draw()
+    #ax1_yticks = ax1.get_yticks()
+    #print(ax1_yticks)
     #ax1.set_yticklabels(ax1_yticklabels,fontsize=fontsize,family=font_family) 
-    ax1_yticks = ax1.get_yticks()
-    ax1.set_yticks(ax1_yticks,ax1_yticklabels,fontsize=fontsize,family=font_family) 
+    ax1.tick_params(axis='y', labelsize=fontsize,labelfontfamily=font_family)
+    #ax1.set_yticks(ax1_yticks,ax1_yticklabels,fontsize=fontsize,family=font_family) 
     if ax4 is not None:
-        ax4_yticklabels = ax4.get_yticklabels()
-        ax4_yticks = ax4.get_yticks()
-        ax4.set_yticks(ax4_yticks,ax4_yticklabels, fontsize=fontsize,family=font_family) 
+        #ax4_yticklabels = ax4.get_yticklabels()
+        #ax4_yticks = ax4.get_yticks()
+        ax4.tick_params(axis='y', labelsize=fontsize,labelfontfamily=font_family)
+        #ax4.set_yticks(ax4_yticks,ax4_yticklabels, fontsize=fontsize,family=font_family) 
     return ax1, ax4
 
 def _process_xlabel(region, xlabel, ax1, gtf_path, mode, fontsize, font_family,  ax3=None , log=Log(),verbose=True):

gwaslab/viz_plot_regional2.py

@@ -70,6 +70,7 @@ def _plot_regional(
     palette=None,
     region_recombination = True,
     region_protein_coding=True,
+    region_legend_marker=True,
     region_flank_factor = 0.05,
     track_font_family="Arial",
     taf=[4,0,0.95,1,1],
@@ -93,6 +94,7 @@ def _plot_regional(
             ax1, lead_id_single = _pinpoint_lead(sumstats = sumstats,
                                         ax1 = ax1, 
                                         region_ref=region_ref_single,
+                                        region_ref_total_n = len(region_ref), 
                                         lead_color = palette[(index+1)*100 + len(region_ld_threshold)+2], 
                                         marker_size= marker_size,
                                         region_marker_shapes=region_marker_shapes,
@@ -130,7 +132,10 @@ def _plot_regional(
                             region_ref=region_ref,
                             region_ld_threshold=region_ld_threshold, 
                             region_ref_index_dic=region_ref_index_dic,
-                            palette=palette)
+                            region_marker_shapes=region_marker_shapes,
+                            palette=palette,
+                            region_legend_marker=region_legend_marker,
+                            fig=fig)
         else:
             cbar=None
 
@@ -241,6 +246,10 @@ def _plot_regional(
 
 # + ###########################################################################################################################################################################
 def _get_lead_id(sumstats=None, region_ref=None, log=None, verbose=True):
+    # region_ref_single (not none) -> specified variant ID
+    # convert region_ref_single -> lead_id(index)
+    
+    #
     region_ref_to_check = copy.copy(region_ref)
     try: 
         if len(region_ref_to_check)>0 and type(region_ref_to_check) is not str:
@@ -250,24 +259,30 @@ def _get_lead_id(sumstats=None, region_ref=None, log=None, verbose=True):
     
     lead_id=None
     
+    # match by rsID 
     if "rsID" in sumstats.columns:
         lead_id = sumstats.index[sumstats["rsID"] == region_ref_to_check].to_list()
-
+    # match by SNPID
     if lead_id is None and "SNPID" in sumstats.columns:
         lead_id = sumstats.index[sumstats["SNPID"] == region_ref_to_check].to_list()
 
+    # if duplicated, select the first one
     if type(lead_id) is list:
         if len(lead_id)>0:
             lead_id = int(lead_id[0])
 
+
     if region_ref_to_check is not None:
         if type(lead_id) is list:
             if len(lead_id)==0 :
                 #try:
+                # if region_ref_to_check is in CHR:POS:NEA:EA format
                 matched_snpid = re.match("(chr)?[0-9]+:[0-9]+:[ATCG]+:[ATCG]+", region_ref_to_check,  re.IGNORECASE)    
                 if matched_snpid is None:
+                    # if not, pass
                     pass
                 else:
+                    # if region_ref_to_check is in CHR:POS:NEA:EA format, match by CHR:POS:NEA:EA
                     lead_snpid = matched_snpid.group(0).split(":")
                     if len(lead_snpid)==4:
                         lead_chr= int(lead_snpid[0])
@@ -300,7 +315,7 @@ def _get_lead_id(sumstats=None, region_ref=None, log=None, verbose=True):
 
     return lead_id
 
-def _pinpoint_lead(sumstats,ax1,region_ref, lead_color, marker_size, log, verbose, region_marker_shapes):
+def _pinpoint_lead(sumstats,ax1,region_ref, region_ref_total_n, lead_color, marker_size, log, verbose, region_marker_shapes):
     
     if region_ref is None:
         log.write(" -Extracting lead variant..." , verbose=verbose)
@@ -308,12 +323,20 @@ def _pinpoint_lead(sumstats,ax1,region_ref, lead_color, marker_size, log, verbos
     else:
         lead_id = _get_lead_id(sumstats, region_ref, log, verbose)
     
+    if lead_id is not None:
+        if region_ref_total_n <2:
+            # single-ref mode
+            marker_shape = region_marker_shapes[sumstats.loc[lead_id,"SHAPE"]]
+        else:
+            # multi-ref mode
+            marker_shape = region_marker_shapes[sumstats.loc[lead_id,"SHAPE"]-1]
+
     if lead_id is not None:
         ax1.scatter(sumstats.loc[lead_id,"i"],sumstats.loc[lead_id,"scaled_P"],
                 color=lead_color,
                 zorder=3,
-                marker= region_marker_shapes[sumstats.loc[lead_id,"SHAPE"]-1],
-                s=marker_size[1]+2,
+                marker= marker_shape,
+                s=marker_size[1]*1.5,
                 edgecolor="black")
 
     return ax1, lead_id
@@ -322,14 +345,15 @@ def _add_region_title(region_title, ax1,region_title_args):
     ax1.text(0.015,0.97, region_title, transform=ax1.transAxes, va="top", ha="left", region_ref=None, **region_title_args )
     return ax1
 
-def _add_ld_legend(sumstats, ax1, region_ld_threshold, region_ref,region_ref_index_dic,palette =None, position=1):
+def _add_ld_legend(sumstats, ax1, region_ld_threshold, region_ref,region_ref_index_dic,region_marker_shapes,fig, region_legend_marker=True,palette =None, position=1):
     
     width_pct = "11%"
     height_pct = "{}%".format( 14 + 7 * len(region_ref))
     axins1 = inset_axes(ax1,
             width=width_pct,  # width = 50% of parent_bbox width
             height=height_pct,  # height : 5%
-            loc='upper right',axes_kwargs={"frameon":True,"facecolor":"white","zorder":999999})
+            loc='upper right',
+            axes_kwargs={"frameon":True,"facecolor":"white","zorder":999999})
     
     ld_ticks = [0]+region_ld_threshold+[1]
 
@@ -345,7 +369,7 @@ def _add_ld_legend(sumstats, ax1, region_ld_threshold, region_ref,region_ref_ind
                 a = Rectangle((x,y),width, height, fill = True, color = hex_color , linewidth = 2)
                 #patches.append(a)
                 axins1.add_patch(a)
-
+    
     # y snpid
     yticks_position = 0.1 + 0.2 *np.arange(0,len(region_ref))
     axins1.set_yticks(yticks_position, ["{}".format(x) for x in region_ref])
@@ -354,9 +378,35 @@ def _add_ld_legend(sumstats, ax1, region_ld_threshold, region_ref,region_ref_ind
     # x ld thresholds
     axins1.set_xticks(ticks=ld_ticks) 
     axins1.set_xticklabels([str(i) for i in ld_ticks]) 
-    axins1.set_xlim(0,1)    
 
+    xmin, xmax = 0, 1
+    axins1.set_xlim(xmin,xmax)    
+
+    ############### ##############plot marker ############## ##############
+    if region_legend_marker==True:
+        for group_index, ref in enumerate(region_ref):
+            x= -0.1
+            y= 0.1 + 0.2 * group_index
+            
+            if len(region_ref) <2:
+                # single-ref mode
+                marker = region_marker_shapes[group_index+1]
+                c =  palette[(region_ref_index_dic[region_ref[group_index]]+1)*100 + len(ld_ticks)]
+            else:
+                # multi-ref mode
+                marker = region_marker_shapes[group_index]
+                c =  palette[(region_ref_index_dic[region_ref[group_index]]+1)*100 + len(ld_ticks)-1]
+            
+            # ([x0,y0][x1,y1])
+            data_to_point =(axins1.bbox.get_points()[1][0]-axins1.bbox.get_points()[0][0]) / (xmax - xmin)
+            s =  (data_to_point * 0.15*0.11/(fig.dpi/72))**2 
+            
+            axins1.scatter(x, y, s=s, marker=marker,c=c, edgecolors="black", linewidths = 1,  clip_on=False, zorder=100)
+            axins1.tick_params(axis="y", pad=data_to_point* 0.11* 0.19/(fig.dpi/72))
+    
+    axins1.set_xlim(0,1)   
     axins1.set_aspect('equal', adjustable='box')
+    #axins1.tick_params(axis="y", pad=data_to_point* 0.11* 0.19/(fig.dpi/72))
     axins1.set_title('LD $r^{2}$ with variant',loc="center",y=-0.2)
     cbar = axins1
     return ax1, cbar
@@ -434,6 +484,7 @@ def _plot_gene_track(
     font_size_in_pixels= taf[2] * pixels_per_track
     font_size_in_points =  font_size_in_pixels * pixels_per_point
     linewidth_in_points=   pixels_per_track * pixels_per_point
+
     log.write(" -plotting gene track..", verbose=verbose)
     
     sig_gene_name = "Undefined"
@@ -446,6 +497,7 @@ def _plot_gene_track(
     sig_gene_names=[]
     sig_gene_lefts=[]
     sig_gene_rights=[]
+    log.write(" -plotting genes: {}..".format(len(uniq_gene_region)), verbose=verbose)
     for index,row in uniq_gene_region.iterrows():
 
         gene_color="#020080"
@@ -464,9 +516,9 @@ def _plot_gene_track(
                 sig_gene_lefts.append(gene_track_start_i+row["start"])
                 sig_gene_rights.append(gene_track_start_i+row["end"])
 
-            # plot gene line
-            ax3.plot((gene_track_start_i+row["start"],gene_track_start_i+row["end"]),
-                        (row["stack"]*2,row["stack"]*2),color=gene_color,linewidth=linewidth_in_points/10)
+        # plot gene line
+        ax3.plot((gene_track_start_i+row["start"],gene_track_start_i+row["end"]),
+                    (row["stack"]*2,row["stack"]*2),color=gene_color,linewidth=linewidth_in_points/10,solid_capstyle="butt")
         
         # plot gene name
         if row["end"] >= region[2]:
@@ -483,6 +535,7 @@ def _plot_gene_track(
                     y=row["stack"]*2+taf[4],s=gene_anno,ha="center",va="center",color="black",style='italic',size=font_size_in_points,family=track_font_family))
     
     # plot exons
+    log.write(" -plotting exons: {}..".format(len(exons)), verbose=verbose)
     for index,row in exons.iterrows():
         exon_color="#020080" 
         for sig_gene_name, sig_gene_left, sig_gene_right in zip(sig_gene_names,sig_gene_lefts,sig_gene_rights):
@@ -664,6 +717,10 @@ def process_vcf(sumstats,
     sumstats[final_shape_col] = 1
     sumstats[final_rsq_col] = 0.0
     
+    if len(region_ref)==1:
+        if lead_id is not None:
+            sumstats.loc[lead_id, final_shape_col] +=1 
+
     for i in range(len(region_ref)):
         ld_single = "LD_{}".format(i)
         current_rsq = "RSQ_{}".format(i)
@@ -672,7 +729,6 @@ def process_vcf(sumstats,
         sumstats.loc[a_ngt_b, final_ld_col] = 100 * (i+1) + sumstats.loc[a_ngt_b, ld_single]
         sumstats.loc[a_ngt_b, final_rsq_col] = sumstats.loc[a_ngt_b, current_rsq]
         sumstats.loc[a_ngt_b, final_shape_col] = i + 1
-
     ####################################################################################################
     log.write("Finished loading reference genotype successfully!", verbose=verbose)
     return sumstats

gwaslab/viz_plot_scatter_with_reg.py

@@ -0,0 +1,229 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import scipy.stats as ss
+import seaborn as sns
+import gc
+import math
+import scipy.stats as ss
+from matplotlib.patches import Rectangle
+from adjustText import adjust_text
+from gwaslab.viz_aux_save_figure import save_figure
+from gwaslab.util_in_get_sig import getsig
+from gwaslab.util_in_get_sig import annogene
+from gwaslab.g_Log import Log
+from gwaslab.util_in_correct_winnerscurse import wc_correct
+from gwaslab.util_in_correct_winnerscurse import wc_correct_test
+from gwaslab.g_Sumstats import Sumstats
+from gwaslab.io_process_args import _merge_and_sync_dic
+from gwaslab.io_process_args import _extract_kwargs
+
+def scatter(df, 
+            x, 
+            y,
+            mode="0",
+            reg_box=None,
+            is_reg=True,
+            fdr=False,
+            allele_match=False,
+            r_se=False,
+            is_45_helper_line=False,
+            plt_args=None,
+            xylabel_prefix="Per-allele effect size in ",
+            helper_line_args=None,
+            font_args=None,
+            fontargs=None,
+            build="19",
+            r_or_r2="r",
+            err_kwargs=None,
+            legend_args=None,
+            log = Log(),
+            save=False,
+            reg_xmin=None,
+            verbose=True,
+            save_args=None,
+            scatter_kwargs=None,
+            font_kwargs=None,
+            plt_kwargs=None,
+            null_beta=0,
+            engine="plt",
+            **kwargs):
+    
+    if save_args is None:
+        save_args = {"dpi":300,"facecolor":"white"}
+    if reg_box is None:
+        reg_box = dict(boxstyle='round', facecolor='white', alpha=1,edgecolor="None")
+    if err_kwargs is None:
+        err_kwargs={"ecolor":"#cccccc","elinewidth":1}
+    if font_kwargs is None:
+        font_kwargs={'fontsize':12,'family':'sans','fontname':'Arial'}
+    if helper_line_args is None:
+        helper_line_args={"color":'black', "linestyle":'-',"lw":1}
+    if plt_kwargs is None:
+        plt_kwargs={"figsize":(8,8),"dpi":300}
+    if scatter_kwargs is None:
+        scatter_kwargs={"s":20}
+    if reg_xmin is None:
+        reg_xmin = df[x].min()
+    
+    save_kwargs =      _extract_kwargs("save", save_args, locals())
+    err_kwargs =       _extract_kwargs("err", err_kwargs, locals())
+    plt_kwargs =       _extract_kwargs("plt", plt_kwargs,  locals())
+    scatter_kwargs =   _extract_kwargs("scatter", scatter_kwargs, locals())
+    font_kwargs =      _extract_kwargs("font",font_kwargs, locals())
+
+    log.write("Start to create scatter plot...", verbose=verbose)
+    fig,ax = plt.subplots(**plt_kwargs) 
+
+   # plot x=0,y=0, and a 45 degree line
+    xl,xh=ax.get_xlim()
+    yl,yh=ax.get_ylim()
+
+    #ax.axhline(y=0, zorder=1,**helper_line_args)
+    #ax.axvline(x=0, zorder=1,**helper_line_args)
+    
+    #for spine in ['top', 'right']:
+    #    ax.spines[spine].set_visible(False)
+    
+    log.write(" -Creating scatter plot : {} - {}...".format(x, y), verbose=verbose)
+    if engine=="plt":
+        ax.scatter(df[x],df[y],**scatter_kwargs)
+    elif engine=="sns":
+        sns.scatterplot(data=df,x=x,y=y,ax=ax,**scatter_kwargs)
+    ###regression line##############################################################################################################################
+    ax, reg = confire_regression_line(x, y,
+                                 is_reg,
+                                 reg_box, 
+                                 df, 
+                                 ax, 
+                                 mode,
+                                 xl,
+                                 yl,
+                                 xh,
+                                 yh, 
+                                 null_beta, 
+                                 r_se, 
+                                is_45_helper_line,
+                                helper_line_args, 
+                                font_kwargs,
+                                log, 
+                                verbose, reg_xmin)
+    
+    save_figure(fig = fig, save = save, keyword="scatter", save_args=save_args, log = log, verbose=verbose)
+
+    return fig, ax, reg
+
+
+def confire_regression_line(x, y, is_reg, reg_box, df,  ax, mode,xl,yl,xh,yh, null_beta, r_se, 
+                            is_45_helper_line,helper_line_args, font_kwargs,
+                            log, verbose, reg_xmin):
+    # if N <3
+    if len(df)<3: 
+        is_reg=False
+    
+    if is_reg is True:
+        # reg 
+        # slope, intercept, r, p, slope_se, intercept_se
+        if mode=="0":
+            reg = ss.linregress(df[x],df[y])
+            # estimate se for r
+            if r_se==True:
+                log.write(" -Estimating SE for rsq using Jackknife method.", verbose=verbose)
+                r_se_jackknife = jackknife_r(df,x,y,log,verbose)
+                r_se_jackknife_string = " ({:.2f})".format(r_se_jackknife)
+            else:
+                r_se_jackknife_string= ""
+        else:
+            reg = ss.linregress(df[x],df[y])
+            r_se_jackknife_string= ""
+
+        #### calculate p values based on selected value , default = 0 
+        create_reg_log(reg, log, verbose)
+
+        reg_string = create_reg_string(reg, 
+                    r_se_jackknife_string)
+        
+        ax.text(0.99,0.01, reg_string, va="bottom",ha="right",transform=ax.transAxes,bbox=reg_box,**font_kwargs)
+        
+        ax = create_helper_line(ax, reg[0], is_45_helper_line, helper_line_args, reg_xmin=reg_xmin)
+        ax = create_reg_line(ax, reg, reg_xmin=reg_xmin)
+
+    return ax, reg
+
+#############################################################################################################################################################################
+def create_reg_log(reg,log, verbose):
+    #t_score = (reg[0]-null_beta) / reg[4]
+    #degree = len(df.dropna())-2
+    p =  reg[3]
+    #ss.t.sf(abs(t_score), df=degree)*2
+    log.write(" -Beta = ", reg[0], verbose=verbose)
+    log.write(" -Beta_se = ", reg[4], verbose=verbose)
+    log.write(" -H0 beta =  0",", default p = ", "{:.2e}".format(reg[3]), verbose=verbose)
+    log.write(" -Peason correlation coefficient =  ", "{:.2f}".format(reg[2]), verbose=verbose)
+    log.write(" -r2 =  ", "{:.2f}".format(reg[2]**2), verbose=verbose)
+
+def create_helper_line(ax, 
+                       slope,
+                       is_45_helper_line, 
+                       helper_line_args,
+                       reg_xmin=0):
+    
+    if is_45_helper_line is True:
+        xl,xh=ax.get_xlim()
+        yl,yh=ax.get_ylim()
+        if slope >0:
+            ax.axline([min(xl,yl),min(xl,yl)], [max(xh, yh),max(xh, yh)],zorder=1,**helper_line_args)
+        else:
+            ax.axline([min(xl,yl),-min(xl,yl)], [max(xh, yh),-max(xh, yh)],zorder=1,**helper_line_args)
+
+    return ax
+
+def create_reg_line(ax, reg, reg_xmin=0):
+    xy1 = (reg_xmin,reg[0]*reg_xmin+reg[1])
+    ax.axline(xy1=xy1,slope=reg[0],color="#cccccc",linestyle='--',zorder=1)
+    return ax
+
+def create_reg_string(reg,  
+                      r_se_jackknife_string):
+    p = reg[2]
+    try:
+        p12=str("{:.2e}".format(p)).split("e")[0]
+        pe =str(int("{:.2e}".format(p).split("e")[1]))
+    except:
+        p12="0"
+        pe="0"
+
+    p_text="$p = " + p12 + " \\times  10^{"+pe+"}$"
+    p_latex= f'{p_text}'
+
+    reg_string = "$y =$ "+"{:.2f}".format(reg[1]) +" $+$ "+ "{:.2f}".format(reg[0])+" $x$, "+ p_latex + ", $r =$" +"{:.2f}".format(reg[2])+r_se_jackknife_string
+    
+    return reg_string
+
+def jackknife_r(df,x,y,log,verbose):
+    """Jackknife estimation of se for rsq
+    """
+
+    # dropna
+    df_nona = df.loc[:,[x,y]].dropna()
+    # non-empty entries
+    n=len(df)
+    # assign row number
+    df_nona["_NROW"] = range(n)
+    # a list to store r2
+    r_list=[]
+    # estimate r
+    for i in range(n):
+        # exclude 1 record
+        records_to_use = df_nona["_NROW"]!=i
+        # estimate r
+        reg_jackknife = ss.linregress(df_nona.loc[records_to_use, x],df_nona.loc[records_to_use,y])
+        # add r_i to list
+        r_list.append(reg_jackknife[2])
+
+    # convert list to array
+    rs = np.array(r_list)
+    # https://en.wikipedia.org/wiki/Jackknife_resampling
+    r_se = np.sqrt( (n-1)/n * np.sum((rs - np.mean(rs))**2) )
+    log.write(" -R se (jackknife) = {:.2e}".format(r_se), verbose=verbose)
+    return r_se

gwaslab/viz_plot_stackedregional.py

@@ -80,6 +80,8 @@ def plot_stacked_mqq(objects,
 
     if fig_args is None:
         fig_args = {"dpi":200}
+    if save_args is None:
+        save_args = {"dpi":400,"facecolor":"white"}
     if region_lead_grid_line is None:
         region_lead_grid_line = {"alpha":0.5,"linewidth" : 2,"linestyle":"--","color":"#FF0000"}
     if region_chromatin_files is None:
@@ -94,6 +96,19 @@ def plot_stacked_mqq(objects,
     else:
         if "family" not in title_args.keys():
             title_args["family"] = "Arial"
+
+    if save is not None:
+        if type(save) is not bool:
+            if len(save)>3:
+                if save[-3:]=="pdf" or save[-3:]=="svg":
+                    log.write(" -Adjusting options for saving as pdf/svg...",verbose=verbose)
+                    fig_args["dpi"]=72
+                    if "scatter_args" not in  mqq_args.keys():
+                        mqq_args["scatter_args"]={"rasterized":True}
+                    else:
+                        mqq_args["scatter_args"]["rasterized"] = True
+                else:
+                    fig_args["dpi"] = save_args["dpi"]
     # create figure and axes ##################################################################################################################
     #
     # subplot_height : subplot height
@@ -141,6 +156,8 @@ def plot_stacked_mqq(objects,
         region_lead_grids = [i for i in range(len(axes))]
     ##########################################################################################################################################
     mqq_args_for_each_plot = _sort_args(mqq_args, n_plot)
+
+
     ##########################################################################################################################################
     # get x axis dict
     if mode=="m" or mode=="r":
@@ -238,7 +255,6 @@ def plot_stacked_mqq(objects,
     # adjust labels
     # drop labels for each plot 
     # set a common laebl for all plots
-
     #if title_box is None:
     #    title_box = dict(boxstyle='square', facecolor='white', alpha=1.0, edgecolor="black")
     #    title_box = {}
@@ -270,8 +286,9 @@ def plot_stacked_mqq(objects,
     #else:
     if title_pos is None:
         title_pos = [0.01,0.97]
-    for index,title in enumerate(titles):
-        axes[index].text(title_pos[0], title_pos[1] , title, transform=axes[index].transAxes,ha="left", va='top',zorder=999999, **title_args)
+    if titles is not None:
+        for index,title in enumerate(titles):
+            axes[index].text(title_pos[0], title_pos[1] , title, transform=axes[index].transAxes,ha="left", va='top',zorder=999999, **title_args)
     
     ##########################################################################################################################################
     # draw the line for lead variants

gwaslab/viz_plot_trumpetplot.py

@@ -281,8 +281,10 @@ def plottrumpet(mysumstats,
     sumstats["ABS_BETA"] = sumstats[beta].abs()
 
     ##################################################################################################
-    size_norm = (sumstats["ABS_BETA"].min(), sumstats["ABS_BETA"].max())
+    size_norm = (sumstats[size].min(), sumstats[size].max())
     ## if highlight  ##################################################################################################
+
+    log.write(" -Creating scatter plot...", verbose=verbose)
     dots = sns.scatterplot(data=sumstats,
                     x=maf,
                     y=beta,
@@ -295,7 +297,7 @@ def plottrumpet(mysumstats,
                     alpha=0.8,
                     zorder=2,
                     **scatter_args)
-    
+    log.write(" -Finished screating scatter plot...", verbose=verbose)
     if len(highlight) >0:
         
         legend = None
@@ -380,15 +382,13 @@ def plottrumpet(mysumstats,
     ####################################################################################################################
     
     #second_legend = ax.legend(title="Power", loc="upper right",fontsize =fontsize,title_fontsize=fontsize)
-    
+    log.write(" -Creating legends...")
     h,l = ax.get_legend_handles_labels()
     if len(ts)>0:
         l1 = ax.legend(h[:int(len(ts))],l[:int(len(ts))], title="Power", loc="upper right",fontsize =fontsize,title_fontsize=fontsize)
         for line in l1.get_lines():
             line.set_linewidth(5.0)
     if hue is None:
-        l2 = ax.legend(h[int(len(ts)):],l[int(len(ts)):], title=size, loc="lower right",fontsize =fontsize,title_fontsize=fontsize)
-    else:
         l2 = ax.legend(h[int(len(ts)):],l[int(len(ts)):], title=None, loc="lower right",fontsize =fontsize,title_fontsize=fontsize)
     if len(ts)>0:
         ax.add_artist(l1)

{gwaslab-3.5.1.dist-info → gwaslab-3.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gwaslab
-Version: 3.5.1
+Version: 3.5.3
 Summary: A collection of handy tools for GWAS SumStats
 Author-email: Yunye <yunye@gwaslab.com>
 Project-URL: Homepage, https://cloufield.github.io/gwaslab/

{gwaslab-3.5.1.dist-info → gwaslab-3.5.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-gwaslab/__init__.py,sha256=7TKJaODdpeuQKibL7gIEa4MtyQ0pmrU-vIHQ-Et27lQ,2433
+gwaslab/__init__.py,sha256=pP_OQwkaXMJokVVU_o6AXnJEBs2HtaMtpcHIls3ezO8,2486
 gwaslab/bd_common_data.py,sha256=2voBqMrIsII1TN5T6uvyDax90fWcJK1Stmo1ZHNGGsE,13898
 gwaslab/bd_config.py,sha256=TP-r-DPhJD3XnRYZbw9bQHXaDIkiRgK8bG9HCt-UaLc,580
 gwaslab/bd_download.py,sha256=cDDk2C5IvjeAzvPvVYGTkI4Ss33DUtEDjGo8eAbQRvY,15663
@@ -6,21 +6,21 @@ gwaslab/bd_get_hapmap3.py,sha256=FQpwbhWUPFT152QtiLevEkkN4YcVDIeKzoK0Uz1NlRo,410
 gwaslab/cache_manager.py,sha256=HOTnSkCOyGEPLRl90WT8D_6pAdI8d8AzenMIDGuCeWc,28113
 gwaslab/g_Log.py,sha256=C3Zv-_6c3C9ms8bgQ-ytplz22sjk7euqXYkWr9zNeAs,1573
 gwaslab/g_Phenotypes.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gwaslab/g_Sumstats.py,sha256=c_qYY2H-nf-JtGepzafoHuYwnWxmOOBf9CDytPZc60Q,36704
+gwaslab/g_Sumstats.py,sha256=eqEpHEH5fnBMsOIufVzwaRp0_vCsuHvGEUe5OzNL41s,36969
 gwaslab/g_SumstatsPair.py,sha256=20snPb4SlI6ftMGVjgxAuyxsxYRQF-GzzlBSnoB-3Lo,8851
 gwaslab/g_SumstatsT.py,sha256=u_DighLMnMxwTLnqm-B58pA0G6WXRj6pudPyKMVKjSU,2133
 gwaslab/g_Sumstats_summary.py,sha256=FECvvFXJVKaCX5dggBvvk9YvJ6AbdbcLfjltysX7wEE,6380
 gwaslab/g_meta.py,sha256=htWlgURWclm9R6UqFcX1a93WN27xny7lGUeyJZOtszQ,2583
 gwaslab/g_vchange_status.py,sha256=w3zsYYOcCaI3PTeboonvkQjudzUAfVIgATzRdiPViZs,1939
-gwaslab/g_version.py,sha256=Wpfo8Y_fjYS4ajalombaHrLezBO7BOr070GnjQHhOGw,1885
+gwaslab/g_version.py,sha256=wfkMhPi1U1fd25HKu8F5F4j1YcnYQslOrERu0bBTD38,1885
 gwaslab/hm_casting.py,sha256=FqP4EQl83Q2OKLw004OgLIvUH795TVCGwziLk5jsHqY,11368
 gwaslab/hm_harmonize_sumstats.py,sha256=_sZ8soikAxDokw-dcr_CLguBB8OmTmPPS04MfmsJc_Q,79509
 gwaslab/hm_rsid_to_chrpos.py,sha256=ODWREO0jPN0RAfNzL5fRzSRANfhiksOvUVPuEsFZQqA,6552
 gwaslab/io_preformat_input.py,sha256=J8Ny4OPMaLVdo2nP8lTM-c5A8LSdqphSrp9G4i9JjDQ,24097
-gwaslab/io_process_args.py,sha256=bF7oHBtMnxJgksIit0O0_U94dZFh8r5YblgDqEEsqoM,806
+gwaslab/io_process_args.py,sha256=0ljJOVGsD7qPuBLvdfvR7Vrh7zXPlvfPg-rhOw8xRpQ,1366
 gwaslab/io_read_ldsc.py,sha256=wsYXpH50IchBKd2dhYloSqc4YgnDkiwMsAweaCoN5Eo,12471
 gwaslab/io_read_tabular.py,sha256=EG-C6KhCutt4J4LlOMgXnqzJvU-EZXzVhMvaDFnHrMM,2380
-gwaslab/io_to_formats.py,sha256=8FmbQjWUIsz_V1Lb80TuwRIXKBgs5t42j25Znougk1Y,29401
+gwaslab/io_to_formats.py,sha256=hiIaR-JKOVehv7Y14_SklvzPi_E4U-wUybjKWfPyIus,32587
 gwaslab/io_to_pickle.py,sha256=HhePU0VcaGni0HTNU0BqoRaOnrr0NOxotgY6ISdx3Ck,1833
 gwaslab/ldsc_irwls.py,sha256=83JbAMAhD0KOfpv4IJa6LgUDfQjp4XSJveTjnhCBJYQ,6142
 gwaslab/ldsc_jackknife.py,sha256=XrWHoKS_Xn9StG1I83S2vUMTertsb-GH-_gOFYUhLeU,17715
@@ -55,25 +55,26 @@ gwaslab/util_in_get_sig.py,sha256=53NOh7KueLY3vJPTNhhb37KPAIgLEfcP3k2zIV61lc4,39
 gwaslab/util_in_meta.py,sha256=5K9lIZcIgUy0AERqHy1GvMN2X6dp45JUUgopuDLgt4o,11284
 gwaslab/util_in_snphwe.py,sha256=-KpIDx6vn_nah6H55IkV2OyjXQVXV13XyBL069WE1wM,1751
 gwaslab/vis_plot_credible sets.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gwaslab/viz_aux_annotate_plot.py,sha256=gA-s8a90dsl3MB5CIapdI_DecD9h2FmuqMgy07kMYJI,25207
-gwaslab/viz_aux_chromatin.py,sha256=7cGmej5EkKO7fxR1b5w8r1oRRl9ofVzFRG52SCYWtz0,4109
+gwaslab/viz_aux_annotate_plot.py,sha256=3PyBioC-3ZBzqKT2JRv6vp-hZUXSqTTePIT5cblEvnQ,25334
+gwaslab/viz_aux_chromatin.py,sha256=aWZaXOSvGyZY7wQcoFDaqHRYCSHZbi_K4Q70HruN9ts,4125
 gwaslab/viz_aux_property.py,sha256=UIaivghnLXYpTwkKnXRK0F28Jbn9L6OaICk3K73WZaU,33
-gwaslab/viz_aux_quickfix.py,sha256=HnhVvY0GP0EN0gLJ-B11OYiE5PWDcdKGUpQ3QZeu0lE,18592
+gwaslab/viz_aux_quickfix.py,sha256=cGX5i3WBmvKIiqck8V00caDg-pvKOO709Ux3DBXsUrM,18693
 gwaslab/viz_aux_reposition_text.py,sha256=iRIP-Rkltlei068HekJcVubiqPrunBqvAoSQ1eHk04M,4304
-gwaslab/viz_aux_save_figure.py,sha256=GdUXNBOelsWqtTXm8pEZzeGGwDxHYnBkyrGwLOK16ew,2723
+gwaslab/viz_aux_save_figure.py,sha256=x_b4DlTSmHJddfQgoYoReCi4QQbQEtcwCWTKfGetfTA,2768
 gwaslab/viz_plot_compare_af.py,sha256=qtXW45-Sq_ugK8ZfqBYMpmf58SKi3lB3YyHnzn_akcE,5344
 gwaslab/viz_plot_compare_effect.py,sha256=kq-rVWygHEeTBMOtd_jk8nK85ClZHU-ADSf4nI2gTKo,66604
 gwaslab/viz_plot_forestplot.py,sha256=xgOnefh737CgdQxu5naVyRNBX1NQXPFKzf51fbh6afs,6771
 gwaslab/viz_plot_miamiplot.py,sha256=rCFEp7VNuVqeBBG3WRkmFAtFklbF79BvIQQYiSY70VY,31238
 gwaslab/viz_plot_miamiplot2.py,sha256=xiFCgFX8hEySmCJORpEurMVER9eEXQyy_Ik7mLkbi9g,16015
-gwaslab/viz_plot_mqqplot.py,sha256=emyEXZZenzm8eh3XFCkTWI8sz0fEnL5QJxohOZMxWZc,67189
+gwaslab/viz_plot_mqqplot.py,sha256=Pea0uNWe4ZW3S8z8BGQ_dIEWmnKWoxAgEMVxGsMJYxk,68560
 gwaslab/viz_plot_phe_heatmap.py,sha256=qoXVeFTIm-n8IinNbDdPFVBSz2yGCGK6QzTstXv6aj4,9532
 gwaslab/viz_plot_qqplot.py,sha256=psQgVpP29686CEZkzQz0iRbApzqy7aE3GGiBcazVvNw,7247
-gwaslab/viz_plot_regional2.py,sha256=tBoGox-4ngL5o_twdIjk_VW6Iam3JDyrPKuttm6_4Sg,36862
+gwaslab/viz_plot_regional2.py,sha256=rvvIU60pOJFiDReQFd_Q2MkthuwvNOUkptV1swP9uJM,39444
 gwaslab/viz_plot_regionalplot.py,sha256=8u-5-yfy-UaXhaxVVz3Y5k2kBAoqzczUw1hyyD450iI,37983
 gwaslab/viz_plot_rg_heatmap.py,sha256=PidUsgOiEVt6MfBPCF3_yDhOEytZ-I1q-ZD6_0pFrV4,13713
-gwaslab/viz_plot_stackedregional.py,sha256=HfNUhwxevbwSoauE0ysG020U7YFVy4111nkIWdaJ4Q8,16664
-gwaslab/viz_plot_trumpetplot.py,sha256=ZHdc6WcVx0-oKoj88yglRkmB4bS9pOiEMcuwKW35Yvo,42672
+gwaslab/viz_plot_scatter_with_reg.py,sha256=PmUZDQl2q4Dme3HLPXEwf_TrMjwJADA-uFXNDBWUEa4,8333
+gwaslab/viz_plot_stackedregional.py,sha256=UefPxnd-EJApFdwcafE2k6jZqrfGKEjy51NhieiRaPM,17362
+gwaslab/viz_plot_trumpetplot.py,sha256=y4sAFjzMaSLuWrdr9_ao-wPYCK5DlP2ykiqulWsoN_k,42680
 gwaslab/data/formatbook.json,sha256=N2nJs80HH98Rsu9FxaSvIQO9J5yIV97WEtAKjRqYwiY,38207
 gwaslab/data/reference.json,sha256=IrjwFnXjrpVUp3zYfcYClpibJE9Y-94gtrC1Aw8sXxg,12332
 gwaslab/data/chrx_par/chrx_par_hg19.bed.gz,sha256=LocZg_ozhZjQiIpgWCO4EYCW9xgkEKpRy1m-YdIpzQs,83
@@ -82,9 +83,9 @@ gwaslab/data/hapmap3_SNPs/hapmap3_db150_hg19.snplist.gz,sha256=qD9RsC5S2h6l-OdpW
 gwaslab/data/hapmap3_SNPs/hapmap3_db151_hg38.snplist.gz,sha256=Y8ZT2FIAhbhlgCJdE9qQVAiwnV_fcsPt72usBa7RSBM,10225828
 gwaslab/data/high_ld/high_ld_hla_hg19.bed.gz,sha256=R7IkssKu0L4WwkU9SrS84xCMdrkkKL0gnTNO_OKbG0Y,219
 gwaslab/data/high_ld/high_ld_hla_hg38.bed.gz,sha256=76CIU0pibDJ72Y6UY-TbIKE9gEPwTELAaIbCXyjm80Q,470
-gwaslab-3.5.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gwaslab-3.5.1.dist-info/LICENSE_before_v3.4.39,sha256=GhLOU_1UDEKeOacYhsRN_m9u-eIuVTazSndZPeNcTZA,1066
-gwaslab-3.5.1.dist-info/METADATA,sha256=Dqj65vurvDR3JCwlyCVnnfUS64cmN1vMJJjUTCm3xLI,7758
-gwaslab-3.5.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-gwaslab-3.5.1.dist-info/top_level.txt,sha256=PyY6hWtrALpv2MAN3kjkIAzJNmmBTH5a2risz9KwH08,8
-gwaslab-3.5.1.dist-info/RECORD,,
+gwaslab-3.5.3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gwaslab-3.5.3.dist-info/LICENSE_before_v3.4.39,sha256=GhLOU_1UDEKeOacYhsRN_m9u-eIuVTazSndZPeNcTZA,1066
+gwaslab-3.5.3.dist-info/METADATA,sha256=lMetRGVrgpM2KaxU-y17WKZhZkOd7aafJY1pta3oKJA,7758
+gwaslab-3.5.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+gwaslab-3.5.3.dist-info/top_level.txt,sha256=PyY6hWtrALpv2MAN3kjkIAzJNmmBTH5a2risz9KwH08,8
+gwaslab-3.5.3.dist-info/RECORD,,

{gwaslab-3.5.1.dist-info → gwaslab-3.5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any