offtracker 1.0.2__zip → 2.7.7__zip

{offtracker-1.0.2/offtracker.egg-info → offtracker-2.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: offtracker
-Version: 1.0.2
+Version: 2.7.7
 Summary: Track-seq data analysis
 Home-page: https://github.com/Lan-lab/offtracker
 Author: Runda Xu

offtracker-2.7.7/offtracker/X_offplot.py

@@ -0,0 +1,123 @@
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import pandas as pd
+
+def offtable(offtargets, target_guide, 
+                         col_seq='best_target', col_score='track_score', col_mismatch='mismatch', col_loc='target_location',
+                         title=None, font='Arial', font_size=9, 
+                         box_size_x=15, box_size_y=20, box_gap=1,
+                         x_offset=15, y_offset=35, dpi=100, savefig=None):
+    # Facecolor
+    color_dict = {
+        'A': 'lightgreen',
+        'T': 'lightblue',
+        'C': 'lightcoral',
+        'G': 'lightgoldenrodyellow',
+        'N': 'lightgrey',
+        '—': 'orange',
+        '-': 'orange'
+    }
+
+    # If offtargets is a DataFrame, convert to list of dictionaries
+    if isinstance(offtargets, pd.DataFrame):
+        offtargets = offtargets.to_dict(orient='records')
+
+    # Configuration
+    # title=None
+    # font='Arial'
+    # font_size = 9
+    # box_size_x = 15 # 一个碱基图形的宽度
+    # box_size_y = 20 # 一个碱基图形的高度
+    # box_gap = 1 # 两行之间的间隔
+    # x_offset = 15
+    # y_offset = 35
+    # dpi=100
+    # col_seq='best_target'
+    # col_score='track_score'
+    # col_mismatch='mismatch'
+    # col_loc='target_location'
+    width = box_size_x * (len(target_guide) + 15)
+    height = y_offset + (len(offtargets) + 2) * (box_size_y + box_gap)
+    fig = plt.figure(figsize=(width / 100.0, height / 100.0), dpi=dpi)
+    ax = fig.add_subplot(111)
+
+    # Plot a title
+    ax.text(x_offset, 25, "Off-targets table" if title is None else f"{title}", fontsize=14, family=font)
+
+    # Plot the reference sequence
+    for i, c in enumerate(target_guide):
+        x = x_offset + i * box_size_x
+        y = y_offset
+        base_color = color_dict.get(c, 'purple') # Default to purple if base is not recognized
+        ax.add_patch(patches.Rectangle((x, y), box_size_x, box_size_y, facecolor=base_color))
+        ax.text(x + box_size_x / 2, y + box_size_y / 2, c, ha='center', va='center', family=font, fontsize=font_size)
+    # add column annotations
+    ax.text(x_offset + (len(target_guide) + 2) * box_size_x, y_offset + box_size_y / 4, 'Track\nScore', ha='center', va='center', family=font, fontsize=font_size*1.1)
+    #ax.text(x_offset + (len(target_guide) + 7) * box_size_x, y_offset + box_size_y / 2, 'Mismatch', ha='center', va='center', family=font, fontsize=font_size*1.1)
+    ax.text(x_offset + (len(target_guide) + 4) * box_size_x, y_offset + box_size_y / 2, 'Coordinates', ha='left', va='center', family=font, fontsize=font_size*1.1)
+
+    # Plot aligned sequences
+    # 目前有个bug：脱靶序列如果有 insertion，长度会不一致，而且也没想到画图怎么画，只能是默认删掉第一个碱基
+    for j, seq in enumerate(offtargets):
+        y = y_offset + (j + 1) * (box_size_y + box_gap)
+        # 长度不一致的情况
+        len_out = len(seq[col_seq]) - len(target_guide)
+        if len_out > 0:
+            if len_out > 1:
+                print(f"Warning: {seq[col_seq]} is {len_out} longer than {target_guide}")
+            # 通过比较删除开头的碱基和最后的碱基，看哪个更接近target_guide
+            delete_first = seq[col_seq][len_out:]
+            delete_last = seq[col_seq][:-len_out]
+            # 计算两个序列和target_guide的hamming distance
+            hamming_first = sum([1 for i, c in enumerate(delete_first) if c != target_guide[i]])
+            hamming_last = sum([1 for i, c in enumerate(delete_last) if c != target_guide[i]])
+            # 选择hamming distance小的那个序列
+            if hamming_first < hamming_last:
+                seq[col_seq] = delete_first
+            else:
+                seq[col_seq] = delete_last
+        elif len_out < 0:
+            print(f"Warning: {seq[col_seq]} is {-len_out} shorter than {target_guide}")
+            
+        for i, c in enumerate(seq[col_seq]):
+            # gap 的 - (minus sign) 太短了，所以替换成 — (em dash)
+            if c == '-':
+                c = '—'
+            x = x_offset + i * box_size_x
+            base_color = color_dict.get(c, 'purple') # Default to purple if base is not recognized
+            if c == target_guide[i]:
+                ax.add_patch(patches.Rectangle((x, y), box_size_x, box_size_y, facecolor='white')) # same
+            elif target_guide[i] == 'N':
+                ax.add_patch(patches.Rectangle((x, y), box_size_x, box_size_y, facecolor='white')) # N in target
+            else:
+                ax.add_patch(patches.Rectangle((x, y), box_size_x, box_size_y, facecolor=base_color))
+            ax.text(x + box_size_x / 2, y + box_size_y / 2, "." if c == target_guide[i] else c, ha='center', va='center', family=font, fontsize=font_size, weight='bold')
+
+        # Annotations for score, mismatches, and location coordinates
+        ax.text(x_offset + (len(target_guide) + 2) * box_size_x, y + box_size_y / 2, round(seq[col_score],2), ha='center', va='center', family=font, fontsize=font_size)
+        #ax.text(x_offset + (len(target_guide) + 7) * box_size_x, y + box_size_y / 2, "Target" if seq[col_mismatch] == 0 else seq[col_mismatch], ha='center', va='center', family=font, fontsize=font_size, color='red' if seq[col_mismatch] == 0 else 'black')
+        ax.text(x_offset + (len(target_guide) + 4) * box_size_x, y + box_size_y / 2, seq[col_loc], ha='left', va='center', family=font, fontsize=font_size)
+
+    # add a vertical line to indicate the PAM
+    x_line = x_offset + (len(target_guide) - 3) * box_size_x
+    y_start = y_offset # + box_size_y / 2 
+    y_end = y_start + (len(offtargets)+1) * (box_size_y + box_gap)
+    ax.vlines(x=x_line, ymin=y_start, ymax=y_end, color='indianred', linestyle='--')
+
+    # Styling and save
+    ax.set_xlim(0, width*1.1) # location 的文字太长了，所以要加长一点
+    ax.set_ylim(height, 0)
+    ax.axis('off')
+
+    # # This will make the subplot(s) expand to fill the entire figure area, with no padding on any side. 
+    # # In brief, make the plot bigger (not influence the font size)
+    plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
+    if savefig is not None:
+        plt.savefig(savefig, dpi=dpi)
+    plt.show()
+    return ax
+
+
+
+
+

offtracker-2.7.7/offtracker/X_offtracker.py

@@ -0,0 +1,338 @@
+
+import pandas as pd
+import numpy as np
+import os, sys
+sys.path.append( os.path.abspath(os.path.dirname(__file__)) )
+
+def fdr(p_vals):
+    # Benjamini-Hochberg
+    from scipy.stats import rankdata
+    ranked_p_values = rankdata(p_vals)
+    fdr = p_vals * len(p_vals) / ranked_p_values
+    fdr[fdr > 1] = 1
+    return fdr
+
+def dedup_two( df_loc, col_ID_1='ID_1', col_ID_2='ID_2'):
+    # 会根据 df_loc 的排序保留第一个 location
+    # dedup 结束后，剩下的 ID_1 + ID_2 并集可能会小于 dedup 前的并集
+    list_nondup = []
+    set_IDs = set()
+    df_IDs = df_loc[[col_ID_1,col_ID_2]]
+    for a_row in df_IDs.iterrows():
+        temp = a_row[1]
+        if (temp[col_ID_1] in set_IDs) or (temp[col_ID_2] in set_IDs):
+            # 只要有一ID出现过，即便另一ID没出现过，也不更新 set_IDs
+            list_nondup.append(False)
+        else:
+            set_IDs.add(temp[col_ID_1])
+            set_IDs.add(temp[col_ID_2])
+            list_nondup.append(True)
+    return list_nondup
+
+def window_smooth(sr_smooth, window_size=3, times=1):
+    window  = np.ones(window_size) / window_size
+
+    bool_index = False
+    if isinstance(sr_smooth, pd.Series):
+        sr_index = sr_smooth.index 
+        bool_index = True
+    
+    for i in range(times):
+        sr_smooth = pd.Series(np.convolve(sr_smooth, window, mode='same'))
+    
+    if bool_index:
+        sr_smooth.index = sr_index
+    
+    return sr_smooth
+
+# 每 n 个数取平均
+def segmental_mean(vector, n, drop='last'):
+    # Identify the length and remainder
+    length = len(vector)
+    rem = length % n
+    # If there is a remainder
+    if rem != 0:
+        if drop=='last':
+            main_part = vector[:-rem]  # Part that could be reshaped
+            #last_part = vector[-rem:]  # Excessive part in the end
+            array = np.array(main_part).reshape(-1, n)
+            result = array.mean(axis=1)
+        elif drop=='first':
+            main_part = vector[rem:]  # Part that could be reshaped
+            #first_part = vector[:rem]  # Excessive part in the start
+            array = np.array(main_part).reshape(-1, n)
+            result = array.mean(axis=1)
+    else:
+        # If there's no remainder, proceed as usual
+        array = np.array(vector).reshape(-1, n)
+        result = array.mean(axis=1)
+
+    return result
+
+# v2.1 版本的计算信号长度存在一个问题：bw add 后，不是严格按 binsize 分割的，连续几个区域同数值，会被合并，但是这里都按 binsize 算，导致长度可能偏小
+# v2.6 按 flank regions 分别取子集，避免根据 binsize 推测行数的误差，并且加入 trackseq v4 版本的正负bin占比计算
+def target_signal(df_bdg_chr, chrom, cleavage_site, flank_max=100000, smooth_times = 1, window_size = 3, 
+                  binsize=100, flank_regions=[500,1000,2000,5000], 
+                  length_bkg = 20000, length_binsize=1000, length_min_noise=0.2, n_std=1, 
+                  end='end',start='start',value='residual', pct_offset=0.0):
+    # 输入数据必须是同一条染色体内的
+    # 统计 flank regions 的个数
+    # n_regions = len(flank_regions)
+    ## 根据 binsize 计算每个 flank region 对应长度的 row 个数， 会有偏差
+    ## flank_bins = [int(x/binsize) for x in flank_regions] # 取消这个算法
+    
+    assert flank_max >= max(flank_regions), 'flank_max must be larger than max(flank_regions)'
+    assert length_binsize >= binsize, 'length_binsize must be larger than binsize'
+    n_merge = int(length_binsize/binsize)
+    n_bkg = int(length_bkg/length_binsize)
+
+    # Left
+    # 新版增加 list_signal_pct_L 会带 (pos_pct_left, left_pos_sum, left_neg_sum)*n_regions 外加一个 list_pct_score_L
+    # list_signal_residual_L 数值和之前类似
+    list_signal_pct_L = []
+    list_pct_score_L = []
+    list_signal_residual_L = []
+    df_bdg_chr_L = df_bdg_chr[ (df_bdg_chr[end] >= cleavage_site-flank_max) & (df_bdg_chr[end]<=cleavage_site) ]
+    if len(df_bdg_chr_L)<=window_size:
+        L_length = 0
+        L_overall_signal = 0
+        for flank in flank_regions:
+            list_signal_pct_L.extend([0,0,0])
+            list_pct_score_L.append(0)
+            list_signal_residual_L.append(0)
+    else:
+        ##################
+        ## 先算 overall ##
+        ##################
+        L_length = 0
+        # 信号平滑
+        if smooth_times > 0:
+           signal_residual_L = window_smooth(df_bdg_chr_L[value], window_size=window_size, times=smooth_times)
+        else:
+           signal_residual_L = df_bdg_chr_L[value]
+        # 信号长度
+        # 增大 binsize 减少随机波动，增大到 length_binsize 长度
+        signal_residual_L_merged = segmental_mean(signal_residual_L, n_merge, drop='first')
+        # 防止出现长度不足的情况，然后二次平滑
+        if len(signal_residual_L_merged)<=window_size:
+            L_length = 0
+            L_overall_signal = 0
+        else:
+            signal_residual_L_merged = window_smooth(signal_residual_L_merged, window_size=3, times=3)
+            # 计算背景和阈值
+            bkg_L_mean = signal_residual_L_merged[:n_bkg].mean()
+            bkg_L_std = max(length_min_noise, signal_residual_L_merged[:n_bkg].std())
+            # 平移到均值为0
+            # signal_residual_L_merged = signal_residual_L_merged - bkg_L_mean
+            # 最后一个小于 threshold 的位点
+            signal_start_index = signal_residual_L_merged.index[signal_residual_L_merged<bkg_L_mean+n_std*bkg_L_std].max()
+            # 计算信号长度
+            L_n_bins = signal_residual_L_merged.index.max()-signal_start_index
+            if L_n_bins == 0:
+                L_length = 0
+            else:
+                df_bdg_chr_L_good = df_bdg_chr_L[-n_merge*L_n_bins:]
+                L_length = df_bdg_chr_L_good[end].iloc[-1]-df_bdg_chr_L_good[start].iloc[0]
+            # 计算 overall 信号强度
+            L_overall_signal = signal_residual_L_merged.sum()
+
+        ###################
+        ## 再算 proximal ##
+        ###################
+        # left_region_sum_norm 应该约等于 v2.5 以前的单一数值
+        for flank in flank_regions:
+            bool_flank = (df_bdg_chr_L[end] >= cleavage_site-flank)
+            df_bdg_chr_L_flank = df_bdg_chr_L[ bool_flank ]
+            signal_residual_L_flank = signal_residual_L[ bool_flank ]
+            if df_bdg_chr_L_flank.empty:
+                list_signal_pct_L.extend( [0,0,0] )
+                list_pct_score_L.append(0)
+                list_signal_residual_L.append(0)
+                continue
+            # pos and neg
+            df_bdg_chr_L_flank_pos = df_bdg_chr_L_flank[df_bdg_chr_L_flank[value] > 0]
+            df_bdg_chr_L_flank_neg = df_bdg_chr_L_flank[df_bdg_chr_L_flank[value] <= 0]
+            n_pos_left = len(df_bdg_chr_L_flank_pos)
+            n_neg_left = len(df_bdg_chr_L_flank_neg)
+            # avoid zero
+            if n_pos_left == 0:
+                pos_pct_left = 0
+            else:
+                pos_pct_left = n_pos_left/(n_pos_left+n_neg_left)
+            # pos/neg value sum
+            left_pos_sum = df_bdg_chr_L_flank_pos[value].sum()
+            left_neg_sum = df_bdg_chr_L_flank_neg[value].sum()
+            list_signal_pct_L.extend( [pos_pct_left,left_pos_sum,left_neg_sum] ) 
+            # 平滑 sum
+            left_region_sum_norm = 1000*signal_residual_L_flank.sum()/flank
+            list_signal_residual_L.append(left_region_sum_norm)            
+            # pct_score
+            left_pct_score = left_region_sum_norm*max(0,(pos_pct_left-pct_offset))
+            list_pct_score_L.append(left_pct_score)
+
+    # Right
+    list_signal_pct_R = []
+    list_pct_score_R = []
+    list_signal_residual_R = []
+    df_bdg_chr_R = df_bdg_chr[ (df_bdg_chr[start] <= cleavage_site+flank_max) & (df_bdg_chr[start]>=cleavage_site) ].copy()
+    if len(df_bdg_chr_R)<=window_size:
+        R_length = 0
+        R_overall_signal = 0
+        for flank in flank_regions:
+            list_signal_pct_R.extend([0,0,0])
+            list_pct_score_R.append(0)
+            list_signal_residual_R.append(0)
+    else:
+        ##################
+        ## 先算 overall ##
+        ##################
+        R_length = 0
+        # 右侧信号反向
+        df_bdg_chr_R[value] = -df_bdg_chr_R[value]
+        # 信号平滑
+        if smooth_times > 0:
+           signal_residual_R = window_smooth(df_bdg_chr_R[value], window_size=window_size, times=smooth_times)
+        else:
+           signal_residual_R = df_bdg_chr_R[value]
+        # 信号长度
+        # 增大 binsize 减少随机波动，增大到 length_binsize 长度
+        signal_residual_R_merged = segmental_mean(signal_residual_R, n_merge, drop='last')
+        # 防止出现长度不足的情况
+        if len(signal_residual_R_merged)<=window_size:
+            R_length = 0
+            R_overall_signal = 0
+        else:
+            signal_residual_R_merged = window_smooth(signal_residual_R_merged, window_size=3, times=3)
+            # 计算背景和阈值
+            bkg_R_mean = signal_residual_R_merged[-n_bkg:].mean()
+            bkg_R_std = max(length_min_noise, signal_residual_R_merged[-n_bkg:].std())
+            # 平移到均值为0
+            # signal_residual_R_merged = signal_residual_R_merged - bkg_R_mean
+            # 第一个小于 threshold 的位点
+            signal_end_index = signal_residual_R_merged.index[signal_residual_R_merged<bkg_R_mean+n_std*bkg_R_std].min()
+            # 计算信号长度
+            R_n_bins = signal_end_index
+            if R_n_bins == 0:
+                R_length = 0
+            else:
+                df_bdg_chr_R_good = df_bdg_chr_R[:n_merge*R_n_bins]
+                R_length = df_bdg_chr_R_good[end].iloc[-1]-df_bdg_chr_R_good[start].iloc[0]
+            # 计算 overall 信号强度
+            R_overall_signal = signal_residual_R_merged.sum()
+        ###################
+        ## 再算 proximal ##
+        ###################
+        # 注意，上面的 df_bdg_chr_R[value] 是反向的，因此这边还是 pos 为有信号
+        for flank in flank_regions:
+            bool_flank = (df_bdg_chr_R[start] <= cleavage_site+flank)
+            df_bdg_chr_R_flank = df_bdg_chr_R[ bool_flank ]
+            signal_residual_R_flank = signal_residual_R[ bool_flank ]
+            if df_bdg_chr_R_flank.empty:
+                list_signal_pct_R.extend( [0,0,0] )
+                list_pct_score_R.append(0)
+                list_signal_residual_R.append(0)
+                continue
+            # pos and neg
+            df_bdg_chr_R_flank_pos = df_bdg_chr_R_flank[df_bdg_chr_R_flank[value] > 0]
+            df_bdg_chr_R_flank_neg = df_bdg_chr_R_flank[df_bdg_chr_R_flank[value] <= 0]
+            n_pos_right = len(df_bdg_chr_R_flank_pos)
+            n_neg_right = len(df_bdg_chr_R_flank_neg)
+            # avoid zero
+            if n_pos_right == 0:
+                pos_pct_right = 0
+            else:
+                pos_pct_right = n_pos_right/(n_pos_right+n_neg_right)
+            # pos/neg value sum
+            right_pos_sum = df_bdg_chr_R_flank_pos[value].sum()
+            right_neg_sum = df_bdg_chr_R_flank_neg[value].sum()
+            list_signal_pct_R.extend( [pos_pct_right,right_pos_sum,right_neg_sum] ) 
+            # 平滑 sum
+            right_region_sum_norm = 1000*signal_residual_R_flank.sum()/flank
+            list_signal_residual_R.append(right_region_sum_norm)            
+            # pct_score
+            right_pct_score = right_region_sum_norm*max(0,(pos_pct_right-pct_offset))
+            list_pct_score_R.append(right_pct_score)
+
+
+    # calculate proximal_signal
+    mean_signal_residual_L = np.mean(list_signal_residual_L)
+    mean_signal_residual_R = np.mean(list_signal_residual_R)
+    proximal_signal = mean_signal_residual_L+mean_signal_residual_R
+    # calculate pct_score
+    mean_pct_score_L = np.mean(list_pct_score_L)
+    mean_pct_score_R = np.mean(list_pct_score_R)
+    pct_score = mean_pct_score_L+mean_pct_score_R
+    # calculate length and overall_signal
+    signal_length = L_length + R_length
+    #pct_signal_length = L_pct_length + R_pct_length
+    # 有时候极远处有真编辑位点或者大噪音，会导致 overall_signal 的 bkg 不正确
+    if L_overall_signal > 2*(mean_pct_score_L+mean_signal_residual_L):
+        L_overall_signal = (mean_pct_score_L+mean_signal_residual_L)/2
+    if R_overall_signal > 2*(mean_pct_score_R+mean_signal_residual_R):
+        R_overall_signal = (mean_pct_score_R+mean_signal_residual_R)/2
+    overall_signal = L_overall_signal + R_overall_signal
+    list_return = list_signal_pct_L + list_signal_pct_R + \
+                  list_pct_score_L + list_pct_score_R + \
+                  list_signal_residual_L + list_signal_residual_R + \
+                  [mean_signal_residual_L, mean_signal_residual_R] + \
+                  [mean_pct_score_L, mean_pct_score_R] + \
+                  [chrom+':'+str(cleavage_site)] + \
+                  [L_length, R_length, L_overall_signal, R_overall_signal, signal_length, overall_signal, proximal_signal, pct_score]
+                  # [L_pct_length, R_pct_length, pct_signal_length] 暂时不加这里了，额外写一个函数
+                  # 2*3*n_regions
+                  # 2*n_regions
+                  # 2*n_regions
+                  # 2+2+1+8
+
+    return list_return
+
+def target_signal_chunk(df_bdg_chr, df_alignment_chr, flank_max=100000, smooth_times = 1, window_size = 3, binsize=100, flank_regions=[500,1000,2000,5000], 
+                        length_bkg = 20000, length_binsize=1000, length_min_noise=0.2, n_std=1, pct_offset=0.0):
+    # 输入数据必须是同一条染色体内的
+    list_target_all = []
+    for a_row in df_alignment_chr.iterrows():
+        chrom, cleavage_site = a_row[1]
+        list_target = target_signal(df_bdg_chr, chrom, cleavage_site, flank_max, smooth_times = smooth_times, window_size = window_size, binsize=binsize, flank_regions=flank_regions, 
+                                    length_bkg = length_bkg, length_binsize=length_binsize, length_min_noise=length_min_noise, n_std=n_std, pct_offset=pct_offset)
+        list_target_all.append(list_target)
+    df_result = pd.DataFrame(list_target_all)
+    pct_features_L = [['L_pos_pct_'+x,'L_pos_'+x,'L_neg_'+x] for x in pd.Series(flank_regions).astype(str)]
+    pct_features_L = [item for sublist in pct_features_L for item in sublist]
+    pct_features_R = [['R_pos_pct_'+x,'R_pos_'+x,'R_neg_'+x] for x in pd.Series(flank_regions).astype(str)]
+    pct_features_R = [item for sublist in pct_features_R for item in sublist]
+    df_result.columns = pct_features_L + pct_features_R + \
+                        list('L_pct_score_' + pd.Series(flank_regions).astype(str)) + list('R_pct_score_' + pd.Series(flank_regions).astype(str)) + \
+                        list('L_' + pd.Series(flank_regions).astype(str)) + list('R_' + pd.Series(flank_regions).astype(str)) + \
+                        ['L_mean', 'R_mean','L_mean_pct_score','R_mean_pct_score','chr_cleavage',
+                         'L_length', 'R_length', 'L_overall_signal', 'R_overall_signal', 'signal_length', 'overall_signal','proximal_signal','pct_score']
+    return df_result
+
+
+
+
+# 2024.01.22. 额外写一个 signal length 算法，增加基于 pos_pct 而非 smooth 后的 overall_signal 的 length，叫 singal_length
+def signal_length(df_bdg_chr, chrom, cleavage_site, end='end',start='start',value='residual', 
+                  flank_max=100000, binsize=100, pct_threshold=0.6):
+    # 输入数据必须是同一条染色体内的
+    # Left
+    df_bdg_chr_L = df_bdg_chr[ (df_bdg_chr[end] >= cleavage_site-flank_max) & (df_bdg_chr[end]<=cleavage_site) ].copy()
+    
+    # pos and neg
+    df_bdg_chr_L_flank_pos = df_bdg_chr_L_flank[df_bdg_chr_L_flank[value] > 0]
+    df_bdg_chr_L_flank_neg = df_bdg_chr_L_flank[df_bdg_chr_L_flank[value] <= 0]
+    n_pos_left = len(df_bdg_chr_L_flank_pos)
+    n_neg_left = len(df_bdg_chr_L_flank_neg)
+    # avoid zero
+    if n_pos_left == 0:
+        pos_pct_left = 0
+    else:
+        pos_pct_left = n_pos_left/(n_pos_left+n_neg_left)    
+    
+    
+    df_bdg_chr_R = df_bdg_chr[ (df_bdg_chr[start] <= cleavage_site+flank_max) & (df_bdg_chr[start]>=cleavage_site) ].copy()
+    # list_signal_residual_L 数值和之前类似
+    list_signal_pct_L = []
+    list_pct_score_L = []
+    list_signal_residual_L = []
+
+    return list_return

offtracker-1.0.2/offtracker/X_general.py → offtracker-2.7.7/offtracker/X_sequence.py

@@ -67,10 +67,10 @@ def write_fasta(df, output, name_col = 'ID', sequence_col='sequence', line_len =
                 f.write( df[sequence_col].iloc[i][ j*line_len : (j+1)*line_len ]   + '\n')
     return 'fasta is written.'
 
-def writebed(df, bed_dir):
+def write_bed(df, bed_dir):
     return df.to_csv(bed_dir, sep='\t', header=None, index=False)
 
-def readbed(bed_dir):
+def read_bed(bed_dir):
     return pd.read_csv(bed_dir,sep='\t',header=None)
 
 def X_readbed(bed_dir):
@@ -90,7 +90,7 @@ def bedfmt(igv):
     igv['ed'] = igv['ed'].astype(int)
     return igv
 
-def add_ID(df, chr_col=0, midpoint='midpoint'):
+def add_ID(df, chr_col=0, midpoint='cleavage_site'):#, midpoint='midpoint'):
 	chr_col_name = df.columns[chr_col]
 	print(f'chromosome col = {chr_col_name}')
 	point_head = (df[midpoint]/1000).astype(int)
@@ -130,7 +130,7 @@ def sgRNA_alignment(a_key, sgRNA, seq, frag_len, DNA_matrix=None, mismatch_score
     pos_ed = int(a_key.split('-')[1])
     chr_name = a_key.split(':')[0]
     target_st = pos_st + best_alignment.start
-    target_ed = pos_st + best_alignment.end - 1 # 
+    target_ed = pos_st + best_alignment.end - 1 - deletion # 2023.12.05 修正 deletion 错位
     target_location = chr_name + ':' + str(target_st) + '-' + str(target_ed)
     if return_align:
         return [best_alignment.score, position_pct, target, target_location, deletion, insertion, mismatch, best_alignment.seqB]
@@ -138,4 +138,17 @@ def sgRNA_alignment(a_key, sgRNA, seq, frag_len, DNA_matrix=None, mismatch_score
         return [best_alignment.score, position_pct, target, target_location, deletion, insertion, mismatch]
 
 
-
+def combine_df(list_df, op = 'mean'):
+    # df 行列、结构必须一模一样，非数字部分也一模一样，只有数字不同
+    df_nondigit = list_df[0].select_dtypes(exclude=[float, int])
+    if op=='mean':
+        df_combined = pd.concat(list_df).groupby(level=0).mean(numeric_only=True)
+    elif op=='max':
+        df_combined = pd.concat(list_df).groupby(level=0).max(numeric_only=True)
+    elif op=='min':
+        df_combined = pd.concat(list_df).groupby(level=0).min(numeric_only=True)
+    else:
+        print('op must be mean, max or min')
+    #
+    df_combined = pd.concat([df_nondigit, df_combined], axis=1)
+    return df_combined

{offtracker-1.0.2 → offtracker-2.7.7}/offtracker/__init__.py

@@ -1,2 +1,2 @@
 from ._version import __version__
-from . import X_general
+from .X_offtracker import *

offtracker-2.7.7/offtracker/_version.py

@@ -0,0 +1,27 @@
+__version__ = "2.7.7"
+# 2023.08.11. v1.1.0	adding a option for not normalizing the bw file
+# 2023.10.26. v1.9.0	prerelease for v2.0
+# 2023.10.27. v2.0.0	大更新，还没微调
+# 2023.10.28. v2.1.0 修复bug，增加计算信号长度的功能
+# 2023.10.28. v2.2.0 修复bug，改变计算信号长度的算法
+# 2023.10.29. v2.3.0 增加 overall signal 计算
+# 2023.11.01. v2.3.1 增加 signal_only 选项
+# 2023.11.02. v2.3.2 修改 sample signal 和 group mean 的计算顺序
+# 2023.11.04. v2.3.3 修复 overall score 标准化时排序错误的问题
+# 2023.11.05. v2.3.4 修复判断单边溢出信号时的列名选取错误
+# 2023.11.13. v2.3.5 微调 track score
+# 2023.12.05. v2.3.6 candidates 增加 cleavage site，修正 alignment 有 deletion 会错位的 bug
+# 2023.12.05. v2.3.7 用 cleavage site 代替 midpoint # 还没改完
+# 2023.12.07. v2.3.8 df_score 增加 df_exp, df_ctr 各自列。修复没 df_ctr 时的 bug。track score 用 proximal
+# 2023.12.09. v2.4.0 为了兼顾 proximal 和 overall，当 normalized overall signal 高于 2 时，增加 overall signal 的加分
+# 2023.12.09. v2.5.0 尝试新的加权位置
+# 2023.12.10. v2.6.0 加入 trackseq v4 的计算分支，即考虑 Region 内的 positive_pct，避免短而尖锐的信号
+# 2023.12.10. v2.6.1 有些非特异信号数值很大，如果在 control 组是大负数，可能导致减 control 后假高信号，因此给负数一个 clip
+# 2023.12.30. v2.7.0 增加 X_offplot 模块，用于绘图
+# 2023.12.31. v2.7.1 control 的负数值 clip 由 -5 改为 -1，进一步减少假阳性。另外不加 overall 了
+# 2024.01.01. v2.7.2 权重改为 proximal + pct = 1 + 1. 防信号外溢假阳性标准由<0改为<=0
+# 2024.01.02. v2.7.3 flank regions 默认值改为 1000 2000 3000 5000。之前 control 的负数值 clip 相当于直接在 final score，现在改为每个单独 clip 后重新算 score，默认值为 CtrClip=-0.5
+# 2024.01.03. v2.7.4 更新了 blacklist.bed
+# 2024.01.04. v2.7.5 更新了 hg38 blacklist.bed
+# 2024.01.12. v2.7.6 修复小bug，输出 fdr 改为 <0.05。
+# 2024.01.23. v2.7.7 Snakefile_offtracker: add --fixedStep to bigwigCompare for not merging neighbouring bins with equal values.