BAITS 0.1__tar.gz

baits-0.1/.gitignore

@@ -0,0 +1 @@
+build/

baits-0.1/.readthedocs.yaml

@@ -0,0 +1,22 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version, and other tools you might need
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.10"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# Optionally, but recommended,
+# declare the Python requirements required to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+    - requirements: docs/requirements.txt

baits-0.1/BAITS/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,5 @@
+from . import gr, pl, tl
+
+__all__ = ["gr", "pl", "tl"]
+
+__version__ = version("B-HIT")

baits-0.1/BAITS/VDJ/__init__.py

@@ -0,0 +1,3 @@
+from . import tl, pl
+
+__all__ = ["tl", "pl"]

baits-0.1/BAITS/VDJ/pl/__init__.py

@@ -0,0 +1 @@
+from .basic_plot import _plot_bar, _boxplot, _scatter_plot, _plot_xcr

baits-0.1/BAITS/VDJ/pl/basic_plot.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+import seaborn as sns
+
+def _plot_bar(df, x, y, groupby=None, palette='Set2', xlabel=None, ylabel='Clone Richeness', ylog=False, ax=None, figsize=(4,3.5) ):
+    plt.figure(figsize=figsize)
+    sns.barplot(y=y, x=x, data=df, hue=groupby, palette='Set2', alpha=0.5) 
+    sns.stripplot(y=y, x=x, data=df, hue=groupby, dodge=True, jitter=0.2, palette='Set2')
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel) 
+    if ylog:
+        plt.yscale('log')
+
+
+def _boxplot(df, x, y, groupby=None, palette='Set2', xlabel=None, ylabel=None, log=False, ax=None ): 
+
+    sns.boxplot(data=df, x=x, y=y, hue=groupby, palette=palette, ax=ax ) 
+    
+    if ax:
+        ax.set_xlabel(xlabel)  # 设置x轴标签
+    if ax:
+        ax.set_ylabel(ylabel)  # 设置y轴标签
+    
+    if log:
+        plt.yscale('log')
+
+    if groupby is not None:
+        plt.legend(loc='upper right', bbox_to_anchor=(1, 1))
+    
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+
+
+def _qc_boxplot_clone(clone_df, clone_spatial_df, Cgene_key, group_by, figsize=(6, 3) ):
+    fig, axes = plt.subplots(1, 2, figsize=figsize) 
+    _boxplot(df=clone_df, x=Cgene_key, y='clone_by_group', palette='Set2', xlabel=None, ylabel='clone_by_group', log=False, ax=axes[0] ) 
+    _boxplot(df=clone_spatial_df, x=group_by, y='clone_by_group_spatialLoc', groupby=Cgene_key, palette='Set2', xlabel=None, ylabel='clone_by_group_spatialLoc', log=True, ax=axes[1]) 
+    plt.tight_layout() 
+    plt.show() 
+
+def _qc_boxplot_umis(umis_df, umis_spatial_df, Cgene_key, group_by, figsize=(6, 3) ):
+    fig, axes = plt.subplots(1, 2, figsize=figsize) 
+    _boxplot(df=umis_df, x=Cgene_key, y='umis_by_group', palette='Set2', xlabel=None, ylabel='umis_by_group', log=True, ax=axes[0] ) 
+    _boxplot(df=umis_spatial_df, x=group_by, y='umis_by_group_spatialLoc', groupby=Cgene_key, palette='Set2', xlabel=None, ylabel='umis_by_group_spatialLoc', log=True, ax=axes[1]) 
+    plt.tight_layout() 
+    plt.show() 
+
+
+def _scatter_plot(df, x, y, groupby=None, palette='Set2', xlabel=None, ylabel=None, x_log=False, y_log=False, ax=None ): 
+
+    sns.scatterplot( data=df, x=x, y=y, hue=groupby, palette=palette, edgecolor='black', ax=ax ) 
+    
+    if ax:
+        ax.set_xlabel(xlabel)  # 设置x轴标签
+    if ax:
+        ax.set_ylabel(ylabel)  # 设置y轴标签
+    
+    if x_log:
+        plt.xscale('log')
+    if y_log:
+        plt.yscale('log')
+    if groupby is not None:
+        plt.legend(loc='upper right', bbox_to_anchor=(1, 1))
+
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+
+
+def _plot_xcr(xcr_df, clone_col, loc_x_key, loc_y_key ):
+    xcr_df = xcr_df.sort_values(clone_col)
+    xcr_df['clone_access'] = xcr_df[clone_col].astype('category').cat.codes 
+    clone = list(xcr_df['clone_access'])
+
+    x_min = xcr_df[loc_x_key].min(); x_max = xcr_df[loc_x_key].max()+1
+    y_min = xcr_df[loc_y_key].min(); y_max = xcr_df[loc_y_key].max()+1
+
+    x = list(xcr_df[loc_x_key]); y = list(xcr_df[loc_y_key])
+    xcr_mat = np.zeros(( x_max+1, y_max+1 ))
+    xcr_mat_c = np.zeros(( x_max+1, y_max+1 )) 
+    for i in range(len(x)):
+        xcr_mat[x[i],y[i]]+=1 
+        xcr_mat_c[x[i],y[i]] = clone[i]
+    xcr_row, xcr_col = np.where(xcr_mat )
+    xcr_size = xcr_mat[xcr_row, xcr_col] * 0.3 / np.percentile(xcr_mat[xcr_mat!=0].flatten(),0.9)
+    xcr_size = np.clip(xcr_size,0,1) * 3
+    xcr_color = xcr_mat_c[xcr_row, xcr_col]
+
+    fig, ax = plt.subplots(1,1, figsize=((y_max-y_min)*3/10000, (x_max-x_min)*3/10000 ))     
+    ax.scatter(xcr_col, xcr_row, s=xcr_size, c=xcr_color, marker='o',cmap='coolwarm')
+    ax.invert_yaxis()
+    plt.show()
+
+
+
+

baits-0.1/BAITS/VDJ/tl/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,4 @@
+from .summarize_BCR import stat_clone, compute_grouped_index, aggregate_clone_df
+from .bcr_cluster import build_bcr_family
+from .qc import calculate_qc_clones, calculate_qc_umis, filter_clones, filter_clones_spatial, filter_umi, filter_umi_spatial
+

baits-0.1/BAITS/VDJ/tl/.ipynb_checkpoints/bcr_cluster-checkpoint.py

@@ -0,0 +1,69 @@
+import numpy as np
+import pandas as pd
+from scipy.cluster.hierarchy import linkage, fcluster
+from scipy.spatial.distance import squareform
+from Levenshtein import distance as levenshtein_distance
+from itertools import combinations
+from collections import defaultdict
+
+def _cluster_cdr3nt(cdr3_sequences, threshold=0.85):
+    # Calculate pairwise distances
+    n = len(cdr3_sequences)
+    dist_matrix = np.zeros((n, n))
+    
+    for i, j in combinations(range(n), 2):
+        dist_matrix[i, j] = levenshtein_distance(cdr3_sequences[i], cdr3_sequences[j])
+        dist_matrix[j, i] = dist_matrix[i, j]
+    
+    condensed_dist = squareform(dist_matrix)
+    Z = linkage(condensed_dist, method='average')
+    max_dist = max(len(seq) for seq in cdr3_sequences) * (1 - threshold)
+    clusters = fcluster(Z, max_dist, criterion='distance')
+    
+    return {seq: cluster for seq, cluster in zip(cdr3_sequences, clusters)}
+
+
+def _build_bcr_family(bcr_data, cdr3nt_col, threshold=0.85):
+    
+    tmp_dd_ss = bcr_data.drop_duplicates(subset=[cdr3nt_col])
+    
+    if tmp_dd_ss.empty:
+        return None
+    
+    comp_cdr3_nt = tmp_dd_ss[cdr3nt_col].tolist()
+
+    if len(comp_cdr3_nt)==1:
+        return  {comp_cdr3_nt[0]: 0 }
+    
+    family_groups = _cluster_cdr3nt(comp_cdr3_nt, threshold)
+    return family_groups
+    
+
+def build_bcr_family(bcr_data, Vgene_col, Jgene_col, cdr3nt_col, Cgene_key, Cgene='IGH', threshold=0.85):
+
+    data = bcr_data[[Vgene_col, Jgene_col, cdr3nt_col, Cgene_key]].copy()
+    
+    # Filter by c_gene
+    data = data[data['Cgene'].str.contains(Cgene)].copy()
+    
+    data = data.drop_duplicates(subset=[Vgene_col, Jgene_col, cdr3nt_col])
+    data['CDR3_length'] = (data[cdr3nt_col].str.len()/3).astype(int)
+    data['cloneGroup'] = data[Vgene_col] + "_" + data[Jgene_col] + "_" + data[cdr3nt_col].astype(str) 
+    data['family'] = ''
+    for group in set(data['cloneGroup']): 
+        tmp_data = data[data['cloneGroup'] == group].copy()
+        result = _build_bcr_family(tmp_data, cdr3nt_col, threshold=0.85)
+
+        if not result:
+            continue
+
+        for seq, family_num_idx in result.items():
+            family_name = group + '_family_' + str(family_num_idx) 
+            mask = (data['cloneGroup'] == group) & (data[cdr3nt_col]==(seq) )  
+            data.loc[mask, 'family'] = family_name
+            
+    data['family_id'] = [ Cgene + '_family_' +x for x in pd.Categorical(data['family']).codes.astype(str)]
+    bcr_data = pd.merge(bcr_data, data, on = [Vgene_col, Jgene_col, Cgene_key, cdr3nt_col], how='left')
+    
+    return bcr_data
+    

baits-0.1/BAITS/VDJ/tl/.ipynb_checkpoints/qc-checkpoint.py

@@ -0,0 +1,44 @@
+import numpy as np 
+import pandas as pd
+import seaborn as sns
+from pl.basic_plot import _qc_boxplot_clone, _qc_boxplot_umis
+
+def calculate_qc_clones(df, group_by, Cgene_key, clone_key,loc_x_key='X', loc_y_key='Y', plot=True): 
+    clone_df = df[[group_by, Cgene_key, clone_key ]].drop_duplicates().groupby([group_by, Cgene_key ]).size().reset_index(name='clone_by_group')  
+    clone_spatial_df = df[[group_by, Cgene_key, clone_key, loc_x_key, loc_y_key]].drop_duplicates().groupby([group_by, Cgene_key, loc_x_key, loc_y_key]).size().reset_index(name='clone_by_group_spatialLoc') 
+    
+    if plot:
+        _qc_boxplot_clone( clone_df, clone_spatial_df, Cgene_key, group_by, figsize=(7, 3.5) )
+    cloneDict = clone_df.set_index([group_by, Cgene_key])['clone_by_group'].to_dict()
+    clonesSpatialDict = clone_spatial_df.set_index([group_by, Cgene_key, loc_x_key, loc_y_key])['clone_by_group_spatialLoc'].to_dict()
+    df['clone_by_group'] = df.apply(lambda row: cloneDict.get((row[group_by], row[Cgene_key]), None), axis=1) 
+    df['clone_by_group_spatialLoc'] = df.apply(lambda row: clonesSpatialDict.get((row[group_by], row[Cgene_key], row[loc_x_key], row[loc_y_key]), None), axis=1) 
+    return df
+
+
+def calculate_qc_umis(df, group_by, Cgene_key, clone_key, loc_x_key='X', loc_y_key='Y', plot=True, figsize=(7, 3.5)): 
+    umis_df = df[[group_by, Cgene_key, clone_key ]].groupby([group_by, Cgene_key ]).size().reset_index(name='umis_by_group')  
+    umis_spatial_df = df[[group_by, Cgene_key, clone_key, loc_x_key, loc_y_key]].groupby([group_by, Cgene_key, loc_x_key, loc_y_key]).size().reset_index(name='umis_by_group_spatialLoc') 
+
+    if plot:
+        _qc_boxplot_umis( umis_df, umis_spatial_df, Cgene_key, group_by, figsize=(7, 3.5) )
+    umisDict = umis_df.set_index([group_by, Cgene_key])['umis_by_group'].to_dict()
+    umisSpatialDict = umis_spatial_df.set_index([group_by, Cgene_key, loc_x_key, loc_y_key])['umis_by_group_spatialLoc'].to_dict()
+    df['umis_by_group'] = df.apply(lambda row: umisDict.get((row[group_by], row[Cgene_key]), None), axis=1) 
+    df['umis_by_group_spatialLoc'] = df.apply(lambda row: umisSpatialDict.get((row[group_by], row[Cgene_key], row[loc_x_key], row[loc_y_key]), None), axis=1) 
+    return df
+
+
+def filter_clones(df, clone_key, min_clone=1): 
+    return df[df[clone_key] > min_clone]
+
+def filter_clones_spatial(df, clone_spatial_key, min_clone_spatial=1): 
+    return df[df[clone_spatial_key] > min_clone_spatial]
+
+def filter_umi(df, umi_key, min_umi=1): 
+    return df[df[umi_key] > min_umi]
+
+def filter_umi_spatial(df, clone_umi_key, min_umi_spatial=1): 
+    return df[df[clone_umi_key] > min_umi_spatial]
+
+

baits-0.1/BAITS/VDJ/tl/.ipynb_checkpoints/summarize_BCR-checkpoint.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent))
+from pl.basic_plot import _plot_bar
+
+from .bcr_desc import compute_index 
+
+def stat_clone(df, groupby, Cgene_key, clone_key, plot=True, palette='Set2', xlabel=None, ylabel=None, ylog=False, figsize=(4,3.5) ):
+    y_name = 'clone_by_'+groupby
+    clone_df = df[[groupby, Cgene_key, clone_key]].drop_duplicates().groupby([groupby, Cgene_key]).size().reset_index(name = y_name)
+    
+    if plot:
+        _plot_bar(clone_df, Cgene_key, y_name, groupby=Cgene_key, palette='Set2', xlabel=None, ylabel=None, ylog=False, figsize=(4,3.5) ) 
+
+    cloneDict = clone_df.set_index([groupby, Cgene_key])['clone_by_'+groupby].to_dict() 
+    df[y_name] = df.apply(lambda row: cloneDict.get((row[groupby], row[Cgene_key]), None), axis=1) 
+
+    return df
+
+
+def aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis='location', loc_x_key='X', loc_y_key='Y', Umi_key='UMI'):
+    if count_basis == 'location':
+        lst = list(set([group_by, Cgene_key, clone_key, loc_x_key, loc_y_key] + groups))
+        loc_df = df[lst].drop_duplicates() 
+        _Index_compute_count = loc_df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts().reset_index(name='count') 
+        _Index_compute_freq = loc_df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts(normalize=True).reset_index(name='freq') 
+        _Index_compute = pd.merge(_Index_compute_freq, _Index_compute_count, on = groups+[clone_key] ) 
+        return _Index_compute
+        
+    if count_basis == 'UMI': 
+        _Index_compute_count = df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts().reset_index(name='count') 
+        _Index_compute_freq = df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts(normalize=True).reset_index(name='freq') 
+        _Index_compute = pd.merge(_Index_compute_freq, _Index_compute_count, on = groups+[clone_key] ) 
+        return _Index_compute
+
+
+def compute_grouped_index(df, group_by, Cgene_key, clone_key, groups, count_basis='location', loc_x_key='X', loc_y_key='Y', Umi_key=None, index='shannon_entropy'):
+    if count_basis=='location':
+        _Index_compute = aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis=count_basis, loc_x_key='X', loc_y_key='Y').copy()
+    if count_basis=='UMI':
+        _Index_compute = aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis=count_basis, Umi_key=Umi_key).copy()
+
+    tmp_df = _Index_compute.groupby(groups)['freq'].apply(lambda x: compute_index(index, x))
+    
+    if index != 'renyi_entropy':
+        tmp_df = tmp_df.reset_index(name=index).dropna(subset=[index])
+    else: 
+        tmp_df = tmp_df.melt(ignore_index=False, var_name='alpha', value_name = index).reset_index() 
+        cols = list(range(0, len(groups))) + list(range(len(groups)+1, len(tmp_df.columns))) 
+        tmp_df = tmp_df.iloc[:, cols ]
+    
+    return tmp_df
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

baits-0.1/BAITS/VDJ/tl/__init__.py

@@ -0,0 +1,4 @@
+from .summarize_BCR import stat_clone, compute_grouped_index, aggregate_clone_df
+from .bcr_cluster import build_bcr_family
+from .qc import calculate_qc_clones, calculate_qc_umis, filter_clones, filter_clones_spatial, filter_umi, filter_umi_spatial
+

baits-0.1/BAITS/VDJ/tl/bcr_cluster.py

@@ -0,0 +1,69 @@
+import numpy as np
+import pandas as pd
+from scipy.cluster.hierarchy import linkage, fcluster
+from scipy.spatial.distance import squareform
+from Levenshtein import distance as levenshtein_distance
+from itertools import combinations
+from collections import defaultdict
+
+def _cluster_cdr3nt(cdr3_sequences, threshold=0.85):
+    # Calculate pairwise distances
+    n = len(cdr3_sequences)
+    dist_matrix = np.zeros((n, n))
+    
+    for i, j in combinations(range(n), 2):
+        dist_matrix[i, j] = levenshtein_distance(cdr3_sequences[i], cdr3_sequences[j])
+        dist_matrix[j, i] = dist_matrix[i, j]
+    
+    condensed_dist = squareform(dist_matrix)
+    Z = linkage(condensed_dist, method='average')
+    max_dist = max(len(seq) for seq in cdr3_sequences) * (1 - threshold)
+    clusters = fcluster(Z, max_dist, criterion='distance')
+    
+    return {seq: cluster for seq, cluster in zip(cdr3_sequences, clusters)}
+
+
+def _build_bcr_family(bcr_data, cdr3nt_col, threshold=0.85):
+    
+    tmp_dd_ss = bcr_data.drop_duplicates(subset=[cdr3nt_col])
+    
+    if tmp_dd_ss.empty:
+        return None
+    
+    comp_cdr3_nt = tmp_dd_ss[cdr3nt_col].tolist()
+
+    if len(comp_cdr3_nt)==1:
+        return  {comp_cdr3_nt[0]: 0 }
+    
+    family_groups = _cluster_cdr3nt(comp_cdr3_nt, threshold)
+    return family_groups
+    
+
+def build_bcr_family(bcr_data, Vgene_col, Jgene_col, cdr3nt_col, Cgene_key, Cgene='IGH', threshold=0.85):
+
+    data = bcr_data[[Vgene_col, Jgene_col, cdr3nt_col, Cgene_key]].copy()
+    
+    # Filter by c_gene
+    data = data[data['Cgene'].str.contains(Cgene)].copy()
+    
+    data = data.drop_duplicates(subset=[Vgene_col, Jgene_col, cdr3nt_col])
+    data['CDR3_length'] = (data[cdr3nt_col].str.len()/3).astype(int)
+    data['cloneGroup'] = data[Vgene_col] + "_" + data[Jgene_col] + "_" + data[cdr3nt_col].astype(str) 
+    data['family'] = ''
+    for group in set(data['cloneGroup']): 
+        tmp_data = data[data['cloneGroup'] == group].copy()
+        result = _build_bcr_family(tmp_data, cdr3nt_col, threshold=0.85)
+
+        if not result:
+            continue
+
+        for seq, family_num_idx in result.items():
+            family_name = group + '_family_' + str(family_num_idx) 
+            mask = (data['cloneGroup'] == group) & (data[cdr3nt_col]==(seq) )  
+            data.loc[mask, 'family'] = family_name
+            
+    data['family_id'] = [ Cgene + '_family_' +x for x in pd.Categorical(data['family']).codes.astype(str)]
+    bcr_data = pd.merge(bcr_data, data, on = [Vgene_col, Jgene_col, Cgene_key, cdr3nt_col], how='left')
+    
+    return bcr_data
+    

baits-0.1/BAITS/VDJ/tl/bcr_desc.py

@@ -0,0 +1,72 @@
+import numpy as np
+import pandas as pd
+
+def renyi_entropy(probabilities, alpha_values=range(10)):
+    """
+    Calculate the Rényi entropy for a given probability distribution and alpha.
+    
+    Parameters:
+    probabilities (list or numpy array): Probability distribution (should sum to 1).
+    alpha (float): The order of the Rényi entropy.
+    
+    Returns:
+    float: The calculated Rényi entropy.
+    """
+    results = {}
+    for alpha in alpha_values:
+        if alpha == 1:
+            entropy = -np.sum(probabilities * np.log(probabilities))
+        else:
+            entropy = 1 / (1 - alpha) * np.log(np.sum(probabilities**alpha))
+        results[alpha] = [entropy]
+    return pd.DataFrame.from_dict(results)
+
+
+def shannon_entropy(p): 
+    p = p[p > 0]  # Only consider non-zero probabilities
+    H = -np.sum(p * np.log2(p))
+    return H
+
+
+def CPK(count): 
+    return len(count)/sum(count) * 1000
+
+    
+def normalize_shannon_entropy(p): 
+    p = p[p > 0]  # Only consider non-zero probabilities
+    H = -np.sum(p * np.log2(p)) / np.log2(len(p))
+    return H
+
+def gini_index(data): 
+    if len(data) == 0:
+        raise ValueError("Input data cannot be empty.")
+    sorted_data = np.sort(data)
+    n = len(data)
+    cumulative_sum = np.cumsum(sorted_data)
+    gini_index = (n + 1 - 2 * np.sum(cumulative_sum) / np.sum(sorted_data)) / n
+    return gini_index
+
+def Clonality(p):
+    C = 1 - shannon_entropy(p) / np.log2(len(p))
+    return C
+
+def compute_index(function_name, p):
+    # 使用 globals() 来根据输入的函数名称调用对应的函数 
+    functions = {
+        'shannon_entropy': shannon_entropy,
+        'normalize_shannon_entropy': normalize_shannon_entropy,
+        'Clonality': Clonality, 
+        'renyi_entropy': renyi_entropy,
+        'gini_index': gini_index,
+        'CPK':CPK
+    }
+    
+    # 检查用户输入的函数是否在已定义的函数字典中
+    if function_name in functions:
+        if function_name=='renyi_entropy':
+            return functions[function_name](p)
+        else:
+            return functions[function_name](p)
+    else:
+        raise ValueError(f"Function '{function_name}' not recognized.")
+        

baits-0.1/BAITS/VDJ/tl/qc.py

@@ -0,0 +1,44 @@
+import numpy as np 
+import pandas as pd
+import seaborn as sns
+from pl.basic_plot import _qc_boxplot_clone, _qc_boxplot_umis
+
+def calculate_qc_clones(df, group_by, Cgene_key, clone_key,loc_x_key='X', loc_y_key='Y', plot=True): 
+    clone_df = df[[group_by, Cgene_key, clone_key ]].drop_duplicates().groupby([group_by, Cgene_key ]).size().reset_index(name='clone_by_group')  
+    clone_spatial_df = df[[group_by, Cgene_key, clone_key, loc_x_key, loc_y_key]].drop_duplicates().groupby([group_by, Cgene_key, loc_x_key, loc_y_key]).size().reset_index(name='clone_by_group_spatialLoc') 
+    
+    if plot:
+        _qc_boxplot_clone( clone_df, clone_spatial_df, Cgene_key, group_by, figsize=(7, 3.5) )
+    cloneDict = clone_df.set_index([group_by, Cgene_key])['clone_by_group'].to_dict()
+    clonesSpatialDict = clone_spatial_df.set_index([group_by, Cgene_key, loc_x_key, loc_y_key])['clone_by_group_spatialLoc'].to_dict()
+    df['clone_by_group'] = df.apply(lambda row: cloneDict.get((row[group_by], row[Cgene_key]), None), axis=1) 
+    df['clone_by_group_spatialLoc'] = df.apply(lambda row: clonesSpatialDict.get((row[group_by], row[Cgene_key], row[loc_x_key], row[loc_y_key]), None), axis=1) 
+    return df
+
+
+def calculate_qc_umis(df, group_by, Cgene_key, clone_key, loc_x_key='X', loc_y_key='Y', plot=True, figsize=(7, 3.5)): 
+    umis_df = df[[group_by, Cgene_key, clone_key ]].groupby([group_by, Cgene_key ]).size().reset_index(name='umis_by_group')  
+    umis_spatial_df = df[[group_by, Cgene_key, clone_key, loc_x_key, loc_y_key]].groupby([group_by, Cgene_key, loc_x_key, loc_y_key]).size().reset_index(name='umis_by_group_spatialLoc') 
+
+    if plot:
+        _qc_boxplot_umis( umis_df, umis_spatial_df, Cgene_key, group_by, figsize=(7, 3.5) )
+    umisDict = umis_df.set_index([group_by, Cgene_key])['umis_by_group'].to_dict()
+    umisSpatialDict = umis_spatial_df.set_index([group_by, Cgene_key, loc_x_key, loc_y_key])['umis_by_group_spatialLoc'].to_dict()
+    df['umis_by_group'] = df.apply(lambda row: umisDict.get((row[group_by], row[Cgene_key]), None), axis=1) 
+    df['umis_by_group_spatialLoc'] = df.apply(lambda row: umisSpatialDict.get((row[group_by], row[Cgene_key], row[loc_x_key], row[loc_y_key]), None), axis=1) 
+    return df
+
+
+def filter_clones(df, clone_key, min_clone=1): 
+    return df[df[clone_key] > min_clone]
+
+def filter_clones_spatial(df, clone_spatial_key, min_clone_spatial=1): 
+    return df[df[clone_spatial_key] > min_clone_spatial]
+
+def filter_umi(df, umi_key, min_umi=1): 
+    return df[df[umi_key] > min_umi]
+
+def filter_umi_spatial(df, clone_umi_key, min_umi_spatial=1): 
+    return df[df[clone_umi_key] > min_umi_spatial]
+
+

baits-0.1/BAITS/VDJ/tl/summarize_BCR.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent))
+from pl.basic_plot import _plot_bar
+
+from .bcr_desc import compute_index 
+
+def stat_clone(df, groupby, Cgene_key, clone_key, plot=True, palette='Set2', xlabel=None, ylabel=None, ylog=False, figsize=(4,3.5) ):
+    y_name = 'clone_by_'+groupby
+    clone_df = df[[groupby, Cgene_key, clone_key]].drop_duplicates().groupby([groupby, Cgene_key]).size().reset_index(name = y_name)
+    
+    if plot:
+        _plot_bar(clone_df, Cgene_key, y_name, groupby=Cgene_key, palette='Set2', xlabel=None, ylabel=None, ylog=False, figsize=(4,3.5) ) 
+
+    cloneDict = clone_df.set_index([groupby, Cgene_key])['clone_by_'+groupby].to_dict() 
+    df[y_name] = df.apply(lambda row: cloneDict.get((row[groupby], row[Cgene_key]), None), axis=1) 
+
+    return df
+
+
+def aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis='location', loc_x_key='X', loc_y_key='Y', Umi_key='UMI'):
+    if count_basis == 'location':
+        lst = list(set([group_by, Cgene_key, clone_key, loc_x_key, loc_y_key] + groups))
+        loc_df = df[lst].drop_duplicates() 
+        _Index_compute_count = loc_df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts().reset_index(name='count') 
+        _Index_compute_freq = loc_df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts(normalize=True).reset_index(name='freq') 
+        _Index_compute = pd.merge(_Index_compute_freq, _Index_compute_count, on = groups+[clone_key] ) 
+        return _Index_compute
+        
+    if count_basis == 'UMI': 
+        _Index_compute_count = df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts().reset_index(name='count') 
+        _Index_compute_freq = df[ groups+[clone_key] ].groupby(groups)[clone_key].value_counts(normalize=True).reset_index(name='freq') 
+        _Index_compute = pd.merge(_Index_compute_freq, _Index_compute_count, on = groups+[clone_key] ) 
+        return _Index_compute
+
+
+def compute_grouped_index(df, group_by, Cgene_key, clone_key, groups, count_basis='location', loc_x_key='X', loc_y_key='Y', Umi_key=None, index='shannon_entropy'):
+    if count_basis=='location':
+        _Index_compute = aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis=count_basis, loc_x_key='X', loc_y_key='Y').copy()
+    if count_basis=='UMI':
+        _Index_compute = aggregate_clone_df(df, group_by, Cgene_key, clone_key, groups, count_basis=count_basis, Umi_key=Umi_key).copy()
+
+    tmp_df = _Index_compute.groupby(groups)['freq'].apply(lambda x: compute_index(index, x))
+    
+    if index != 'renyi_entropy':
+        tmp_df = tmp_df.reset_index(name=index).dropna(subset=[index])
+    else: 
+        tmp_df = tmp_df.melt(ignore_index=False, var_name='alpha', value_name = index).reset_index() 
+        cols = list(range(0, len(groups))) + list(range(len(groups)+1, len(tmp_df.columns))) 
+        tmp_df = tmp_df.iloc[:, cols ]
+    
+    return tmp_df
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

baits-0.1/BAITS/__init__.py

@@ -0,0 +1,3 @@
+from . import st, VDJ
+
+__all__ = ["st", "VDJ"]

baits-0.1/BAITS/st/__init__.py

@@ -0,0 +1,3 @@
+from . import tl, pl, gr
+
+__all__ = ["tl", "pl", "gr"]

baits-0.1/BAITS/st/gr/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,4 @@
+from ._aggr import aggregate_neighbors
+from ._get_adj import get_adj
+from ._build_spatial_adj import spatial_neighbors
+from ._utils import _save_data