oscb 0.1.0__py3-none-any.whl

oscb/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import absolute_import
+
+from .evaluation import annotation, ccc, clustering, imputation, integration, multimodal, trajectory, annotation
+from .data import *
+from .evaluator import *
+from .utilization import *
+from .utils import *
+# from .evaluation import ccc
+# from .evaluation import clustering
+# from .evaluation import imputation
+# from .evaluation import integration
+# from .evaluation import multimodal
+# from .evaluation import trajectory
+# from .evaluation import annotation

oscb/data.py

@@ -0,0 +1,135 @@
+import requests
+from tqdm import tqdm
+import os
+from pathlib import Path
+import hashlib
+import re
+from muon import MuData
+import muon as mu
+import numpy as np
+import pandas as pd
+import scanpy as sc
+import anndata as ad
+import mudata as md
+from .utils import *
+
+
+
+class FileDownloader:
+    def __init__(self, chunk_size=8192):
+        self.chunk_size = chunk_size
+        self.session = requests.Session()
+
+    def get_filename_from_response(self, headers):
+        """
+        Extracts filename from Content-Disposition header or URL.
+        """
+        print(headers)
+        if "content-disposition" in headers:
+            cd = headers["content-disposition"]
+            match = re.search(r"filename\*?=['\"]?(.*?)['\"]?(?:;|$)", cd)
+            if match:
+                filename = match.group(1)
+                # Handle potential encoding if filename* is used
+                if filename.startswith("utf-8''"):
+                    filename = filename.split("''", 1)[1]
+                    filename = requests.utils.unquote(filename)
+                return filename
+        return None
+        
+    def get_file_size(self, response):
+        # response = self.session.head(url)
+        return int(response.headers.get('content-length', 0))
+    
+    def get_file_hash(self, file_path):
+        sha256_hash = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        return sha256_hash.hexdigest()
+    
+    def download(self, url, data_dict, data_folder='downloads/', verify_hash=None):
+        try:
+            response = self.session.post(url, json=data_dict, stream=True)
+            response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+            total_size = self.get_file_size(response)
+            file_name = self.get_filename_from_response(response.headers)
+            local_file_path = os.path.join(data_folder, file_name)
+            local_file_path = Path(local_file_path)
+            # Make dir
+            local_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Progress bar
+            progress = tqdm(total=total_size,
+                           unit='B',
+                           unit_scale=True,
+                           desc=local_file_path.name)
+            
+            with local_file_path.open('wb') as f:
+                for chunk in response.iter_content(chunk_size=self.chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        progress.update(len(chunk))
+            progress.close()
+            
+            # File validation
+            if verify_hash:
+                downloaded_hash = self.get_file_hash(local_file_path)
+                if downloaded_hash != verify_hash:
+                    raise ValueError("File hash verification failed.")
+                    
+            print(f"File downloaded successfully to: {local_file_path}")
+            
+            return local_file_path
+            
+        except Exception as e:
+            progress.close()
+            print(f"Download failed: {str(e)}")
+            if local_file_path.exists():
+                local_file_path.unlink()
+            return None
+
+    def download_multiple(self, url_list, data_folder):
+        results = []
+        for url in url_list:
+            filename = url.split('/')[-1]
+            local_file_path = Path(data_folder) / filename
+            success = self.download(url, local_file_path)
+            results.append({
+                'url': url,
+                'success': success,
+                'local_file_path': str(local_file_path)
+            })
+        return results
+
+
+
+def DataLoader(benchmarks_id, data_folder='downloads/', server_endpoint=server_endpoint+'download'):  
+    dataset_id, task = get_dataset_id(benchmarks_id)
+    if task is not None:
+        print(f"Downloading dataset for {task} Benchmarks.")
+    else:
+        print("Downloading dataset.")
+    data_dict = {
+        "dataset_id": dataset_id
+    }
+
+    downloader = FileDownloader()
+    adata_path = downloader.download(server_endpoint, data_dict, data_folder="downloads")
+
+    if os.path.isfile(adata_path):
+        if str(adata_path).endswith(".h5mu"):
+            mdata = muon.read_h5mu(adata_path)
+            return mdata
+        else:
+            adata = sc.read_h5ad(adata_path)
+            return adata
+    else:
+        return None
+
+
+def split_data(adata):
+    train_adata = adata[adata.obs.split_idx.str.contains('train'), :].copy()
+    test_adata = adata[adata.obs.split_idx.str.contains('test'), :].copy()
+
+    return train_adata, test_adata

oscb/evaluation/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+
+from .annotation import *
+from .ccc import *
+from .clustering import *
+from .imputation import *
+from .integration import *
+from .multimodal import *
+from .trajectory import *
+from .annotation import *

oscb/evaluation/annotation.py

@@ -0,0 +1,39 @@
+import numpy as np
+import sklearn.preprocessing
+from sklearn.metrics import f1_score, accuracy_score
+
+
+def annotation_metrics(labels, labels_pred):
+    print("Encode labels", flush=True)
+    labels = labels.astype('category')
+    labels_pred = labels_pred.astype('category')
+    if labels.isna().any():
+        labels = labels.cat.add_categories(['Unkown'])
+        labels = labels.fillna('Unkown')
+    if labels_pred.isna().any():
+        labels_pred = labels_pred.cat.add_categories(['Unkown'])
+        labels_pred = labels_pred.fillna('Unkown')
+    cats = list(labels.dtype.categories) + list(labels_pred.dtype.categories)
+    encoder = sklearn.preprocessing.LabelEncoder().fit(cats)
+    labels = encoder.transform(labels)
+    labels_pred = encoder.transform(labels_pred)
+
+    print("Compute prediction accuracy", flush=True)
+    accuracy = accuracy_score(labels, labels_pred)
+    accuracy = float('{:.4f}'.format(accuracy))
+
+    print("Compute F1 score", flush=True)
+    f1_macro = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='macro'
+        )))
+    f1_micro = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='micro'
+        )))
+    f1_weighted = float('{:.4f}'.format(f1_score(
+            labels, labels_pred, 
+            average='weighted'
+        )))
+
+    return accuracy, f1_macro, f1_micro, f1_weighted

oscb/evaluation/ccc.py

@@ -0,0 +1,74 @@
+from typing import Union
+
+import anndata
+import collections
+import numpy as np
+from sklearn.metrics import auc
+from sklearn.metrics import precision_recall_curve
+
+# Cell Cell Communication
+def ccc_metrics(adata, ccc_pred="ccc_pred", ccc_target="ccc_target", score="score", top_prop=0.05):
+    # Precision-recall AUC
+    gt = join_truth_and_pred(adata, ccc_pred, ccc_target, score)
+    precision, recall, _ = precision_recall_curve(
+        gt["response"], gt[score], pos_label=1
+    )
+
+    auc_score = auc(recall, precision)
+
+    # Odds Ratio
+    gt = gt.sort_values(score, ascending=False)
+    top_n = int(adata.uns[ccc_target].shape[0] * top_prop)
+
+    # assign the top rank interactions to 1
+    a = np.zeros(len(gt[score]))
+    a[0:top_n] = 1
+    gt.loc[:, ["top_n"]] = a
+
+    top = gt[gt["top_n"] == 1]
+    tp = np.sum(top.response == 1)
+    fp = np.sum(top.response == 0)
+
+    bot = gt[gt["top_n"] == 0]
+    fn = np.sum(bot.response == 1)
+    tn = np.sum(bot.response == 0)
+
+    numerator = tp * tn
+    denominator = fp * fn
+    if denominator == 0:
+        if numerator == 0:
+            # undefined
+            oddsratio_score = np.nan
+        else:
+            # perfect score
+            oddsratio_score = np.inf
+    else:
+        oddsratio_score = numerator / denominator
+        oddsratio_score = _sigmoid_transform(oddsratio_score)
+
+    return float('{:.4f}'.format(auc_score)), float('{:.4f}'.format(oddsratio_score))
+
+
+# Join predictions to target
+def join_truth_and_pred(adata, ccc_pred="ccc_pred", ccc_target="ccc_target", score="lrscore"):
+    merge_keys = list(adata.uns["merge_keys"])
+    gt = adata.uns[ccc_target].merge(adata.uns[ccc_pred], on=merge_keys, how="left")
+
+    gt.loc[gt["response"].isna(), "response"] = 0
+    gt.loc[gt[score].isna(), score] = np.nanmin(gt[score]) - np.finfo(float).eps
+
+    return gt
+
+
+def _sigmoid_transform(x):
+    return 1 - 1 / (1 + x / 2)
+
+
+def aggregate_method_scores(adata, how, ccc_pred="LIANA", score="score"):
+    merge_keys = list(adata.uns["merge_keys"])
+    return (
+        adata.uns[ccc_pred]
+        .groupby(merge_keys)
+        .agg(score=(score, how))
+        .reset_index()
+    )

oscb/evaluation/clustering.py

@@ -0,0 +1,20 @@
+from sklearn.metrics import adjusted_rand_score as ARI
+from sklearn.metrics import normalized_mutual_info_score as NMI
+from sklearn.metrics import silhouette_score
+from sklearn.metrics import fowlkes_mallows_score as FM
+
+def clustering_metrics(labels, labels_pred, embedding):
+    asw_score = silhouette_score(embedding, labels)
+    nmi_score = NMI(labels, labels_pred)
+    ari_score = ARI(labels, labels_pred)
+    fm_score = FM(labels, labels_pred)
+    asw_score = float('{:.4f}'.format(asw_score))
+    nmi_score = float('{:.4f}'.format(nmi_score))
+    ari_score = float('{:.4f}'.format(ari_score))
+    fm_score = float('{:.4f}'.format(fm_score))
+
+    print(
+        "Clustering Scores:\nSilhouette: %.4f\nNMI: %.4f\nARI: %.4f\nFowlkes Mallows: %.4f"
+        % (asw_score, nmi_score, ari_score, fm_score)
+    )
+    return asw_score, nmi_score, ari_score, fm_score

oscb/evaluation/imputation.py

@@ -0,0 +1,161 @@
+from scipy import sparse
+import importlib
+import numbers
+import anndata
+import scanpy as sc
+import sklearn.metrics
+import numpy as np
+import pandas as pd
+import re
+import warnings
+
+
+# test_data = adata.obsm["test"]
+# denoised_data = adata.obsm["denoised"]
+# train_data = adata.obsm["train"]
+def imputation_metrics(adata, denoised_layer, train='train', test='test'):
+    #Mean-squared error
+    test_adata = anndata.AnnData(X=adata.obsm[test], obs=adata.obs, var=adata.var)
+    denoised_adata = anndata.AnnData(
+        X=adata.layers[denoised_layer], obs=adata.obs, var=adata.var
+    )
+
+    # scaling and transformation
+    target_sum = 10000
+
+    sc.pp.normalize_total(test_adata, target_sum)
+    sc.pp.log1p(test_adata)
+
+    sc.pp.normalize_total(denoised_adata, target_sum)
+    sc.pp.log1p(denoised_adata)
+
+    mse = sklearn.metrics.mean_squared_error(
+        toarray(test_adata.X), toarray(denoised_adata.X)
+    )
+
+    # Poisson loss
+    test_data = adata.obsm[test]
+    denoised_data = adata.layers[denoised_layer]
+
+    # scaling
+    initial_sum = adata.obsm[train].sum()
+    target_sum = test_data.sum()
+    denoised_data = denoised_data * target_sum / initial_sum
+
+    possion = poisson_nll_loss(toarray(test_data), toarray(denoised_data))
+
+    return float('{:.4f}'.format(mse)), float('{:.4f}'.format(possion))
+
+
+def poisson_nll_loss(y_pred: np.ndarray, y_true: np.ndarray) -> float:
+    return (y_pred - y_true * np.log(y_pred + 1e-6)).mean()
+
+
+def toarray(x):
+    """Convert an array-like to a np.ndarray.
+
+    Parameters
+    ----------
+    x : array-like
+        Array-like to be converted
+    Returns
+    -------
+    x : np.ndarray
+    """
+    if is_SparseDataFrame(x):
+        x = x.to_coo().toarray()
+    elif is_SparseSeries(x):
+        x = x.to_dense().to_numpy()
+    elif isinstance(x, (pd.DataFrame, pd.Series, pd.Index)):
+        x = x.to_numpy()
+    elif isinstance(x, sparse.spmatrix):
+        x = x.toarray()
+    elif isinstance(x, np.matrix):
+        x = x.A
+    elif isinstance(x, list):
+        x_out = []
+        for xi in x:
+            try:
+                xi = toarray(xi)
+            except TypeError:
+                # recursed too far
+                pass
+            x_out.append(xi)
+        # convert x_out from list to array
+        x = np.array(x_out, dtype=_check_numpy_dtype(x_out))
+    elif isinstance(x, (np.ndarray, numbers.Number)):
+        pass
+    else:
+        raise TypeError("Expected array-like. Got {}".format(type(x)))
+    return x
+
+
+def is_SparseSeries(X):
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            "The SparseSeries class is removed from pandas. Accessing it from the "
+            "top-level namespace will also be removed in the next version",
+            FutureWarning,
+        )
+        try:
+            return isinstance(X, pd.SparseSeries)
+        except AttributeError:
+            return False
+
+
+def is_SparseDataFrame(X):
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            "The SparseDataFrame class is removed from pandas. Accessing it from the "
+            "top-level namespace will also be removed in the next version",
+            FutureWarning,
+        )
+        try:
+            return isinstance(X, pd.SparseDataFrame)
+        except AttributeError:
+            return False
+
+
+def is_sparse_dataframe(x):
+    if isinstance(x, pd.DataFrame) and not is_SparseDataFrame(x):
+        try:
+            x.sparse
+            return True
+        except AttributeError:
+            pass
+    return False
+
+
+def is_sparse_series(x):
+    if isinstance(x, pd.Series) and not is_SparseSeries(x):
+        try:
+            x.sparse
+            return True
+        except AttributeError:
+            pass
+    return False
+
+
+def dataframe_to_sparse(x, fill_value=0.0):
+    x = pd.DataFrame.sparse.from_spmatrix(
+        sparse.coo_matrix(x.values), index=x.index, columns=x.columns
+    )
+    x.sparse.fill_value = fill_value
+    return x
+
+
+def SparseDataFrame(X, columns=None, index=None, default_fill_value=0.0):
+    if sparse.issparse(X):
+        X = pd.DataFrame.sparse.from_spmatrix(X)
+        X.sparse.fill_value = default_fill_value
+    else:
+        if is_SparseDataFrame(X) or not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X)
+        X = dataframe_to_sparse(X, fill_value=default_fill_value)
+    if columns is not None:
+        X.columns = columns
+    if index is not None:
+        X.index = index
+    return X

oscb/evaluation/integration.py

@@ -0,0 +1,60 @@
+from scib.metrics import metrics
+
+# https://github.com/theislab/scib/blob/main/scib/metrics/metrics.py
+# https://scib.readthedocs.io/en/latest/api/scib.metrics.metrics_all.html
+def integration_metrics(adata, adata_int, batch_key='batch', label_key='cell_type', species="mouse"):
+    """All metrics
+
+    :Biological conservation:
+        + HVG overlap :func:`~scib.metrics.hvg_overlap`
+        + Cell type ASW :func:`~scib.metrics.silhouette`
+        + Isolated label ASW :func:`~scib.metrics.isolated_labels`
+        + Isolated label F1 :func:`~scib.metrics.isolated_labels`
+        + NMI cluster/label :func:`~scib.metrics.nmi`
+        + ARI cluster/label :func:`~scib.metrics.ari`
+        + Cell cycle conservation :func:`~scib.metrics.cell_cycle`
+        + cLISI (cell type Local Inverse Simpson's Index) :func:`~scib.metrics.clisi_graph`
+        + Trajectory conservation :func:`~scib.metrics.trajectory_conservation`
+
+    :Batch correction:
+        + Graph connectivity :func:`~scib.metrics.graph_connectivity`
+        + Batch ASW :func:`~scib.metrics.silhouette_batch`
+        + Principal component regression :func:`~scib.metrics.pcr_comparison`
+        + kBET (k-nearest neighbour batch effect test) :func:`~scib.metrics.kBET`
+        + iLISI (integration Local Inverse Simpson's Index) :func:`~scib.metrics.ilisi_graph`
+
+    :param adata: unintegrated, preprocessed anndata object
+    :param adata_int: integrated anndata object
+    :param batch_key: name of batch column in adata.obs and adata_int.obs
+    :param label_key: name of biological label (cell type) column in adata.obs and adata_int.obs
+    :param kwargs:
+        Parameters to pass on to :func:`~scib.metrics.metrics` function:
+
+            + ``embed``
+            + ``cluster_key``
+            + ``cluster_nmi``
+            + ``nmi_method``
+            + ``nmi_dir``
+            + ``si_metric``
+            + ``organism``
+            + ``n_isolated``
+            + ``subsample``
+            + ``type_``
+    """
+
+    metrics_all = metrics(adata, adata_int, batch_key=batch_key, label_key=label_key, cluster_nmi=None, ari_=True, nmi_=True, nmi_method='arithmetic', nmi_dir=None, silhouette_=True, si_metric='euclidean', pcr_=True, cell_cycle_=True, organism=species, hvg_score_=True, isolated_labels_=True, isolated_labels_f1_=True, isolated_labels_asw_=True, n_isolated=True, graph_conn_=True, trajectory_=False, kBET_=True)
+    biological_conservation_metrics = ['NMI_cluster/label', 'ARI_cluster/label', 'ASW_label', 'cell_cycle_conservation','isolated_label_F1', 'isolated_label_silhouette', 'hvg_overlap']
+    # metrics_dict = metrics_all.dropna().to_dict()[0]
+    metrics_dict = metrics_all.fillna(0).to_dict()[0]
+
+    for key, value in metrics_dict.items():
+        metrics_dict[key] = float('{:.4f}'.format(value))
+
+    bc_total = 0
+    for key in biological_conservation_metrics:
+        bc_total += metrics_dict[key]
+    biological_conservation_score = float('{:.4f}'.format(bc_total/len(biological_conservation_metrics)))
+
+    metrics_dict['Biological Conservation'] = biological_conservation_score
+
+    return metrics_dict

oscb/evaluation/multimodal.py

@@ -0,0 +1,49 @@
+import numpy as np
+import pandas as pd 
+import os
+import subprocess
+import scanpy as sc
+import scipy.io
+import scib
+import muon as mu
+from muon import MuData
+
+
+def multimodal_metrics(mdata, embed, mod1='rna', batch='group', label_key='cell_type'):
+    scib_anndata = sc.AnnData(mdata.obsm[embed]).copy()
+    scib_anndata.obs = mdata.obs.copy()
+    scib_anndata.obsp["connectivities"] = mdata.obsp["connectivities"].copy()
+    scib_anndata.obsm[embed] = mdata.obsm[embed].copy()
+    scib_anndata = scib_anndata[~scib_anndata.obs[f"{mod1}:{batch}"].isna()] # Remove NaN in batch
+    scib_anndata = scib_anndata[~scib_anndata.obs[f"{mod1}:{label_key}"].isna()] # Remove NaN in cell type label
+    scib_anndata.obs[f"{mod1}:{batch}"] = scib_anndata.obs[f"{mod1}:{batch}"].astype("category")
+    scib_anndata.obs[f"{mod1}:{label_key}"] = scib_anndata.obs[f"{mod1}:{label_key}"].astype("category")
+    
+    metrics = scib.metrics.metrics(
+        scib_anndata,
+        scib_anndata,
+        batch_key=f"{mod1}:{batch}",
+        label_key=f"{mod1}:{label_key}",
+        embed=embed,
+        ari_=True,
+        nmi_=True,
+        silhouette_=True,
+        graph_conn_=True,
+        isolated_labels_asw_=True,
+    )
+
+    biological_conservation_metrics = ['NMI_cluster/label', 'ARI_cluster/label', 'ASW_label', 'cell_cycle_conservation','isolated_label_F1', 'isolated_label_silhouette', 'hvg_overlap']
+    metrics = metrics.fillna(0).to_dict()[0]
+
+    for key, value in metrics.items():
+        metrics[key] = float('{:.4f}'.format(value))
+
+    bc_total = 0
+    for key in biological_conservation_metrics:
+        bc_total += metrics[key]
+    biological_conservation_score = float('{:.4f}'.format(bc_total/len(biological_conservation_metrics)))
+
+    metrics['Biological Conservation'] = biological_conservation_score
+    scib_anndata = None
+
+    return metrics

oscb/evaluation/trajectory.py

@@ -0,0 +1,196 @@
+import random
+import numpy as np
+import networkx as nx
+import zss
+from math import inf
+from grakel import GraphKernel, Graph
+
+
+def trajectory_metrics(traj, bm_traj, root_node):
+    # Graph edit distance
+    traj_dict = traj_to_dict(traj)
+    bm_traj_dict = traj_to_dict(bm_traj)
+    traj_ls = []
+    for key in traj_dict.keys():
+        traj_ls.append((traj_dict[key], key)) 
+
+    bm_traj_ls = []
+    for key in bm_traj_dict.keys():
+        bm_traj_ls.append((bm_traj_dict[key], key))
+
+    traj_ls = sorted(traj_ls, key=lambda edge: (edge[0], edge[1]))
+    bm_traj_ls = sorted(bm_traj_ls, key=lambda edge: (edge[0], edge[1]))
+    
+    G1 = nx.DiGraph()
+    G1.add_edges_from(bm_traj_ls)
+
+    G2 = nx.DiGraph()
+    G2.add_edges_from(traj_ls)
+
+    # Calculate the graph edit distance
+    distance = graph_edit_distance(G1, G2)
+    
+    max_distance = 4*len(bm_traj_dict.keys()) + 2
+    
+    ged_score = (max_distance-distance)/max_distance
+
+
+    # Jaccard similarity coefficient
+    total_n = len(bm_traj_dict.keys()) + len(traj_dict.keys())
+
+    nn = 0
+    for key in bm_traj_dict.keys():
+        if key in traj_dict.keys():
+            if bm_traj_dict[key] == traj_dict[key]:
+                nn += 1
+
+    total_n = total_n - nn
+    jsc_score = nn/total_n
+
+
+    # Graph kernel score
+    traj_ls = sorted(traj_ls, key=lambda edge: (edge[0], edge[1]))
+    bm_traj_ls = sorted(bm_traj_ls, key=lambda edge: (edge[0], edge[1]))
+
+    gks_score = graph_kernel_score(bm_traj_ls, traj_ls, root_node=root_node)
+
+
+    # Tree edit distance
+    # Build trees from edge lists
+    bm_tree = build_tree_from_edges(bm_traj_ls, root_node)
+    tree = build_tree_from_edges(traj_ls, root_node)
+
+    # Calculate tree edit distance
+    tree_distance = zss.distance(
+        tree, bm_tree,
+        get_children=lambda node: node.children,
+        insert_cost=insert_cost,
+        remove_cost=remove_cost,
+        update_cost=update_cost
+    )
+    tree_max_distance = 2*len(bm_traj_dict.keys())-2
+    ted_score = (tree_max_distance-tree_distance)/tree_max_distance
+
+    mean = (ged_score + gks_score + jsc_score + ted_score)/4
+
+    return float('{:.4f}'.format(ged_score)), float('{:.4f}'.format(gks_score)), float('{:.4f}'.format(jsc_score)), float('{:.4f}'.format(ted_score)), float('{:.4f}'.format(mean))
+
+
+def traj_to_dict(df):
+    graph = {}
+    for i, row in df.iterrows():
+        graph[row['to']] = row['from']
+        
+    return graph
+
+
+
+class TreeNode:
+    def __init__(self, label):
+        self.label = label
+        self.children = []
+
+
+def build_tree_from_edges(edges, root_node):
+    nodes = {}
+    for parent, child in edges:
+        if parent not in nodes:
+            nodes[parent] = TreeNode(parent)
+        if child not in nodes:
+            nodes[child] = TreeNode(child)
+        nodes[parent].children.append(nodes[child])
+    return nodes[root_node]  # Return the root node
+
+
+def insert_cost(node):
+    return 1
+
+
+def remove_cost(node):
+    return 1
+
+
+def update_cost(node1, node2):
+    return 0 if node1.label == node2.label else inf
+
+
+def graph_edit_distance(G1, G2):
+    # Initialize cost for edges
+    node_cost = 0
+    nodes1 = set(G1.nodes)
+    nodes2 = set(G2.nodes)
+
+    # Calculate edge substitution cost
+    for node1 in nodes1:
+        if node1 in nodes2:
+            nodes2.remove(node1)  # Matched edges
+        else:
+            node_cost += 1  # Unmatched edge in G1 (deletion)
+
+    node_cost += len(nodes2)  # Remaining unmatched edges in G2 (insertion)
+
+    # Initialize cost for edges
+    edge_cost = 0
+    edges1 = set(G1.edges)
+    edges2 = set(G2.edges)
+
+    # Calculate edge substitution cost
+    for edge1 in edges1:
+        if edge1 in edges2:
+            edges2.remove(edge1)  # Matched edges
+        else:
+            edge_cost += 1  # Unmatched edge in G1 (deletion)
+
+    edge_cost += len(edges2)  # Remaining unmatched edges in G2 (insertion)
+
+    return node_cost + edge_cost
+
+
+def graph_kernel_score(edges1, edges2, root_node):
+    edges1 = find_root_node(edges1, root_node)
+    edges2 = find_root_node(edges2, root_node)
+
+    G1 = nx.Graph()
+    G1.add_edges_from(edges1)
+
+    G2 = nx.Graph()
+    G2.add_edges_from(edges2)
+    
+    grakel_G1 = nx_to_grakel(G1)
+    grakel_G2 = nx_to_grakel(G2)
+
+    # Initialize the Weisfeiler-Lehman subtree kernel
+    gk = GraphKernel(kernel={"name": "shortest_path"}, normalize=True)
+
+    # Compute the kernel matrix
+    G = [grakel_G1, grakel_G2]
+    K = gk.fit_transform(G)
+    
+    final_score = K[0,1]
+    
+    return final_score
+
+# Convert NetworkX graphs to Grakel format
+def nx_to_grakel(G):
+    nodes = list(G.nodes)
+    edges = list(G.edges)
+    node_labels = {node: i for i, node in enumerate(nodes)}
+    edges_transformed = [(node_labels[edge[0]], node_labels[edge[1]]) for edge in edges]
+    return (edges_transformed, {i: label for label, i in node_labels.items()})
+
+
+def find_root_node(edges1, root_node):
+    if edges1[0][0] == root_node:
+        pass
+
+    else:
+        for i in range(1, len(edges1)):
+            if edges1[i][0] == root_node:
+                aaa = edges1[0]
+                edges1[0] = edges1[i]
+                edges1[i] = aaa
+                i = len(edges1)+1
+            else:
+                pass
+            
+    return edges1

oscb/evaluator.py

@@ -0,0 +1,219 @@
+from .evaluation.annotation import *
+from .evaluation.ccc import *
+from .evaluation.clustering import *
+from .evaluation.imputation import *
+from .evaluation.integration import *
+from .evaluation.multimodal import *
+from .evaluation.trajectory import *
+from .evaluation.annotation import *
+from datetime import datetime
+from .utils import *
+import requests
+import json
+
+
+def eval(adata, adata_int=None, benchmarks_id=None, task=None, cluster_key=None, label_key=None, label_pred_key=None, embedding_key=None, ccc_pred="ccc_pred", ccc_target="ccc_target", score="score", denoised_layer=None, train='train', test='test', mod1_key='rna', mod2_key='atac', traj_key=None, bm_traj_key=None, root_node=None, species=None, server_endpoint=server_endpoint+'benchmarks/', method="Your method"):
+    if adata is None:
+        raise ValueError("adata is required.")
+    
+    benchmarks = None
+    current_date_and_time = datetime.now()
+    benchmarks_data = None
+
+    if benchmarks_id is not None:
+        dataset_id, task = get_dataset_id(benchmarks_id)
+        url = server_endpoint + benchmarks_id
+        response = requests.get(url)
+        if response.status_code == 200:
+            try:
+                benchmarks = response.json()
+                benchmarks_data = benchmarks['benchmarks_plot']['data']
+                match task:
+                    case "Clustering" | "CL":
+                        label_key = benchmarks['label']
+
+                    case "Imputation" | "IM":
+                        species = benchmarks['species']
+
+                    case "Batch Integration" | "BI":
+                        label_key = benchmarks['label']
+                        batch_key = benchmarks['batch_key']
+                        species = benchmarks['species']
+
+                    case "Trajectory" | "TJ":
+                        label_key = benchmarks['label']
+                        root_node = benchmarks['origin_group']
+                        bm_traj_key = benchmarks['bm_traj']
+
+                    case "Cell-Cell Communication" | "CCC":
+                        label_key = benchmarks['label']
+                        ccc_target = benchmarks['ccc_target']
+                        species = benchmarks['species']
+
+                    case "Multimodal Data Integration" | "MI":
+                        mod1_key = benchmarks['mod1']
+                        mod2_key = benchmarks['mod2']
+                        label_key = benchmarks['label']
+                        batch_key = benchmarks['batch_key']
+
+                    case "Cell Type Annotation" | "CT":
+                        label_key = benchmarks['label']
+                        # species = benchmarks['species']
+
+            except Exception as e:
+                print(f"Failed to get Benchmarks: {str(e)}")
+        else:
+            print(f"Failed to get Benchmarks: {benchmarks_id}.")
+
+    if task is not None:
+        task_info = {
+            "benchmarksId": benchmarks_id,
+            "datasetId": dataset_id,
+            "task_type": task,
+            "tool": method,
+            "created_on": current_date_and_time
+        }
+        match task:
+            case "Clustering" | "CL":
+                if cluster_key is not None and label_key is not None and embedding_key is not None:
+                    asw_score, nmi_score, ari_score, fm_score = clustering_metrics(adata.obs[label_key], adata.obs[cluster_key], adata.obsm[embedding_key])
+                    results = {
+                        "benchmarksId": benchmarks_id,
+                        "datasetId": dataset_id,
+                        "task_type": task,
+                        "tool": method,
+                        "Silhouette": asw_score,
+                        "NMI": nmi_score,
+                        "ARI": ari_score,
+                        "Fowlkes Mallows": fm_score,
+                        "created_on": current_date_and_time
+                    }
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+
+                    return results
+                else: 
+                    raise ValueError(f"cluster_key, label_key and embedding_key are required for {task}.")
+
+            case "Imputation" | "IM":
+                if denoised_layer is not None:
+                    mse, possion = imputation_metrics(adata, denoised_layer=denoised_layer)
+                    results = {
+                        "benchmarksId": benchmarks_id,
+                        "datasetId": dataset_id,
+                        "task_type": task,
+                        "tool": method,
+                        "MSE": mse,
+                        "Possion": possion,
+                        "created_on": current_date_and_time
+                    }
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"denoised_layer is required for {task}.")
+
+            case "Batch Integration" | "BI":
+                if adata_int is not None and label_key is not None and batch_key is not None:
+                    metrics_dict = integration_metrics(adata, adata_int, batch_key=batch_key, label_key=label_key, species=species)
+                    results = {**task_info, **metrics_dict}
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"adata_int, label_key and batch_key are required for {task}.")
+                    
+            case "Trajectory" | "TJ":
+                if traj_key is not None and bm_traj_key is not None and root_node is not None:
+                    ged_score, gks_score, jsc_score, ted_score, mean = trajectory_metrics(adata.uns[traj_key], adata.uns[bm_traj_key], adata.uns[root_node])
+                    results = {
+                        "benchmarksId": benchmarks_id,
+                        "datasetId": dataset_id,
+                        "task_type": task,
+                        "tool": method,
+                        "Graph Edit Distance": ged_score,
+                        "Graph Kernel Score": gks_score,
+                        "Jaccard Similarity Coefficient": jsc_score,
+                        "Tree Edit Distance": ted_score,
+                        "Mean": mean,
+                        "created_on": current_date_and_time
+                    }
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"adata_int, label_key and batch_key are required for {task}.")
+
+            case "Cell-Cell Communication" | "CCC":
+                if ccc_pred is not None and ccc_target is not None and score is not None:
+                    auc_score, oddsratio_score = ccc_metrics(adata, ccc_pred=ccc_pred, ccc_target=ccc_target, score='score')
+                    results = {
+                        "benchmarksId": benchmarks_id,
+                        "datasetId": dataset_id,
+                        "task_type": task,
+                        "tool": method,
+                        "Precision-recall AUC": auc_score,
+                        "Odds Ratio": oddsratio_score,
+                        "created_on": current_date_and_time
+                    }
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"ccc_pred, ccc_target and score are required for {task}.")
+
+            case "Multimodal Data Integration" | "MI":
+                if embedding_key is not None and mod1_key is not None and batch_key is not None and label_key is not None:
+                    metrics_dict = multimodal_metrics(mdata, embed=embedding_key, mod1=mod1_key, batch=batch_key, label_key=label_key)
+                    results = {**task_info, **metrics_dict}
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"embedding_key, mod1_key, label_key and batch_key are required for {task}.")
+
+            case "Cell Type Annotation" | "CT":
+                if label_pred_key is not None and label_key is not None:
+                    accuracy, f1_macro, f1_micro, f1_weighted = annotation_metrics(adata.obs[label_key], adata.obs[label_pred_key])
+                    results = {
+                        "benchmarksId": benchmarks_id,
+                        "datasetId": dataset_id,
+                        "task_type": task,
+                        "tool": method,
+                        "Accuracy": accuracy,
+                        "F1_macro": f1_macro,
+                        "F1_micro": f1_micro,
+                        "F1_weighted": f1_weighted,
+                        "created_on": current_date_and_time
+                    }
+                    if benchmarks_data is not None:
+                        labels, y_labels, data = get_bar_plot_data(benchmarks_data, user_results=results)
+                        plot_bars(task, labels, y_labels, data)
+                    return results
+                else: 
+                    raise ValueError(f"label_pred_key, and label_key are required for {task}.")
+
+            case _:  # Default case, equivalent to 'default' in other languages
+                raise ValueError(f"{task} is not supported. Please input the task name from the following list [Clustering, Imputation, Batch Integration, Trajectory, Cell-Cell Communication, Multimodal Data Integration, Cell Type Annotation].")
+    else:
+        raise ValueError("benchmarks_id or task is required.")
+
+
+def write_json(data, file_path="./output.json"):
+    # Open the file in write mode ('w') and use json.dump() to write the dictionary
+    with open(file_path, 'w') as json_file:
+        json.dump(data, json_file, indent=4, default=serialize_datetime) # indent=4 for pretty-printing
+
+    print(f"Dictionary successfully written to {file_path}")
+
+
+def serialize_datetime(obj):
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError("Type not serializable")

oscb/utilization.py

@@ -0,0 +1,133 @@
+
+# pip install nvidia-ml-py
+import os
+import time
+import psutil
+# import GPUtil
+from threading import Thread
+from pynvml import *
+from .utils import *
+
+
+
+class Monitor(Thread):
+    def __init__(self, delay=1):
+        super(Monitor, self).__init__()
+        self.stopped = False
+        self.delay = delay # Time between calls to GPUtil
+        self.time_points = []
+        self.cpu_usage = []
+        self.mem_usage = []
+        self.gpu_usage = []
+        self.gpu_mem_usage = []
+        self.start()
+
+
+    def run(self):
+        while not self.stopped:
+            # Obtaining all the essential details
+            self.time_points.append(time.time())
+            self.cpu_usage.append(psutil.cpu_percent())
+            self.mem_usage.append(psutil.virtual_memory().percent)
+            # self.gpu_mem_usage.append(self.gpu_mem_percent())
+            self.gpu_usage.append(self.get_nvidia_info()['gpus'][0]['gpu_utilization'])
+            self.gpu_mem_usage.append(self.get_nvidia_info()['gpus'][0]['memory_utilization'])
+            time.sleep(self.delay)
+        
+
+    def stop(self):
+        self.stopped = True
+        sys_info = self.get_sys_info()
+        results = {
+            "sys_info": sys_info,
+            "CPU": self.cpu_usage,
+            "Memory": self.mem_usage,
+            "GPU": self.gpu_usage,
+            "GPU Memory": self.gpu_mem_usage,
+            'time_points': self.time_points
+        }
+        plot_lines(results)
+
+        return results
+    
+
+    def get_sys_info(self) -> dict:
+        sys_info: dict = {}
+        cpu, ram = self.get_cpu_mem_info()
+        gpus = self.get_nvidia_info()
+        sys_info['CPU'] = cpu
+        sys_info['RAM'] = ram
+        if len(gpus['gpus']) > 0:
+            gpu_list = []
+            for i in range(len(gpus['gpus'])):
+                gpu = f"{gpus['gpus'][i]['gpu_model']} @ {gpus['gpus'][i]['total']} GB"
+                gpu_list.append(gpu)
+            
+            sys_info['GPU'] = gpu_list
+
+        return sys_info
+    
+
+    def get_cpu_mem_info(self):
+        import platform
+
+        n_cores = psutil.cpu_count(logical=False)
+        # n_thread = psutil.cpu_count()
+        freq = float('{:.2f}'.format(psutil.cpu_freq().current / 1000)) # GHz
+        cpu_model = platform.processor()
+        mem_total = round(psutil.virtual_memory().total / 1024 / 1024 / 1024, 2) # GB
+        # mem_free = round(psutil.virtual_memory().available / 1024 / 1024 / 1024, 2) # GB
+        # mem_process_used = round(psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024 / 1024, 2) # GB
+        cpu = f"{cpu_model} {n_cores}-core @ {freq} GHz"
+        ram = f"{mem_total} GB"
+
+        return cpu, ram
+    
+
+    def get_nvidia_info(self):
+        nvidia_dict = {
+            "state": True,
+            "nvidia_version": "",
+            "nvidia_count": 0,
+            "gpus": []
+        }
+        try:
+            nvmlInit()
+            nvidia_dict["nvidia_version"] = nvmlSystemGetDriverVersion()
+            nvidia_dict["nvidia_count"] = nvmlDeviceGetCount()
+            for i in range(nvidia_dict["nvidia_count"]):
+                handle = nvmlDeviceGetHandleByIndex(i)
+                memory_info = nvmlDeviceGetMemoryInfo(handle)
+                utilization = nvmlDeviceGetUtilizationRates(handle)
+                gpu = {
+                    "gpu_model": nvmlDeviceGetName(handle),
+                    "total": round(memory_info.total / 1024 / 1024 / 1024, 2), # GB
+                    "free": round(memory_info.free / 1024 / 1024 / 1024, 2), # GB
+                    "used": round(memory_info.used / 1024 / 1024 / 1024, 2), # GB
+                    "gpu_utilization": utilization.gpu, 
+                    "memory_utilization": round(memory_info.used * 100 / memory_info.total, 2), 
+                    "temperature": f"{nvmlDeviceGetTemperature(handle, 0)}℃",
+                    "powerStatus": nvmlDeviceGetPowerState(handle)
+                }
+                nvidia_dict['gpus'].append(gpu)
+        except NVMLError as _:
+            nvidia_dict["state"] = False
+        except Exception as _:
+            nvidia_dict["state"] = False
+        finally:
+            try:
+                nvmlShutdown()
+            except:
+                pass
+        return nvidia_dict
+
+
+    def gpu_mem_percent(self):
+        mem_rate = 0.0
+        info = self.get_nvidia_info()
+        if len(info['gpus']) > 0:
+            used = info['gpus'][0]['used']
+            tot = info['gpus'][0]['total']
+            mem_rate = used/tot
+
+        return mem_rate

oscb/utils.py

@@ -0,0 +1,107 @@
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+server_endpoint = "http://c4130-110233.wisc.cloudlab.us:5005/api/"
+
+
+def get_dataset_id(benchmarks_id):
+    task = None
+    dataset_id = None
+    if benchmarks_id.startswith("CL-"):
+        dataset_id = benchmarks_id.removeprefix("CL-")
+        task = "Clustering"
+        
+    elif benchmarks_id.startswith("IM-"):
+        dataset_id = benchmarks_id.removeprefix("IM-")
+        task = "Imputation"
+        
+    elif benchmarks_id.startswith("BI-"):
+        dataset_id = benchmarks_id.removeprefix("BI-")
+        task = "Batch Integration"
+        
+    elif benchmarks_id.startswith("TJ-"):
+        dataset_id = benchmarks_id.removeprefix("TJ-")
+        task = "Trajectory"
+        
+    elif benchmarks_id.startswith("CCC-"):
+        dataset_id = benchmarks_id.removeprefix("CCC-")
+        task = "Cell-Cell Communication"
+        
+    elif benchmarks_id.startswith("MI-"):
+        dataset_id = benchmarks_id.removeprefix("MI-")
+        task = "Multimodal Data Integration"
+        
+    elif benchmarks_id.startswith("CT-"):
+        dataset_id = benchmarks_id.removeprefix("CT-")
+        task = "Cell Type Annotation"
+
+    return dataset_id, task
+
+
+def get_bar_plot_data(benchmark_data, user_results=None):
+    labels = benchmark_data[0]['x']
+    y_labels = []
+    data = []
+    y_user = []
+    
+    # Add Benchmark data
+    for i in range(len(benchmark_data)):
+        data.append(benchmark_data[i]['y'])
+        y_labels.append(benchmark_data[i]['name'])
+    
+    # Add user results
+    if user_results is not None:    
+        y_labels.append(user_results['tool'])
+        for label in labels:
+            y_user.append(user_results[label])
+        data.append(y_user)
+
+    return labels, y_labels, data
+
+
+def plot_bars(task, labels, y_labels, data, tick_step=1, group_gap=0.2, bar_gap=0):
+    x = np.arange(len(labels)) * tick_step
+    group_num = len(data)
+    group_width = tick_step - group_gap
+    bar_span = group_width / group_num
+    bar_width = bar_span - bar_gap
+    for index, y in enumerate(data):
+        plt.bar(x + index*bar_span, y, bar_width, label=y_labels[index])
+    plt.ylabel('Scores')
+    plt.title(f'Benchmarks for {task}')
+    ticks = x + (group_width - bar_span) / 2
+    plt.xticks(ticks, labels)
+    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+    plt.show()
+
+
+def plot_lines(results):
+    x = results['time_points']
+    x = [n for n in range(len(x))]
+    data = []
+    y_labels = []
+    labels = ["CPU", "Memory", "GPU", "GPU Memory"]
+
+    for label in labels:
+        if sum(results[label]) != 0:
+            data.append(results[label])
+            y_labels.append(label)
+    
+    for i in range(len(data)):
+        if len(x) == len(data[i]):
+            if 'GPU' in y_labels[i]:
+                plt.plot(x, data[i], label=y_labels[i], marker='o', linestyle='--') # '--' sets a dashed line style
+            else:    
+                plt.plot(x, data[i], label=y_labels[i], marker='o') # 'o' adds circular markers
+
+    # Adding labels, title, and legend for clarity
+    plt.xlabel('Time Points (s)')
+    plt.ylabel('Utilization (%)')
+    plt.title('Computing Assessments')
+    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) # Displays the labels for each line
+
+    # Displaying the plot
+    plt.show()
+

oscb-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.2
+Name: oscb
+Version: 0.1.0
+Summary: OSCB aims to provide automated end-to-end single-cell analyses ML pipelines to simplify and standardize the process of single-cell data formatting, quality control, loading, model development, and model evaluation. 
+Home-page: https://github.com/cirisjl/Machine-learning-development-environment-for-single-cell-sequencing-data-analyses
+Author: Lei Jiang
+Author-email: leijiang@missouri.edu
+License: MIT
+Keywords: single-cell,benchmarks
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6, <=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: leidenalg>=0.8.10
+Requires-Dist: matplotlib>=3.5.1
+Requires-Dist: networkx>=2.6.3
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: pandas>=1.3.5
+Requires-Dist: python_igraph>=0.9.9
+Requires-Dist: python_louvain>=0.16
+Requires-Dist: scanpy
+Requires-Dist: muon
+Requires-Dist: mudata
+Requires-Dist: tqdm
+Requires-Dist: requests
+Requires-Dist: scib
+Requires-Dist: zss
+Requires-Dist: grakel
+Requires-Dist: scikit_learn>=1.0.2
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: umap_learn>=0.5.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Overview
+
+--------------------------------------------------------------------------------
+
+
+Machine learning (ML) is transforming single-cell sequencing data analysis; however, the barriers of technology complexity and biology knowledge remain challenging for the involvement of the ML community in single-cell data analysis. We present an ML development environment for single-cell sequencing data analyses with a diverse set of AI-Ready benchmark datasets. A cloud-based platform is built to dynamically scale workflows for collecting, processing, and managing various single-cell sequencing data to make them ML-ready. In addition, benchmarks for each problem formulation and a code-level and web-interface IDE for single-cell analysis method development are provided. 
+
+
+![Workflow](https://oscb.missouri.edu/assets/30e6000a-5e6f-440f-bec5-5c7ceb256c55)
+
+OSCB aims to provide automated end-to-end single-cell analyses ML pipelines to simplify and standardize the process of single-cell data formatting, quality control, loading, model development, and model evaluation. 
+
+
+**Workflows** are developed for collecting, processing, and managing diverse single-cell sequencing data to make them ML-ready and build benchmarks.
+
+**IDE** is provided for supporting partial method development.
+
+**Assessment utilities** are provided for evaluating results and report generation.
+
+This **end-to-end pipeline** transforms the traditional “static” machine Learning into **continuous learning** on extensive new data.
+
+
+By **in-depth fusing models with data**, this platform could ultimately help many single-cell sequencing researchers substantially.
+
+ 
+![Tools](https://oscb.missouri.edu/assets/c18ffb2a-814f-452c-921b-e399b99c41b4)
+
+
+OSCB is an on-going effort, and we are planning to increase our coverage in the future.

oscb-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+oscb/__init__.py,sha256=4-lyUl644DHa1-kCvev0FnHX5YX7WH-xQ8-aMsEgy_8,498
+oscb/data.py,sha256=AxV-umgeh_MdpOsR99V9Y7SXvEL6IqHby1RsNcp4kc0,4676
+oscb/evaluator.py,sha256=KoU4-l0EFsd4fUrL871MWJ9-cPVjmdgpRg5PApHKs3s,11029
+oscb/utilization.py,sha256=yOiUMnYw1PRnywCo_4Eeyl25Er6GJYZrvaSP4evQZ_4,4513
+oscb/utils.py,sha256=Ezm6cWWfldSO3lDNMOBzDFXWVC2pTXNxTzgMxA8k43g,3361
+oscb/evaluation/__init__.py,sha256=yV92jToZZNb4sJE2GsmXm6YCk1VQZv7nbrivrI8b-LQ,241
+oscb/evaluation/annotation.py,sha256=DY1-GasL5PPHLhsC6lIxE5kkVFQqshkt5yxWgxhAk9Q,1394
+oscb/evaluation/ccc.py,sha256=jKo7A1Vat1XIKYoZZlUDUrGBgTfLJmSl5JCjT1hWFNU,2151
+oscb/evaluation/clustering.py,sha256=xpYvumLnQjc147G3zyzqgEQNeUT9g45d65H6WVTTSNI,864
+oscb/evaluation/imputation.py,sha256=5eSWB2zkJLuqqg3mUET1UxdwHP2ytQsVV6H20HO5eyM,4499
+oscb/evaluation/integration.py,sha256=dD1uX5n11qcKJjAb_MRAZq5owszxoWgwfwa8EElKI1U,3106
+oscb/evaluation/multimodal.py,sha256=vFWVZI04ghaBvmyc6KfNpFwlDIuIfVkOYZLHd_geU2s,1851
+oscb/evaluation/trajectory.py,sha256=qyvsgFAzRs4ydQkkYU80OLIZOOhL-4jggid4maajaik,5231
+oscb-0.1.0.dist-info/METADATA,sha256=Yt6_SVTENmQeu2Ab6qHclON53eLtzYATFGNqDmT5l8g,3259
+oscb-0.1.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+oscb-0.1.0.dist-info/top_level.txt,sha256=-kscy76s5yJOs8EyWQof-Ico6tACMlsgQ7tHMT4sd2Q,5
+oscb-0.1.0.dist-info/RECORD,,

oscb-0.1.0.dist-info/WHEEL

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

oscb-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oscb