gwaslab 3.4.49__tar.gz → 3.5.0__tar.gz

{gwaslab-3.4.49/src/gwaslab.egg-info → gwaslab-3.5.0}/PKG-INFO

@@ -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 → gwaslab-3.5.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gwaslab"
-version = "3.4.49"
+version = "3.5.0"
 authors = [
   { name="Yunye", email="yunye@gwaslab.com" },
 ]

{gwaslab-3.4.49 → gwaslab-3.5.0}/src/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-3.4.49 → gwaslab-3.5.0}/src/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-3.4.49 → gwaslab-3.5.0}/src/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-3.4.49 → gwaslab-3.5.0}/src/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-3.4.49 → gwaslab-3.5.0}/src/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-3.4.49 → gwaslab-3.5.0}/src/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