gwaslab 3.4.49__py3-none-any.whl → 3.5.0__py3-none-any.whl

gwaslab/g_Sumstats.py

@@ -81,6 +81,7 @@ from gwaslab.bd_get_hapmap3 import gethapmap3
 from gwaslab.util_abf_finemapping import abf_finemapping
 from gwaslab.util_abf_finemapping import make_cs
 import gc
+from gwaslab.viz_plot_phe_heatmap import _gwheatmap
 
 #20220309
 class Sumstats():
@@ -602,6 +603,11 @@ class Sumstats():
     def plot_daf(self, **kwargs):
         fig,outliers = plotdaf(self.data, **kwargs)
         return fig, outliers
+    
+    def plot_gwheatmap(self, **kwargs):
+        fig = _gwheatmap(self.data, **kwargs)
+        return fig
+    
     def plot_mqq(self, build=None, **kwargs):
 
         chrom="CHR"
@@ -705,7 +711,7 @@ class Sumstats():
         # return sumstats object    
         return output
     
-    def check_cis(self, **kwargs):
+    def check_cis(self, gls=False, **kwargs):
         if "SNPID" in self.data.columns:
             id_to_use = "SNPID"
         else:
@@ -717,7 +723,13 @@ class Sumstats():
                            p="P",
                            log=self.log,
                            **kwargs)
-        # return sumstats object    
+        
+        # return sumstats object   
+        if gls == True:
+            new_Sumstats_object = copy.deepcopy(self)
+            new_Sumstats_object.data = output
+            gc.collect()
+            return new_Sumstats_object
         return output
     
     def check_novel_set(self, **kwargs):

gwaslab/g_version.py

@@ -15,8 +15,8 @@ def _get_version():
 def gwaslab_info():
     # version meta information
     dic={
-   "version":"3.4.49",
-   "release_date":"20241019"
+   "version":"3.5.0",
+   "release_date":"20241029"
     }
     return dic   
 

gwaslab/util_in_get_sig.py

@@ -619,8 +619,10 @@ def _check_cis(insumstats,
     except:
         pass
 
-    allsig["CIS/TRANS"] = allsig.apply(lambda x: determine_if_cis(x, group_key,windowsizekb, reference_dict), axis=1)
-    
+    #allsig["CIS/TRANS"] = allsig.apply(lambda x: determine_if_cis(x, group_key,windowsizekb, reference_dict), axis=1)
+    cis_tuples = allsig.apply(lambda x: determine_if_cis2(x, group_key,windowsizekb, reference_dict), axis=1)
+    allsig[["CIS/TRANS","REF_CHR","REF_START","REF_END"]] = pd.DataFrame(cis_tuples.tolist(), index=allsig.index)
+
     try:
         allsig = allsig.where(~pd.isna(allsig), pd.NA)
     except:
@@ -689,6 +691,20 @@ def determine_if_cis(x, group_key,windowsizekb, reference_dict):
     else:
         return "NoReference"
 
+def determine_if_cis2(x, group_key,windowsizekb, reference_dict):
+    if x[group_key] in reference_dict.keys():
+        is_same_chr = str(reference_dict[x[group_key]][0]) == str(x["CHR"])
+        is_large_than_start = int(reference_dict[x[group_key]][1]) - windowsizekb*1000 <= x["POS"]
+        is_smaller_than_end = int(reference_dict[x[group_key]][2]) + windowsizekb*1000 >= x["POS"]               
+        
+        if  is_same_chr and is_large_than_start  and is_smaller_than_end:
+            return "Cis", int(reference_dict[x[group_key]][0]), int(reference_dict[x[group_key]][1]), int(reference_dict[x[group_key]][2])
+        else: 
+            return "Trans", int(reference_dict[x[group_key]][0]), int(reference_dict[x[group_key]][1]), int(reference_dict[x[group_key]][2])
+    else:
+        return "NoReference", pd.NA, pd.NA, pd.NA
+
+
 def determine_distance(allsig, knownsig):
     if len(allsig)==0: 
         return allsig

gwaslab/viz_aux_annotate_plot.py

@@ -60,21 +60,21 @@ def annotate_single(
         elif anno:
                 annotation_col=anno
         log.write(" -Annotating using column "+annotation_col+"...", verbose=verbose)
-        
+        ################################################################################################################################
         ## calculate y span
         if region is not None:
             y_span = region[2] - region[1]
         else:
             y_span = sumstats["i"].max()-sumstats["i"].min()
-        
         log.write(" -Adjusting text positions with repel_force={}...".format(repel_force), verbose=verbose)
         if anno_style == "expand" :
             to_annotate.loc[:, "ADJUSTED_i"] = adjust_text_position(to_annotate["i"].values.copy(), y_span, repel_force,max_iter=anno_max_iter,log=log,amode=amode,verbose=verbose)
         ##  iterate through variants to be annotated
+        ################################################################################################################################
+
         anno_to_adjust_list = list()
         
         for rowi,row in to_annotate.iterrows():
-            
             # avoid text overlapping
             ## adjust x to avoid overlapping################################################################
             if anno_style == "right" :
@@ -93,7 +93,7 @@ def annotate_single(
             else:
                 pass
             ################################################################
-            #shrink or increase the arm
+            # shrink or increase the arm by a factor (arm_scale)
             if arm_scale_d is not None:
                 if anno_count not in arm_scale_d.keys():
                     arm_scale =1
@@ -102,20 +102,32 @@ def annotate_single(
             ################################################################
 
             # vertical arm length in pixels
-            #to_annotate["scaled_P"] = to_annotate5["scaled_P_2"].copy()
-            # arm length in pixels
-            #armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-            armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+0.01*maxy))[1]-arm_offset/2
-            # scale if needed
-            armB_length_in_point = armB_length_in_point*arm_scale
+            # Annotation y : 1.15 * maxy_anno
+            # Top dot:  1 * maxy_anno
+            # armB_length_in_point_raw = 0.15 * maxy_anno -> gap_pixel
+            # Fixed Offset: 0.5 * 0.15 * gap_pixel
+
+            #Calculate armB length in pixels
+            # arm_scale: raise up the ceiling
+            
+            # gap : 0.5* space between top variant and annotation text
+            gap_pixel =                (ax1.transData.transform((0,1.15*maxy*arm_scale))[1]-ax1.transData.transform((0, maxy*arm_scale))[1])*0.5
+
+            # armB_length_in_pixel_raw : distance between variant to annotate and annotation text
+            armB_length_in_pixel_raw =  ax1.transData.transform((0,1.15*maxy*arm_scale))[1]-ax1.transData.transform((0, row["scaled_P"]+1))[1] 
+            
+            armB_length_in_pixel = armB_length_in_pixel_raw - gap_pixel
+
             ################################################################
+            # armB_length_in_pixel should not be negative
             if arm_scale>=1:
-                #armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+2))[1]-ax1.transData.transform((skip,  row["scaled_P"]+1))[1] 
-                armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+0.02*maxy))[1]-ax1.transData.transform((skip,  row["scaled_P"]+0.01*maxy))[1] 
-            ###if anno_fixed_arm_length #############################################################
+                armB_length_in_pixel = max(0, armB_length_in_pixel)
+            
+            ################################################################
+            #if setting anno_fixed_arm_length 
             if anno_fixed_arm_length is not None:
-                anno_fixed_arm_length_factor = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
-                armB_length_in_point = anno_fixed_arm_length_factor
+                armB_length_in_pixel = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
+            
             ################################################################################################################################
             # annotation alias
             if anno==True:
@@ -129,26 +141,31 @@ def annotate_single(
                 else:
                     annotation_text=row["Annotation"]
             
-            
-            #xy=(row["i"],row["scaled_P"]+0.2)
+            ################################################################################################################################
+            # setting arrow xy and text xy
+            # add a small space between variant and arrow head
             xy=(row["i"],row["scaled_P"]+0.01*maxy)
-            xytext=(last_pos,1.15*maxy*arm_scale*anno_height)
+
+            # text xy is of the same height
+            # anno_height can be used to adjust the height of annotation text
+            xytext=(last_pos,1.15*maxy*(arm_scale + anno_height -1))
             
+            # for anno_fixed_arm_length
             if anno_fixed_arm_length is not None:
-                armB_length_in_point = anno_fixed_arm_length
-                xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
-            
+                xytext=(row["i"],row["scaled_P"] + 0.2 + anno_fixed_arm_length)
+
+            ################################################################################################################################
+            # if not changing the directions of some annotation arror arms 
             if anno_count not in anno_d.keys():
-                #arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                #                         connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
                 if _invert==False:
                     arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
+                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_pixel)+",rad=0")
                 else:
                     arrowargs = dict(arrowstyle="-|>",relpos=(0,1),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_point)+",rad=0")
+                                            connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_pixel)+",rad=0")
             else:
-                # adjuest horizontal direction
+                # if not changing the directions of some annotation arror arms 
+                # adjust horizontal direction
                 xy=(row["i"],row["scaled_P"])
                 if anno_d[anno_count] in ["right","left","l","r"]:
                     if anno_d[anno_count]=="right" or anno_d[anno_count]=="r": 
@@ -170,7 +187,7 @@ def annotate_single(
                     elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
                         arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
                                                 connectionstyle="arc,angleA=-135,armA="+str( anno_d[anno_count][1])+",angleB=135,armB="+str( anno_d[anno_count][1])+",rad=0")
-            
+            ################################################################################################################################
             
             if "r" in mode:
                 arrowargs["color"] = "black" 
@@ -179,16 +196,19 @@ def annotate_single(
                     bbox_para[key]=value
             else:
                 bbox_para=None
-            
+
+            ################################################################################################################################
             if  _invert==False:
-                anno_default = {"rotation":40,"fontstyle":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
+                anno_default = {"rotation":40, "fontstyle":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
             else:
-                anno_default = {"rotation":-40,"fontstyle":"italic","ha":"left","va":"top","fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
+                anno_default = {"rotation":-40,"fontstyle":"italic","ha":"left","va":"top",   "fontsize":anno_fontsize,"fontweight":"normal","fontfamily":font_family}
 
+            ################################################################################################################################
             if anno_style == "expand" :
                 anno_default["rotation"] = 90
             if anno_style == "tight" :
                 anno_default["rotation"] = 90
+            ################################################################################################################################
 
             for key,value in anno_args.items():
                 anno_default[key]=value
@@ -196,12 +216,13 @@ def annotate_single(
                 if row["i"] in highlight_i:
                     for key,value in highlight_anno_args.items():
                         anno_default[key]=value
-            
+            ################################################################################################################################
             if anno_adjust==True:
                 if  _invert==False:
                     arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(0,0.5))
                 else:
                     arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(1,0.5))
+            ################################################################################################################################
 
             anno_to_adjust = ax1.annotate(annotation_text,
                         xy=xy,
@@ -213,6 +234,8 @@ def annotate_single(
                         )
             anno_to_adjust_list.append(anno_to_adjust) 
             anno_count +=1
+            ################################################################################################################################
+        
         #anno_adjust_keyargs = {"arrowprops":dict(arrowstyle='->', color='grey', linewidth=0.1,relpos=(0.5,0.5))}
         if anno_adjust==True:
             log.write(" -Auto-adjusting text positions...", verbose=verbose)
@@ -354,15 +377,25 @@ def annotate_pair(
                             arm_scale = arm_scale_d[anno_count]
 
                     # vertical arm length in pixels
-                    armB_length_in_point = ax.transData.transform((skip,1.15*maxy_anno))[1]-ax.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-                    # times arm_scale to increase or reduce the length
-                    armB_length_in_point = armB_length_in_point*arm_scale
+                    # Annotation y : 1.15 * maxy_anno
+                    # Top dot:  1 * maxy_anno
+                    # armB_length_in_point_raw = 0.15 * maxy_anno -> gap_pixel
+                    # Fixed Offset: 0.5 * 0.15 * gap_pixel
+
+                    #Calculate armB length in pixels
+                    # arm_scale: raise up the ceiling
+                    gap_pixel =                (ax1.transData.transform((0,1.15*maxy_anno*arm_scale))[1]-ax1.transData.transform((0, maxy_anno*arm_scale))[1])*0.5
+
+                    armB_length_in_pixel_raw =  ax1.transData.transform((0,1.15*maxy_anno*arm_scale))[1]-ax1.transData.transform((0, row["scaled_P"]+1))[1] 
+                    
+                    armB_length_in_pixel = armB_length_in_pixel_raw - gap_pixel
                     
                     if arm_scale>=1:
-                        armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else 0 #ax.transData.transform((skip, maxy_anno+2))[1]-ax.transData.transform((skip,  row["scaled_P"]+1))[1] 
+                        armB_length_in_pixel= armB_length_in_pixel if armB_length_in_pixel>0 else 0
+                    
                     if anno_fixed_arm_length is not None:
                         anno_fixed_arm_length_factor = ax.transData.transform((skip,anno_fixed_arm_length))[1]-ax.transData.transform((skip,0))[1] 
-                        armB_length_in_point = anno_fixed_arm_length_factor
+                        armB_length_in_pixel = anno_fixed_arm_length_factor
                     
                     if anno==True:
                         if row[snpid] in anno_alias.keys():
@@ -383,24 +416,24 @@ def annotate_pair(
                     xytext=(last_pos,1.15*maxy_anno*arm_scale)
                     
                     if anno_fixed_arm_length is not None:
-                        armB_length_in_point = anno_fixed_arm_length
+                        armB_length_in_pixel = anno_fixed_arm_length
                         xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
                     
                     if anno_count not in anno_d.keys():
                         if index==0:
                             #upper panel
-                            if armB_length_in_point <5:
+                            if armB_length_in_pixel <5:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",connectionstyle="arc,armA=0,armB=0,rad=0.")
                             else:  
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
+                                                connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_pixel)+",rad=0")
                         else:
                             #lower panel
-                            if armB_length_in_point <5:
+                            if armB_length_in_pixel <5:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",connectionstyle="arc,armA=0,armB=0,rad=0.")
                             else:
                                 arrowargs = dict(arrowstyle="-|>",relpos=(0,1),color="#ebebeb",
-                                                    connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_point)+",rad=0")
+                                                    connectionstyle="arc,angleA=0,armA=0,angleB=-90,armB="+str(armB_length_in_pixel)+",rad=0")
                     
                     else:
                         xy=(row["i"],row["scaled_P"])
@@ -478,204 +511,4 @@ def annotate_pair(
                             )
     else:
         log.write(" -Skip annotating", verbose=verbose)
-    return ax1,ax5
-
-
-# subtype plot
-def annotate_subtype(
-    sumstats,
-    anno,
-    mode,
-    ax1,
-    highlight_i,
-    to_annotate,
-    anno_d,
-    anno_alias,
-    anno_style,
-    anno_args,
-    arm_scale,
-    anno_max_iter,
-    arm_scale_d,
-    arm_offset,
-    anno_adjust,
-    anno_fixed_arm_length,
-    maxy,
-    anno_fontsize,
-    region,
-    region_anno_bbox_args,
-    skip,
-    snpid="SNPID",
-    chrom="CHR",
-    pos="POS",
-    repel_force=0.02,
-    verbose=True,
-    log=Log()
-):
-    if anno and (to_annotate.empty is not True):
-        #initiate a list for text and a starting position
-        text = []
-        last_pos=0
-        anno_count=0
-        to_annotate = to_annotate.sort_values(by=[chrom,pos])
-        ## log : annotation column
-        if anno==True:
-                annotation_col="CHR:POS"
-        elif anno:
-                annotation_col=anno
-        log.write(" -Annotating using column "+annotation_col+"...", verbose=verbose)
-        
-        ## calculate y span
-        if region is not None:
-            y_span = region[2] - region[1]
-        else:
-            y_span = sumstats["i"].max()-sumstats["i"].min()
-        
-        log.write(" -Adjusting text positions with repel_force={}...".format(repel_force), verbose=verbose)
-        if anno_style == "expand" :
-            to_annotate.loc[:, "ADJUSTED_i"] = adjust_text_position(to_annotate["i"].values.copy(), y_span, repel_force,max_iter=anno_max_iter,log=log,verbose=verbose)
-        ##  iterate through variants to be annotated
-        anno_to_adjust_list = list()
-        
-        for rowi,row in to_annotate.iterrows():
-            
-            # avoid text overlapping
-            ## adjust x to avoid overlapping################################################################
-            if anno_style == "right" :
-                #right style
-                if row["i"]>last_pos+repel_force*y_span:
-                    last_pos=row["i"]
-                else:
-                    last_pos+=repel_force*y_span
-            elif anno_style == "expand" :
-                #expand style
-                last_pos = row["ADJUSTED_i"]
-                anno_args["rotation"] = 90
-            elif anno_style == "tight" :
-                #tight style
-                anno_fixed_arm_length = 1
-                anno_adjust = True
-                anno_args["rotation"] = 90
-            else:
-                pass
-            ################################################################
-            #shrink or increase the arm
-            if arm_scale_d is not None:
-                if anno_count not in arm_scale_d.keys():
-                    arm_scale =1
-                else:
-                    arm_scale = arm_scale_d[anno_count]
-            ################################################################
-
-            # vertical arm length in pixels
-            armB_length_in_point = ax1.transData.transform((skip,1.15*maxy))[1]-ax1.transData.transform((skip, row["scaled_P"]+1))[1]-arm_offset/2
-            # scale if needed
-            armB_length_in_point = armB_length_in_point*arm_scale
-            ################################################################
-            if arm_scale>=1:
-                armB_length_in_point= armB_length_in_point if armB_length_in_point>0 else ax1.transData.transform((skip, maxy+2))[1]-ax1.transData.transform((skip,  row["scaled_P"]+1))[1] 
-            ###if anno_fixed_arm_length #############################################################
-            if anno_fixed_arm_length is not None:
-                anno_fixed_arm_length_factor = ax1.transData.transform((skip,anno_fixed_arm_length))[1]-ax1.transData.transform((skip,0))[1] 
-                armB_length_in_point = anno_fixed_arm_length_factor
-            ################################################################################################################################
-            # annotation alias
-            if anno==True:
-                if row[snpid] in anno_alias.keys():
-                    annotation_text = anno_alias[row[snpid]]
-                else:
-                    annotation_text="Chr"+ str(row[chrom]) +":"+ str(int(row[pos]))
-            elif anno:
-                annotation_text=row["Annotation"]
-            
-            #
-            fontweight = "normal"
-            if len(highlight_i) >0:
-                if row["i"] in highlight_i:
-                    fontweight = "bold"
-
-            
-            xy=(row["i"],row["scaled_P"]+0.2)
-            xytext=(last_pos, 1.15*maxy*arm_scale)
-            
-            if anno_fixed_arm_length is not None:
-                armB_length_in_point = anno_fixed_arm_length
-                xytext=(row["i"],row["scaled_P"]+0.2+anno_fixed_arm_length)
-            
-            if anno_count not in anno_d.keys():
-                #arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                #                         connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
-                arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                            connectionstyle="arc,angleA=0,armA=0,angleB=90,armB="+str(armB_length_in_point)+",rad=0")
-            else:
-                # adjuest direction
-                xy=(row["i"],row["scaled_P"])
-                if anno_d[anno_count] in ["right","left","l","r"]:
-                    if anno_d[anno_count]=="right" or anno_d[anno_count]=="r": 
-                        armoffsetall = (ax1.transData.transform(xytext)[0]-ax1.transData.transform(xy)[0])*np.sqrt(2)
-                        armoffsetb = arm_offset 
-                        armoffseta = armoffsetall - armoffsetb   
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(armoffseta)+",angleB=45,armB="+str(armoffsetb)+",rad=0")
-                    elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(arm_offset)+",angleB=135,armB="+str(arm_offset)+",rad=0")
-                else:
-                    if anno_d[anno_count][0]=="right" or anno_d[anno_count][0]=="r": 
-                        armoffsetall = (ax1.transData.transform(xytext)[0]-ax1.transData.transform(xy)[0])*np.sqrt(2)
-                        armoffsetb = anno_d[anno_count][1] 
-                        armoffseta = armoffsetall - armoffsetb   
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str(armoffseta)+",angleB=45,armB="+str(armoffsetb)+",rad=0")
-                    elif anno_d[anno_count]=="left" or anno_d[anno_count]=="l":
-                        arrowargs = dict(arrowstyle="-|>",relpos=(0,0),color="#ebebeb",
-                                                connectionstyle="arc,angleA=-135,armA="+str( anno_d[anno_count][1])+",angleB=135,armB="+str( anno_d[anno_count][1])+",rad=0")
-            
-            
-            if "r" in mode:
-                arrowargs["color"] = "black" 
-                bbox_para=dict(boxstyle="round", fc="white",zorder=3)
-                for key,value in region_anno_bbox_args.items():
-                    bbox_para[key]=value
-            else:
-                bbox_para=None
-            
-            anno_default = {"rotation":40,"style":"italic","ha":"left","va":"bottom","fontsize":anno_fontsize,"fontweight":fontweight}
-            for key,value in anno_args.items():
-                anno_default[key]=value
-
-            if anno_adjust==True:
-                arrowargs=dict(arrowstyle='-|>', color='grey', shrinkA=10, linewidth=0.1, relpos=(0,0.5))
-            anno_to_adjust = ax1.annotate(annotation_text,
-                        xy=xy,
-                        xytext=xytext,
-                        bbox=bbox_para,
-                        arrowprops=arrowargs,
-                        zorder=100,
-                        **anno_default
-                        )
-            anno_to_adjust_list.append(anno_to_adjust) 
-            anno_count +=1
-        #anno_adjust_keyargs = {"arrowprops":dict(arrowstyle='->', color='grey', linewidth=0.1,relpos=(0.5,0.5))}
-        if anno_adjust==True:
-            log.write(" -Auto-adjusting text positions...", verbose=verbose)
-            adjust_text(texts = anno_to_adjust_list,
-                        autoalign=False, 
-                        only_move={'points':'x', 'text':'x', 'objects':'x'},
-                        ax=ax1,
-                        precision=0.02,
-                        force_text=(repel_force,repel_force),
-                        expand_text=(1,1),
-                        expand_objects=(0,0),
-                        expand_points=(0,0),
-                        va="bottom",
-                        ha='left',
-                        avoid_points=False,
-                        lim =100
-                        #kwargs = anno_adjust_keyargs
-                        )
-        
-    else:
-        log.write(" -Skip annotating", verbose=verbose)
-    
-    return ax1
-
+    return ax1,ax5

gwaslab/viz_aux_quickfix.py

@@ -80,6 +80,7 @@ def _quick_fix_chr(seires, chr_dict,log=Log(), verbose=True):
     '''
     if pd.api.types.is_string_dtype(seires) == True:
         # if chr is string dtype: convert using chr_dict
+        seires = seires.astype("string")
         seires = seires.map(chr_dict, na_action="ignore")
     seires = np.floor(pd.to_numeric(seires, errors='coerce')).astype('Int64')
     return seires
@@ -93,6 +94,12 @@ def _quick_fix_pos(seires,log=Log(), verbose=True):
     return seires
 
 
+def _dropna_in_cols(sumstats, cols, log=Log(), verbose=True):
+    to_drop = sumstats[cols].isna().any(axis=1)
+    log.write(" -Dropping {} variants due to missing values in {}.".format(sum(to_drop),cols))
+    return sumstats.loc[~to_drop,:]
+
+
 def _get_largenumber(*args,log=Log(), verbose=True):
     '''
     get a helper large number, >> max(pos)
@@ -330,7 +337,7 @@ def _cut(series, mode,cutfactor,cut,skip, ylabels, cut_log, verbose, lines_to_pl
                 if "b" not in mode:
                     log.write(" -Minus log10(P) values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
                 else:
-                    log.write(" -Minus DENSITY values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
+                    log.write(" -DENSITY values above " + str(cut)+" will be shrunk with a shrinkage factor of " + str(cutfactor)+"...", verbose=verbose)
 
                 maxticker=int(np.round(series.max(skipna=True)))
 
@@ -448,4 +455,4 @@ def _jagged_y(cut,skip,ax1,mode,mqqratio,jagged_len,jagged_wid, log=Log(), verbo
     ax1.plot((x0,-dx), (tycut,tycut+dy), zorder=1001, **kwargs)
     ax1.plot((-dx,+dx), (tycut+dy,tycut+3*dy), zorder=1001, **kwargs)
     ax1.plot((+dx,x0), (tycut+3*dy,tycut+4*dy), zorder=1001,  **kwargs)
-    return ax1
+    return ax1

gwaslab/viz_aux_save_figure.py

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

gwaslab/viz_plot_compare_effect.py

@@ -9,6 +9,7 @@ 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
@@ -59,6 +60,7 @@ def compare_effect(path1,
                    xylabel_prefix="Per-allele effect size in ",
                    helper_line_args=None,
                    fontargs=None,
+                   build="19",
                    r_or_r2="r",
                    # 
                    errargs=None,
@@ -77,10 +79,9 @@ def compare_effect(path1,
         scaled2 = True
     if is_q_mc=="fdr" or is_q_mc=="bon":
         is_q = True
-    
     if is_q == True:
         if is_q_mc not in [False,"fdr","bon","non"]:
-            raise ValueError("Please select either fdr or bon or non for is_q_mc.")
+            raise ValueError('Please select either "fdr" or "bon" or "non"/False for is_q_mc.')
     if save_args is None:
         save_args = {"dpi":300,"facecolor":"white"}
     if reg_box is None:
@@ -89,6 +90,8 @@ def compare_effect(path1,
         sep = ["\t","\t"]
     if get_lead_args is None:
         get_lead_args = {}
+    if anno=="GENENAME":
+        get_lead_args["anno"]=True
     if errargs is None:
         errargs={"ecolor":"#cccccc","elinewidth":1}
     if fontargs is None:
@@ -191,10 +194,12 @@ def compare_effect(path1,
         ######### 8.1 if a snplist is provided, use the snp list
         log.write(" -Extract variants in the given list from "+label[0]+"...")
         sig_list_1 = sumstats.loc[sumstats["SNPID"].isin(snplist),:].copy()
+        if anno=="GENENAME":
+            sig_list_1 = annogene(sumstats,"SNPID","CHR","POS", build=build, verbose=verbose,**get_lead_args)
     else:
-        ######### 8,2 otherwise use the sutomatically detected lead SNPs
+        ######### 8,2 otherwise use the automatically detected lead SNPs
         log.write(" -Extract lead variants from "+label[0]+"...")
-        sig_list_1 = getsig(sumstats,"SNPID","CHR","POS","P", verbose=verbose,sig_level=sig_level,**get_lead_args)
+        sig_list_1 = getsig(sumstats,"SNPID","CHR","POS","P", build=build, verbose=verbose,sig_level=sig_level,**get_lead_args)
     
     if drop==True:
         sig_list_1 = drop_duplicate_and_na(sig_list_1, sort_by="P", log=log ,verbose=verbose)
@@ -235,10 +240,12 @@ def compare_effect(path1,
         ######### 12.1 if a snplist is provided, use the snp list
         log.write(" -Extract snps in the given list from "+label[1]+"...")
         sig_list_2 = sumstats.loc[sumstats["SNPID"].isin(snplist),:].copy()
+        if anno=="GENENAME":
+            sig_list_2 = annogene(sumstats,"SNPID","CHR","POS", build=build, verbose=verbose,**get_lead_args)
     else: 
         log.write(" -Extract lead snps from "+label[1]+"...")
         ######### 12.2 otherwise use the sutomatically detected lead SNPs
-        sig_list_2 = getsig(sumstats,"SNPID","CHR","POS","P",
+        sig_list_2 = getsig(sumstats,"SNPID","CHR","POS","P",build=build,
                                  verbose=verbose,sig_level=sig_level,**get_lead_args)
     if drop==True:
         sig_list_2 = drop_duplicate_and_na(sig_list_2, sort_by="P", log=log ,verbose=verbose)
@@ -248,6 +255,10 @@ def compare_effect(path1,
     log.write("Merging snps from "+label[0]+" and "+label[1]+"...")
     
     sig_list_merged = pd.merge(sig_list_1,sig_list_2,left_on="SNPID",right_on="SNPID",how="outer",suffixes=('_1', '_2'))
+    if anno == "GENENAME":
+        sig_list_merged.loc[sig_list_merged["SNPID"].isin((sig_list_1["SNPID"])),"GENENAME"] = sig_list_merged.loc[sig_list_merged["SNPID"].isin((sig_list_1["SNPID"])),"GENE_1"]
+        sig_list_merged.loc[~sig_list_merged["SNPID"].isin((sig_list_1["SNPID"])),"GENENAME"] = sig_list_merged.loc[~sig_list_merged["SNPID"].isin((sig_list_1["SNPID"])),"GENE_2"]
+        sig_list_merged = sig_list_merged.drop(columns=["GENE_1","GENE_2","LOCATION_1","LOCATION_2"])
     #     SNPID       P_1       P_2
     #0   rs117986209  0.142569  0.394455
     #1     rs6704312  0.652104  0.143750
@@ -533,7 +544,7 @@ def compare_effect(path1,
 
     ########################## Het test############################################################
     ## heterogeneity test
-    if (is_q is True):
+    if (is_q == True):
         log.write(" -Calculating Cochran's Q statistics and peform chisq test...", verbose=verbose)
         if mode=="beta" or mode=="BETA" or mode=="Beta":
             sig_list_merged = test_q(sig_list_merged,"EFFECT_1","SE_1","EFFECT_2_aligned","SE_2",q_level=q_level,is_q_mc=is_q_mc, log=log, verbose=verbose)
@@ -552,7 +563,7 @@ def compare_effect(path1,
         log.write(" -Exclude "+str(len(sig_list_merged) -sum(both_eaf_clear))+ " variants with maf <",maf_level, verbose=verbose)
         sig_list_merged = sig_list_merged.loc[both_eaf_clear,:]
     # heterogeneity summary
-    if (is_q is True):
+    if (is_q == True):
         log.write(" -Significant het:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:]), verbose=verbose)
         log.write(" -All sig:" ,len(sig_list_merged), verbose=verbose)
         log.write(" -Het rate:" ,len(sig_list_merged.loc[sig_list_merged["HetP"]<0.05,:])/len(sig_list_merged), verbose=verbose)   
@@ -633,11 +644,11 @@ def compare_effect(path1,
             ax.scatter(both["OR_1"],both["OR_2_aligned"],label=label[2],zorder=2,color="#205be6",edgecolors=both["Edge_color"],marker="s",**scatterargs)
             legend_elements.append(label[2])
     ## annotation #################################################################################################################
-    if anno==True:
+    if anno==True or anno=="GENENAME":
         sig_list_toanno = sig_list_merged.dropna(axis=0)
         if is_q==True and anno_het == True:
             sig_list_toanno = sig_list_toanno.loc[sig_list_toanno["Edge_color"]=="black",:]
-        
+
         if mode=="beta":
             sig_list_toanno = sig_list_toanno.loc[sig_list_toanno["EFFECT_1"].abs() >=anno_min1 ,:]
             sig_list_toanno = sig_list_toanno.loc[sig_list_toanno["EFFECT_2_aligned"].abs() >=anno_min2 ,:]
@@ -651,22 +662,38 @@ def compare_effect(path1,
 
         texts_l=[]
         texts_r=[]
+        
+        if anno==True:
+            log.write("Annotating variants using {}".format("SNPID"), verbose=verbose)
+        elif anno=="GENENAME":
+            log.write("Annotating variants using {}".format("GENENAME"), verbose=verbose)
+        
         for index, row in sig_list_toanno.iterrows():
+            log.write("Annotating {}...".format(row), verbose=verbose)
+            if anno==True:
+                to_anno_text = index
+            elif type(anno) is str:
+                if not pd.isna(row[anno]):
+                    to_anno_text = row[anno]
+                else:
+                    to_anno_text = index
+
             if mode=="beta" or mode=="BETA" or mode=="Beta":
                 if row["EFFECT_1"] <  row["EFFECT_2_aligned"]:
-                    texts_l.append(plt.text(row["EFFECT_1"], row["EFFECT_2_aligned"],index,ha="right",va="bottom"))
+                    texts_l.append(plt.text(row["EFFECT_1"], row["EFFECT_2_aligned"],to_anno_text,ha="right",va="bottom"))
                 else:
-                    texts_r.append(plt.text(row["EFFECT_1"], row["EFFECT_2_aligned"],index,ha="left",va="top"))
+                    texts_r.append(plt.text(row["EFFECT_1"], row["EFFECT_2_aligned"],to_anno_text,ha="left",va="top"))
             else:
                 if row["OR_1"] <  row["OR_2_aligned"]:
-                    texts_l.append(plt.text(row["OR_1"], row["OR_2_aligned"],index, ha='right', va='bottom')) 
+                    texts_l.append(plt.text(row["OR_1"], row["OR_2_aligned"],to_anno_text, ha='right', va='bottom')) 
                 else:
-                    texts_r.append(plt.text(row["OR_1"], row["OR_2_aligned"],index, ha='left', va='top')) 
-
-        adjust_text(texts_l,autoalign =False,precision =0.001,lim=1000, ha="right",va="bottom", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects=(0.8,0.8) ,arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
-        adjust_text(texts_r,autoalign =False,precision =0.001,lim=1000, ha="left",va="top", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects =(0.8,0.8),arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
-    
+                    texts_r.append(plt.text(row["OR_1"], row["OR_2_aligned"],to_anno_text, ha='left', va='top')) 
+        if len(texts_l)>0:
+            adjust_text(texts_l,autoalign =False,precision =0.001,lim=1000, ha="right",va="bottom", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects=(0.8,0.8) ,arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
+        if len(texts_r)>0:
+            adjust_text(texts_r,autoalign =False,precision =0.001,lim=1000, ha="left",va="top", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects =(0.8,0.8),arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
     elif type(anno) is dict:
+        sig_list_toanno = sig_list_merged.dropna(axis=0)
         # if input is a dict
         sig_list_toanno = sig_list_toanno.loc[sig_list_toanno.index.isin(list(anno.keys())),:]
         if is_q==True and anno_het == True:
@@ -696,9 +723,10 @@ def compare_effect(path1,
                     texts_l.append(plt.text(row["OR_1"], row["OR_2_aligned"],anno[index], ha='right', va='bottom')) 
                 else:
                     texts_r.append(plt.text(row["OR_1"], row["OR_2_aligned"],anno[index], ha='left', va='top')) 
-
-        adjust_text(texts_l,autoalign =False,precision =0.001,lim=1000, ha="right",va="bottom", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects=(0.8,0.8) ,arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
-        adjust_text(texts_r,autoalign =False,precision =0.001,lim=1000, ha="left",va="top", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects =(0.8,0.8),arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
+        if len(texts_l)>0:
+            adjust_text(texts_l,autoalign =False,precision =0.001,lim=1000, ha="right",va="bottom", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects=(0.8,0.8) ,arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
+        if len(texts_r)>0:
+            adjust_text(texts_r,autoalign =False,precision =0.001,lim=1000, ha="left",va="top", expand_text=(1,1.8) , expand_objects=(0.1,0.1), expand_points=(1.8,1.8) ,force_objects =(0.8,0.8),arrowprops=dict(arrowstyle='-|>', color='grey'),ax=ax)
     #################################################################################################################################
     
     # plot x=0,y=0, and a 45 degree line

gwaslab/viz_plot_mqqplot.py

@@ -139,7 +139,7 @@ def mqqplot(insumstats,
           anno_gtf_path=None,
           anno_adjust=False,
           anno_max_iter=100,
-          arm_offset=50,
+          arm_offset=None,
           arm_scale=1,
           anno_height=1,
           arm_scale_d=None,
@@ -291,7 +291,7 @@ def mqqplot(insumstats,
     if maf_bin_colors is None:
         maf_bin_colors = ["#f0ad4e","#5cb85c", "#5bc0de","#000042"]
     if save_args is None:
-        save_args = {"dpi":300,"facecolor":"white"}
+        save_args = {"dpi":400,"facecolor":"white"}
     if highlight is None:
         highlight = list()
     if highlight_anno_args is None:
@@ -329,6 +329,20 @@ def mqqplot(insumstats,
                     fig_args["dpi"]=72
                     scatter_args["rasterized"]=True
                     qq_scatter_args["rasterized"]=True
+                else:
+                    fig_args["dpi"] = save_args["dpi"]
+    
+    # configure dpi if saving the plot
+    fig_args, scatter_args, qq_scatter_args, save_args = _configure_fig_save_kwargs(save = save, 
+                                                                                    fig_args = fig_args, 
+                                                                                    scatter_args = scatter_args, 
+                                                                                    qq_scatter_args = qq_scatter_args, 
+                                                                                    save_args = save_args)
+
+
+    if len(anno_d) > 0 and arm_offset is None:
+        # in pixels
+        arm_offset = fig_args["dpi"] * repel_force * fig_args["figsize"][0]*0.5
 
     log.write("Start to create MQQ plot...{}:".format(_get_version()),verbose=verbose)
     log.write(" -Genomic coordinates version: {}...".format(build),verbose=verbose)
@@ -401,7 +415,7 @@ def mqqplot(insumstats,
     if mode=="b":
         sig_level=1,
         sig_line=False,
-        windowsizekb = 100000000   
+        #windowsizekb = 100000000   
         mode="mb"
         scatter_args={"marker":"s"}
         marker_size= (marker_size[1],marker_size[1])
@@ -522,8 +536,12 @@ def mqqplot(insumstats,
                                                     pos=pos, 
                                                     verbose=verbose, 
                                                     log=log)
+        
+        lines_to_plot = pd.Series(lines_to_plot.to_list() + [bmean, bmedian])
+    
     else:
         bmean, bmedian=0,0 
+    
 # P value conversion #####################################################################################################  
     
     # add raw_P and scaled_P
@@ -956,7 +974,7 @@ def mqqplot(insumstats,
             ax1.set_title(mtitle,fontsize=title_fontsize,family=font_family)
         log.write("Finished processing figure arts.",verbose=verbose)
 
-        # Add annotation arrows and texts
+        ## Add annotation arrows and texts
         log.write("Start to annotate variants...",verbose=verbose)
         ax1 = annotate_single(
                                 sumstats=sumstats,
@@ -1055,7 +1073,8 @@ def mqqplot(insumstats,
         fig.suptitle(title , fontsize = title_fontsize ,x=0.5, y=1.05)
     else:
         fig.suptitle(title , fontsize = title_fontsize, x=0.5,y=1)
-
+        ## Add annotation arrows and texts
+    
     # Saving figure
     save_figure(fig = fig, save = save, keyword=mode, save_args=save_args, log = log, verbose=verbose)
 
@@ -1069,7 +1088,31 @@ def mqqplot(insumstats,
 
 ##############################################################################################################################################################################
 
+def _configure_fig_save_kwargs(save=None, 
+                               fig_args=None, 
+                               scatter_args=None, 
+                               qq_scatter_args=None, 
+                               save_args=None):
+    if fig_args is None:
+        fig_args = dict()
+    if scatter_args is None:
+        scatter_args = dict()
+    if qq_scatter_args is None:
+        qq_scatter_args = dict()
+    if save_args is None:
+        save_args = dict()
 
+    if save is not None:
+        if type(save) is not bool:
+            if len(save)>3:
+                if save[-3:]=="pdf" or save[-3:]=="svg":
+                    # to save as vectorized plot
+                    fig_args["dpi"]=72
+                    scatter_args["rasterized"]=True
+                    qq_scatter_args["rasterized"]=True
+                else:
+                    fig_args["dpi"] = save_args["dpi"]
+    return fig_args, scatter_args, qq_scatter_args, save_args
 
 
 def _add_pad_to_x_axis(ax1, xpad, xpadl, xpadr, sumstats, pos, chrpad, xtight, log, verbose):
@@ -1104,12 +1147,6 @@ def _add_pad_to_x_axis(ax1, xpad, xpadl, xpadr, sumstats, pos, chrpad, xtight, l
     return ax1
 
 
-
-
-
-
-
-
 ##############################################################################################################################################################################
 def _configure_cols_to_use(insumstats, snpid,  chrom, pos, ea, nea, eaf, p, mlog10p,scaled, mode,stratified,anno, anno_set, anno_alias,_chrom_df_for_i,highlight ,pinpoint,density_color):
     usecols=[]
@@ -1287,9 +1324,10 @@ def _process_density(sumstats, mode, bwindowsizekb, chrom, pos, verbose, log):
                 else:
                     break
         df = pd.DataFrame(stack,columns=["SNPID","TCHR+POS","DENSITY"])
-        sumstats["DENSITY"] = df["DENSITY"].values
-        bmean=sumstats["DENSITY"].mean()
-        bmedian=sumstats["DENSITY"].median()
+        sumstats["DENSITY"] = df["DENSITY"].astype("Float64").values
+
+        bmean=sumstats.drop_duplicates(subset="SNPID")["DENSITY"].mean()
+        bmedian=sumstats.drop_duplicates(subset="SNPID")["DENSITY"].median()
     elif "b" in mode and "DENSITY" in sumstats.columns:
         bmean=sumstats["DENSITY"].mean()
         bmedian=sumstats["DENSITY"].median()
@@ -1305,6 +1343,7 @@ def _process_line(ax1, sig_line, suggestive_sig_line, additional_line, lines_to_
                                 linestyle="--",
                                 color=sig_line_color,
                                 zorder=1)
+        
     if suggestive_sig_line is True:
         suggestive_sig_line = ax1.axhline(y=lines_to_plot[1], 
                                             linewidth = sc_linewidth, 
@@ -1312,15 +1351,20 @@ def _process_line(ax1, sig_line, suggestive_sig_line, additional_line, lines_to_
                                             color=suggestive_sig_line_color,
                                             zorder=1)
     if additional_line is not None:
-        for index, level in enumerate(lines_to_plot[2:].values):
+        for index, level in enumerate(lines_to_plot[2:2+len(additional_line)].values):
             ax1.axhline(y=level, 
                         linewidth = sc_linewidth, 
                         linestyle="--", 
                         color=additional_line_color[index%len(additional_line_color)],
                         zorder=1)
-    if "b" in mode:   
+    if "b" in mode: 
+        bmean = lines_to_plot.iat[-2]
+        bmedian = lines_to_plot.iat[-1]
         # for brisbane plot, add median and mean line 
+        log.write(" -Plotting horizontal line (  mean DENISTY): y = {}".format(bmean),verbose=verbose) 
         meanline = ax1.axhline(y=bmean, linewidth = sc_linewidth,linestyle="-",color=sig_line_color,zorder=1000)
+
+        log.write(" -Plotting horizontal line ( median DENISTY): y = {}".format(bmedian),verbose=verbose) 
         medianline = ax1.axhline(y=bmedian, linewidth = sc_linewidth,linestyle="--",color=sig_line_color,zorder=1000)
     return ax1
 
@@ -1441,10 +1485,16 @@ def _process_layout(mode, figax, fig_args, mqqratio, region_hspace):
             ax2 = None
             plt.subplots_adjust(hspace=region_hspace)
     elif mode =="b" :
-        fig_args["figsize"] = (15,5)
-        fig, ax1 = plt.subplots(1, 1,**fig_args)
-        ax2 = None
-        ax3 = None
+        if figax is not None:
+            fig = figax[0]
+            ax1 = figax[1]
+            ax3 = None
+            ax2 = None
+        else:
+            fig_args["figsize"] = (15,5)
+            fig, ax1 = plt.subplots(1, 1,**fig_args)
+            ax2 = None
+            ax3 = None
     else:
         raise ValueError("Please select one from the 5 modes: mqq/qqm/m/qq/r/b")
     ax4=None

gwaslab/viz_plot_phe_heatmap.py

@@ -0,0 +1,260 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+import scipy as sp
+from gwaslab.viz_aux_quickfix import _quick_assign_i_with_rank
+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
+from gwaslab.viz_aux_quickfix import _quick_fix_chr
+from gwaslab.viz_aux_quickfix import _quick_fix_eaf
+from gwaslab.viz_aux_quickfix import _quick_fix_mlog10p
+from gwaslab.viz_aux_quickfix import _dropna_in_cols
+from gwaslab.viz_plot_mqqplot import _process_p_value
+from gwaslab.viz_plot_mqqplot import _configure_fig_save_kwargs
+from gwaslab.viz_plot_mqqplot import mqqplot
+from gwaslab.viz_aux_save_figure import save_figure
+from gwaslab.g_Log import Log
+import copy
+from gwaslab.bd_common_data import get_chr_to_number
+from gwaslab.bd_common_data import get_number_to_chr
+from gwaslab.g_version import _get_version
+
+def _gwheatmap(
+    insumstats,    
+    chrom="CHR",
+    pos="POS",
+    ref_chrom="REF_CHR",
+    ref_pos="REF_START",
+    p="P",
+    scaled=False,
+    sizes = (10,50),
+    alpha=0.5,
+    mlog10p="MLOG10P",
+    snpid="SNPID",
+    eaf=None,
+    group="CIS/TRANS",
+    ea="EA",
+    nea="NEA",
+    colors=None,
+    check = True,
+    chr_dict = None,
+    xchrpad = 0, 
+    ychrpad=0,
+    use_rank = False,
+    xtick_chr_dict=None, 
+    ytick_chr_dict=None, 
+    fontsize=10, 
+    add_b =False,
+    log=Log(),
+    fig_kwargs=None,
+    scatter_kwargs=None,
+    height_ratios=None,
+    hspace = 0.1,
+    font_family="Arial",
+    cis_windowsizekb=100,
+    verbose=True,
+    save=True,
+    save_kwargs=None,
+    grid_linewidth=1,
+    grid_linecolor="grey",
+    **mqq_kwargs
+):
+    log.write("Start to create genome-wide scatter plot...{}:".format(_get_version()),verbose=verbose)
+    if height_ratios is None:
+        height_ratios = [1, 2]
+    if xtick_chr_dict is None:         
+        xtick_chr_dict = get_number_to_chr()
+    if ytick_chr_dict is None:         
+        ytick_chr_dict = get_number_to_chr()
+    if chr_dict is None:          
+        chr_dict = get_chr_to_number()
+    if colors is None:
+        colors=["#CB132D","#597FBD"]
+    if fig_kwargs is None:
+        fig_kwargs= dict(figsize=(15,15))
+    if save_kwargs is None:
+        save_kwargs = {"dpi":300,"facecolor":"white"}
+    if scatter_kwargs is None:
+        scatter_kwargs = {}
+
+    fig_kwargs, scatter_kwargs, qq_scatter_args, save_kwargs = _configure_fig_save_kwargs(save=save, 
+                                                                                    fig_args = fig_kwargs, 
+                                                                                    scatter_args = scatter_kwargs, 
+                                                                                    qq_scatter_args = dict(), 
+                                                                                    save_args = save_kwargs)
+
+    sumstats = insumstats.copy()
+    
+    # Data QC and format
+    if check ==True:
+        sumstats[pos] = _quick_fix_pos(sumstats[pos])
+        sumstats[chrom] = _quick_fix_chr(sumstats[chrom], chr_dict=chr_dict)
+        sumstats[ref_pos] = _quick_fix_pos(sumstats[ref_pos])
+        sumstats[ref_chrom] = _quick_fix_chr(sumstats[ref_chrom], chr_dict=chr_dict)
+        sumstats = _dropna_in_cols(sumstats, [pos, chrom, ref_pos, ref_chrom], log=log, verbose=verbose)
+    
+    # dropna
+    sumstats = sumstats.sort_values(by=group)
+
+    if scaled is True:
+        sumstats["raw_P"] = pd.to_numeric(sumstats[mlog10p], errors='coerce')
+    else:
+        sumstats["raw_P"] = sumstats[p].astype("float64")
+
+    sumstats =  _process_p_value(sumstats=sumstats, 
+                                mode="m",
+                                p=p, 
+                                mlog10p=mlog10p, 
+                                scaled=scaled, 
+                                log=log, 
+                                verbose=verbose )
+    
+    
+    
+    if add_b ==False:
+        fig, ax1 = plt.subplots(**fig_kwargs)
+    else:
+        fig, (ax2, ax1) = plt.subplots( nrows=2 ,sharex=True, gridspec_kw={'height_ratios': height_ratios }, **fig_kwargs)
+        plt.subplots_adjust(hspace=hspace)   
+
+    ## assign i for variants
+    sumstats, chrom_df_x = _quick_assign_i_with_rank(sumstats, 
+                                                chrpad=xchrpad, 
+                                                use_rank=use_rank, 
+                                                chrom=chrom,
+                                                pos=pos,
+                                                verbose=verbose)
+    chrom_df_b = chrom_df_x
+    sumstats = sumstats.rename(columns={"i":"i_x"})
+    add_x_unique = list(sumstats["_ADD"].unique()) 
+    
+    ## determine grouping methods for Y
+    ## assign i for Y group
+    sumstats, chrom_df_y = _quick_assign_i_with_rank(sumstats, 
+                              chrpad=ychrpad, 
+                              use_rank=use_rank, 
+                              chrom=ref_chrom,
+                              pos=ref_pos,
+                              verbose=verbose)
+    
+    sumstats = sumstats.rename(columns={"i":"i_y"})
+    add_y_unique = list(sumstats["_ADD"].unique()) 
+    
+    if add_b == True:
+        sumstats["i"] = sumstats["i_x"]
+        fig,log = mqqplot(sumstats,
+                        chrom=chrom,
+                        pos=pos,
+                        p=p,
+                        mlog10p=mlog10p,
+                        snpid=snpid,
+                        scaled=scaled,
+                        log=log, 
+                        mode="b",
+                        figax=(fig,ax2),
+                        _chrom_df_for_i = chrom_df_b,
+                        _invert=False,
+                        _if_quick_qc=False,
+                        **mqq_kwargs
+                        )
+    ## 
+    #min_xy = min(min(sumstats["i_x"]),min(sumstats["i_y"]))
+    #max_xy = max(max(sumstats["i_x"]),max(sumstats["i_y"]))
+    
+    ## determine color 
+
+    ## determine dot size
+
+    ## plot  
+    legend = True
+    style=None
+    linewidth=0
+    edgecolor="black"
+
+    palette = sns.color_palette(colors,n_colors=sumstats[group].nunique()) 
+    
+    #for index,g in enumerate(sumstats[group].unique()):
+    #    
+    #    palette = sns.color_palette("dark:{}".format(colors[index]), as_cmap=True)
+    #    
+    #    plot = sns.scatterplot(data=sumstats.loc[sumstats[group]==g,:], x='i_x', y='i_y',
+    #            hue="scaled_P",
+    #            palette=palette,
+    #            size="scaled_P",
+    #            alpha=alpha,
+    #            sizes=sizes,
+    #            legend=legend,
+    #            style=style,
+    #            linewidth=linewidth,
+    #            edgecolor = edgecolor,
+    #            zorder=2,
+    #            ax=ax1)   
+    
+    plot = sns.scatterplot(data=sumstats, x='i_x', y='i_y',
+            hue=group,
+            palette=palette,
+            size="scaled_P",
+            alpha=alpha,
+            sizes=sizes,
+            legend=legend,
+            style=style,
+            linewidth=linewidth,
+            edgecolor = edgecolor,
+            zorder=2,
+            ax=ax1)   
+    
+    handles, labels = ax1.get_legend_handles_labels()
+    new_labels = []
+    ncol = len(labels)
+    for i in labels:
+        if i==group:
+            new_labels.append("Group")
+        elif i=="scaled_P":
+            new_labels.append("$-log_{10}(P)$")
+        else:
+            new_labels.append(i)
+    
+    ax1.legend(labels = new_labels,  handles=handles, loc="lower center", bbox_to_anchor=(.45, -0.17), 
+                    ncol=ncol, scatterpoints=2, title=None, frameon=False)
+
+    ## add vertical line
+    for i in add_x_unique:
+        ax1.axvline(x = i+0.5, linewidth = grid_linewidth,color=grid_linecolor,zorder=1000 )
+    for i in add_y_unique:
+        ax1.axhline(y = i+0.5,  linewidth = grid_linewidth,color=grid_linecolor,zorder=1000 )
+
+    
+    ## add X tick label 
+    ax1 = _process_xtick(ax1, chrom_df_x, xtick_chr_dict, fontsize, font_family, log=log,verbose=True)
+    ## add Y tick label 
+    ax1 = _process_ytick(ax1, chrom_df_y, ytick_chr_dict, fontsize, font_family, log=log,verbose=True)
+    
+    ## set x y lim
+    ax1.set_ylim([0.5,sumstats["i_y"].max()+1])
+    ax1.set_xlim([0.5,sumstats["i_x"].max()+1])
+
+    ## set x y label
+
+    xlabel = "pQTL position"
+    ax1.set_xlabel(xlabel,fontsize=fontsize,family=font_family)
+    ylabel = "location of the gene encoding the target protein"
+    ax1.set_ylabel(ylabel,fontsize=fontsize,family=font_family)
+    
+    save_figure(fig = fig, save = save, keyword="gwheatmap",  save_args=save_kwargs, log = log, verbose=verbose)
+
+    return fig, log
+
+################################################################################################################
+def _process_xtick(ax1, chrom_df, xtick_chr_dict, fontsize, font_family, log=Log(),verbose=True):
+    log.write(" -Processing X ticks...",verbose=verbose)
+    ax1.set_xticks(chrom_df.astype("float64"))
+    ax1.set_xticklabels(chrom_df.index.astype("Int64").map(xtick_chr_dict),fontsize=fontsize,family=font_family)    
+    return ax1
+
+def _process_ytick(ax1, chrom_df, ytick_chr_dict, fontsize, font_family, log=Log(),verbose=True):
+    log.write(" -Processing Y ticks...",verbose=verbose)
+    ax1.set_yticks(chrom_df.astype("float64"))
+    ax1.set_yticklabels(chrom_df.index.astype("Int64").map(ytick_chr_dict),fontsize=fontsize,family=font_family)    
+    return ax1

{gwaslab-3.4.49.dist-info → gwaslab-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gwaslab
-Version: 3.4.49
+Version: 3.5.0
 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.4.49.dist-info → gwaslab-3.5.0.dist-info}/RECORD

@@ -6,13 +6,13 @@ gwaslab/bd_get_hapmap3.py,sha256=asNjQYeGfQi8u3jnfenRvDdKMs5ptql5wpcUzqMlwUI,393
 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=qWBh14-XheS88KLm2vr0OKRAhU9VmbUvy90T4L52zAo,36265
+gwaslab/g_Sumstats.py,sha256=6bzc7Sf23fIZRP85h-hQJC8DsBl3YLZNBUKJaOboHJQ,36639
 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=dhN-3rbJKALlFhTZACsxBZL_U8j4PQmcVuCuWx9dapo,1886
+gwaslab/g_version.py,sha256=ll9kIVGycz_99ofwzsFd_semBDePvcEjIqqCgWdVa_8,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
@@ -50,20 +50,21 @@ gwaslab/util_in_correct_winnerscurse.py,sha256=Gp--yAQ8MMzdkWIvXP9C1BHVjZc-YzqHf
 gwaslab/util_in_fill_data.py,sha256=iVq5WLWwFI03v9HyvBanu5si3j2p-oyPFTl8jsX69xM,14693
 gwaslab/util_in_filter_value.py,sha256=dY4X66N9A4MHCRHjPqLYFufMM91ggLRwUBf_nJYh8Lg,23605
 gwaslab/util_in_get_density.py,sha256=kpKXH69acMkeYVG5vs-VbJC3COhmuLBfYco-wuOxgjc,3934
-gwaslab/util_in_get_sig.py,sha256=9kq1GXacknO2YnVmsTli1GlPA728ASweTZ3UKm3Wszo,38783
+gwaslab/util_in_get_sig.py,sha256=53NOh7KueLY3vJPTNhhb37KPAIgLEfcP3k2zIV61lc4,39845
 gwaslab/util_in_meta.py,sha256=5K9lIZcIgUy0AERqHy1GvMN2X6dp45JUUgopuDLgt4o,11284
 gwaslab/util_in_snphwe.py,sha256=-KpIDx6vn_nah6H55IkV2OyjXQVXV13XyBL069WE1wM,1751
-gwaslab/viz_aux_annotate_plot.py,sha256=UTOx-OpFsM_UVphBHxqQZwCFI8bjwwB6CMsgFbAfheQ,32215
+gwaslab/viz_aux_annotate_plot.py,sha256=i-Fvg_4H6LZvENM6F_yH9-sVSxjD_9LwVhlvgHusW6w,25006
 gwaslab/viz_aux_chromatin.py,sha256=7cGmej5EkKO7fxR1b5w8r1oRRl9ofVzFRG52SCYWtz0,4109
-gwaslab/viz_aux_quickfix.py,sha256=5XM-J9D2yp5FVbK6YQKEhSCqAYBLNWSQms9WjpXxVn8,18313
+gwaslab/viz_aux_quickfix.py,sha256=HnhVvY0GP0EN0gLJ-B11OYiE5PWDcdKGUpQ3QZeu0lE,18592
 gwaslab/viz_aux_reposition_text.py,sha256=iRIP-Rkltlei068HekJcVubiqPrunBqvAoSQ1eHk04M,4304
-gwaslab/viz_aux_save_figure.py,sha256=nL-aoE8Kg06h7FgleGRBIZjhI-6w5gpn3E1HWMwBig8,2664
+gwaslab/viz_aux_save_figure.py,sha256=GdUXNBOelsWqtTXm8pEZzeGGwDxHYnBkyrGwLOK16ew,2723
 gwaslab/viz_plot_compare_af.py,sha256=qtXW45-Sq_ugK8ZfqBYMpmf58SKi3lB3YyHnzn_akcE,5344
-gwaslab/viz_plot_compare_effect.py,sha256=lV-4KSQatTSsYqzEGGTkBu17I2VlVyVh1uJr-kCq630,49585
+gwaslab/viz_plot_compare_effect.py,sha256=60KlfRGj1TSc0-NCaInZ7GMiAUveXe4qDCjIW-RHJNE,51304
 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=q_c_ZDRdirEcdHHnb030h7dTUWAFy9OVuzwbdCzZ3gU,64580
+gwaslab/viz_plot_mqqplot.py,sha256=nIwS3fMAXv_LVn7l9koSFZiZbcKCyuVq6Qg5fMzrEps,67049
+gwaslab/viz_plot_phe_heatmap.py,sha256=vCCPAiTyBBVklZahXG_zmyxXPgm0d7ArVha7A6gJaok,9514
 gwaslab/viz_plot_qqplot.py,sha256=psQgVpP29686CEZkzQz0iRbApzqy7aE3GGiBcazVvNw,7247
 gwaslab/viz_plot_regional2.py,sha256=tBoGox-4ngL5o_twdIjk_VW6Iam3JDyrPKuttm6_4Sg,36862
 gwaslab/viz_plot_regionalplot.py,sha256=8u-5-yfy-UaXhaxVVz3Y5k2kBAoqzczUw1hyyD450iI,37983
@@ -78,9 +79,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.4.49.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gwaslab-3.4.49.dist-info/LICENSE_before_v3.4.39,sha256=GhLOU_1UDEKeOacYhsRN_m9u-eIuVTazSndZPeNcTZA,1066
-gwaslab-3.4.49.dist-info/METADATA,sha256=bA0qeWgxt5mOkt_aL4aW_v4csyNSJCsbY6wrKMLyqY8,7752
-gwaslab-3.4.49.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-gwaslab-3.4.49.dist-info/top_level.txt,sha256=PyY6hWtrALpv2MAN3kjkIAzJNmmBTH5a2risz9KwH08,8
-gwaslab-3.4.49.dist-info/RECORD,,
+gwaslab-3.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gwaslab-3.5.0.dist-info/LICENSE_before_v3.4.39,sha256=GhLOU_1UDEKeOacYhsRN_m9u-eIuVTazSndZPeNcTZA,1066
+gwaslab-3.5.0.dist-info/METADATA,sha256=SocHVFBOrjeEchxsvVLUgI4CZPwSypppxfSE7o7yp1I,7751
+gwaslab-3.5.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+gwaslab-3.5.0.dist-info/top_level.txt,sha256=PyY6hWtrALpv2MAN3kjkIAzJNmmBTH5a2risz9KwH08,8
+gwaslab-3.5.0.dist-info/RECORD,,