rectanglepy 0.1.8__tar.gz → 0.4.0__tar.gz

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.8
+current_version = 0.4.0
 tag = True
 commit = True
 

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/.github/workflows/build.yaml

@@ -1,4 +1,4 @@
-name: CI Checks
+name: CI Build
 
 on:
     push:

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/.github/workflows/test.yaml

@@ -1,4 +1,4 @@
-name: CI Checks
+name: CI Tests
 
 on:
     push:

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rectanglepy
-Version: 0.1.8
+Version: 0.4.0
 Summary: Hierarchical deconvolution of bulk  transcriptomics
 Project-URL: Documentation, https://rectanglepy.readthedocs.io/
 Project-URL: Source, https://github.com/ComputationalBiomedicineGroup/Rectangle
@@ -33,8 +33,9 @@ Requires-Python: >=3.10
 Requires-Dist: anndata<0.10.9,>=0.8.0
 Requires-Dist: loguru
 Requires-Dist: numpy<2.0.0,>=1.0.0
-Requires-Dist: pydeseq2==0.4.1
-Requires-Dist: quadprog==0.1.11
+Requires-Dist: pydeseq2==0.4.11
+Requires-Dist: quadprog==0.1.12
+Requires-Dist: statsmodels>=0.14.1
 Provides-Extra: dev
 Requires-Dist: bump2version; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["hatchling"]
 
 [project]
 name = "rectanglepy"
-version = "0.1.8"
+version = "0.4.0"
 description = "Hierarchical deconvolution of bulk  transcriptomics"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -19,11 +19,12 @@ urls.Documentation = "https://rectanglepy.readthedocs.io/"
 urls.Source = "https://github.com/ComputationalBiomedicineGroup/Rectangle"
 urls.Home-page = "https://github.com/ComputationalBiomedicineGroup/Rectangle"
 dependencies = [
-    "pydeseq2==0.4.1",
-    "quadprog==0.1.11",
+    "pydeseq2==0.4.11",
+    "quadprog==0.1.12",
     "loguru",
     "numpy>=1.0.0,<2.0.0",
     "anndata>=0.8.0,<0.10.9",
+    "statsmodels>=0.14.1"
 ]
 
 [project.optional-dependencies]

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/src/rectanglepy/pp/create_signature.py

@@ -1,9 +1,11 @@
 import numpy as np
 import pandas as pd
+import scipy.sparse
 from anndata import AnnData
 from loguru import logger
 from pandas import DataFrame, Series
 from pydeseq2.dds import DeseqDataSet
+from pydeseq2.default_inference import DefaultInference
 from pydeseq2.ds import DeseqStats
 from scipy.cluster.hierarchy import fcluster, linkage
 from scipy.stats import pearsonr
@@ -31,9 +33,10 @@ def _create_condition_number_matrices(de_adjusted, pseudo_signature):
     de_adjusted_lengths = {annotation: len(de_adjusted[annotation]) for annotation in de_adjusted}
     longest_de_analysis = max(de_adjusted_lengths.values())
 
-    loop_range = min(longest_de_analysis, 200)
-    range_minimum = 30
+    loop_range = min(longest_de_analysis, 80)
+    range_minimum = 20
 
+    # should the data be too small we need to adjust the range, mainly for testing purposes
     if loop_range < 8:
         range_minimum = 2
     elif loop_range < range_minimum:
@@ -71,13 +74,9 @@ def _calculate_cluster_range(number_of_cell_types: int) -> tuple[int, int]:
     cluster_factor = 3
     if number_of_cell_types > 12:
         cluster_factor = 4
-    if number_of_cell_types > 20:
-        cluster_factor = 6
-    if number_of_cell_types > 50:
-        cluster_factor = 10
     min_number_clusters = max(
         3, number_of_cell_types - cluster_factor
-    )  # we don't want to cluster too many cell types together
+    )  # we don't want to cluster too many cell types together, depending on the number of cell types
     max_number_clusters = number_of_cell_types - 1  # we want to have at least one cluster wih multiple cell types
     return min_number_clusters, max_number_clusters
 
@@ -121,45 +120,81 @@ def _filter_de_analysis_results(de_analysis_result, p, logfc):
     de_analysis_result["log2_fc"] = de_analysis_result["log2FoldChange"]
     de_analysis_result["gene"] = de_analysis_result.index
     adjusted_result = de_analysis_result[
-        (de_analysis_result["pvalue"] < max_p) & (de_analysis_result["log2_fc"] > min_log2FC)
+        (de_analysis_result["padj"] < max_p) & (de_analysis_result["log2_fc"] > min_log2FC)
     ]
-    # if increase p-value and decrease log2FC until genes are found or the threshold is reached
-    while len(adjusted_result) < 10 and (min_log2FC > 0.5 and max_p < 0.05):
-        min_log2FC = max(min_log2FC - 0.1, 0.5)
-        max_p = min(max_p + 0.001, 0.05)
-        adjusted_result = de_analysis_result[
-            (de_analysis_result["pvalue"] < max_p) & (de_analysis_result["log2_fc"] > min_log2FC)
-        ]
 
     return adjusted_result
 
 
-def _run_deseq2(countsig: pd.DataFrame, n_cpus: int = None) -> dict[str | int, pd.DataFrame]:
+def _run_deseq2(
+    countsig: pd.DataFrame, sc_data, annotations: pd.Series, n_cpus: int = None, gene_expression_threshold=0.5
+) -> dict[str | int, pd.DataFrame]:
     results = {}
-    count_df = countsig[countsig.sum(axis=1) > 0].T
-    for i, cell_type in enumerate(countsig.columns):
+    inference = DefaultInference(n_cpus=n_cpus)
+    bootstrapped_signature = _create_bootstrap_signature(countsig, sc_data, annotations)
+    np.random.seed(42)
+    for _i, cell_type in enumerate(countsig.columns):
+        bootstrapped_signature_copy = bootstrapped_signature.copy()
+        countsig_copy = countsig.copy()
+        sc_data_filtered = sc_data.T[annotations == cell_type]
+        expressed_cells = (sc_data_filtered > 0).sum(axis=0)
+        if expressed_cells.ndim > 1:  # needed for sparse matrices
+            expressed_cells = np.squeeze(np.asarray(expressed_cells))
+            # make dense out of sparse
+            sc_data_filtered = sc_data_filtered.toarray()
+        threshold = gene_expression_threshold * sc_data_filtered.shape[0]
+        genes = countsig_copy.index[expressed_cells > threshold].tolist()
+        bootstrapped_signature_copy = bootstrapped_signature_copy.loc[genes].T
         logger.info(f"Running DE analysis for {cell_type}")
-        condition = np.zeros(len(countsig.columns))
-        condition[i] = 1
-        clinical_df = pd.DataFrame({"condition": condition}, index=countsig.columns)
-        dds = DeseqDataSet(counts=count_df, metadata=clinical_df, design_factors="condition", quiet=True, n_cpus=n_cpus)
+        condition = ["B" if (cell_type + "_") in x else "A" for x in bootstrapped_signature_copy.index]
+        clinical_df = pd.DataFrame({"condition": condition}, index=bootstrapped_signature_copy.index)
+        dds = DeseqDataSet(
+            counts=bootstrapped_signature_copy,
+            metadata=clinical_df,
+            design_factors="condition",
+            quiet=True,
+            inference=inference,
+            refit_cooks=False,
+        )
         dds.deseq2()
-        dds.varm["LFC"] = dds.varm["LFC"].round(4)
-        dds.varm["dispersions"] = dds.varm["dispersions"].round(3)
-
-        stat_res = DeseqStats(dds, n_cpus=n_cpus, quiet=True)
+        stat_res = DeseqStats(dds, inference=inference, quiet=True, cooks_filter=False)
         stat_res.summary(quiet=True)
-        stat_res.lfc_shrink()
+        stat_res.lfc_shrink("condition_B_vs_A")
         results[cell_type] = stat_res.results_df
 
     return results
 
 
+def _create_bootstrap_signature(countsig, sc_data, annotations) -> pd.DataFrame:
+    if scipy.sparse.issparse(sc_data):
+        sc_data = sc_data.toarray()
+    celltypes = countsig.columns
+    bootstrapped_signature = pd.DataFrame()
+    number_of_bootstraps = 5
+    samples_per_bootstrap = 250
+    for celltype in celltypes:
+        sc_data_filtered = sc_data.T[annotations == celltype]
+        for i in range(number_of_bootstraps):
+            selected_rows = np.random.choice(len(sc_data_filtered), samples_per_bootstrap, replace=True)
+            summed_rows = sc_data_filtered[selected_rows].sum(axis=0)
+            bootstrapped_signature[f"{celltype}_{i}"] = list(summed_rows)
+    bootstrapped_signature.index = countsig.index
+    return bootstrapped_signature
+
+
 def _de_analysis(
-    pseudo_count_sig, sc_data, annotations, p, lfc, optimize_cutoffs: bool, n_cpus: int = None, genes=None
+    pseudo_count_sig,
+    sc_data,
+    annotations: pd.Series,
+    p,
+    lfc,
+    optimize_cutoffs: bool,
+    n_cpus: int = None,
+    genes=None,
+    gene_expression_threshold=0.5,
 ) -> tuple[Series, dict[str, [str]] :, DataFrame | None]:
     logger.info("Starting DE analysis")
-    deseq_results = _run_deseq2(pseudo_count_sig, n_cpus)
+    deseq_results = _run_deseq2(pseudo_count_sig, sc_data, annotations, n_cpus, gene_expression_threshold)
     optimization_results = None
 
     if optimize_cutoffs:
@@ -188,6 +223,9 @@ def _get_marker_genes(deseq_results, logfc, p, pseudo_count_sig):
 
     markers = optimal_condition_matrix.index
     marker_genes_per_cell_type = _get_marker_genes_per_cell_type(de_analysis_adjusted, optimal_condition_number)
+    flattened_markers = [item for sublist in marker_genes_per_cell_type.values() for item in sublist]
+    duplicated_markers = [x for x in flattened_markers if flattened_markers.count(x) > 1]
+    print("duplicated markers: ", duplicated_markers)
     return markers, marker_genes_per_cell_type
 
 
@@ -248,6 +286,7 @@ def build_rectangle_signatures(
     sample_size: int = 1500,
     n_cpus: int = None,
     run: int = 0,
+    gene_expression_threshold=0.5,
 ) -> RectangleSignatureResult:
     r"""Builds rectangle signatures based on single-cell  count data and annotations.
 
@@ -277,11 +316,16 @@ def build_rectangle_signatures(
         The number of cpus to use for the DE analysis. Defaults to the number of cpus available.
     run
         The consensus run number for the analysis. Defaults to 0.
+    gene_expression_threshold
+        The gene expression threshold for the DE analysis. How many cells need to express a gene to be considered in DGE
 
     Returns
     -------
     The result of the rectangle signature analysis which is of type RectangleSignatureResult.
     """
+    annotations = adata.obs[cell_type_col]
+    adata = adata[:, adata.X.sum(axis=0) > len(annotations.value_counts())]
+
     if bulks is not None:
         genes = list(set(bulks.columns) & set(adata.var_names))
         genes = sorted(genes)
@@ -289,7 +333,6 @@ def build_rectangle_signatures(
         logger.info(f"Using {len(genes)} common genes between bulks and single-cell data")
         adata = adata[:, genes]
 
-    annotations = adata.obs[cell_type_col]
     if subsample:
         annotations = _even(annotations, sample_size, run)
         adata = adata[annotations.index]
@@ -309,7 +352,7 @@ def build_rectangle_signatures(
     m_rna_biasfactors = _create_bias_factors(pseudo_sig_counts, sc_counts, annotations)
 
     marker_genes, marker_genes_per_cell_type, optimization_result = _de_analysis(
-        pseudo_sig_counts, sc_counts, annotations, p, lfc, optimize_cutoffs, n_cpus, genes
+        pseudo_sig_counts, sc_counts, annotations, p, lfc, optimize_cutoffs, n_cpus, genes, gene_expression_threshold
     )
     pseudo_sig_cpm = _convert_to_cpm(pseudo_sig_counts)
     logger.info("Starting rectangle cluster analysis")
@@ -329,7 +372,13 @@ def build_rectangle_signatures(
 
     clustered_biasfact = _create_bias_factors(clustered_signature, sc_counts, clustered_annotations)
     clustered_genes, clustered_marker_genes_per_cell_type, _ = _de_analysis(
-        clustered_signature, sc_counts, clustered_annotations, p, lfc, False
+        clustered_signature,
+        sc_counts,
+        clustered_annotations,
+        p,
+        lfc,
+        False,
+        gene_expression_threshold=gene_expression_threshold,
     )
     clustered_signature = _convert_to_cpm(clustered_signature)
     return RectangleSignatureResult(
@@ -361,9 +410,9 @@ def _create_pseudo_count_sig(sc_counts: np.ndarray, annotations: pd.Series, var_
 def _optimize_parameters(
     sc_data: pd.DataFrame, annotations: pd.Series, pseudo_signature_counts: pd.DataFrame, de_results, genes=None
 ) -> pd.DataFrame:
-    # if there are many cell types we relax the cutoffs
-    lfcs = [x / 100 for x in range(140, 200, 10)]
-    ps = [x / 1000 for x in range(15, 20, 1)]
+    # search space for p and lfc
+    lfcs = [x / 100 for x in range(160, 230, 10)]
+    ps = [x / 1000 for x in range(50, 51, 1)]
 
     results = []
     logger.info("generating pseudo bulks")
@@ -380,6 +429,7 @@ def _optimize_parameters(
                 logger.error(f"Error in assessing parameter fit for p={p}, lfc={lfc}: {e}")
 
     results_df = pd.DataFrame(results)
+    # best results first
     results_df = results_df.sort_values(by=["pearson_r", "rmse"], ascending=[False, True])
 
     return results_df

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/src/rectanglepy/rectangle.py

@@ -39,6 +39,7 @@ def rectangle_consens(
     p=0.015,
     lfc=1.5,
     n_cpus: int = None,
+    gene_expression_threshold=0.5,
 ) -> tuple[DataFrame, RectangleSignatureResult, ConsensusResult]:
     r"""All in one deconvolution method. Creates signatures and deconvolutes the bulk data. Has options for subsampling and consensus runs.
 
@@ -70,6 +71,8 @@ def rectangle_consens(
         The number of cpus to use for the DE analysis. None value takes all cpus available.
     correct_mrna_bias : bool
         A flag indicating whether to correct for mRNA bias. Defaults to True.
+    gene_expression_threshold : float
+        The threshold for gene expression. Genes with expression below this threshold are removed from the analysis.
 
     Returns
     -------
@@ -80,12 +83,6 @@ def rectangle_consens(
     assert isinstance(adata, AnnData), "adata must be an AnnData object"
     assert isinstance(bulks, DataFrame), "bulks must be a DataFrame"
 
-    if bulks is not None:
-        genes = list(set(bulks.columns) & set(adata.var_names))
-        genes = sorted(genes)
-        adata = adata[:, genes]
-        bulks = bulks[genes]
-
     if consensus_runs > 1:
         logger.info(f"Running {consensus_runs} consensus runs with subsample size {sample_size}")
         subsample = True
@@ -109,6 +106,7 @@ def rectangle_consens(
             subsample=subsample,
             sample_size=sample_size,
             run=i,
+            gene_expression_threshold=gene_expression_threshold,
         )
         most_recent_signatures = signatures
         cell_fractions = deconvolution(signatures, bulks, correct_mrna_bias, n_cpus)
@@ -117,7 +115,8 @@ def rectangle_consens(
         signatures.unkn_gene_corr = unkn_gene_corr
         rectangle_signature_results.append(signatures)
     consensus_estimations = pd.concat(estimations).groupby(level=0).median()
-    # normalize the estimations to 1
+
+    # normalize the estimations to 1, needed for the consensus
     consensus_estimations = consensus_estimations.div(consensus_estimations.sum(axis=1), axis=0)
     consensus_results = ConsensusResult(estimations, rectangle_signature_results)
     return consensus_estimations, most_recent_signatures, consensus_results
@@ -135,6 +134,7 @@ def rectangle(
     p=0.015,
     lfc=1.5,
     n_cpus: int = None,
+    gene_expression_threshold=0.5,
 ) -> tuple[DataFrame, RectangleSignatureResult]:
     r"""All in one deconvolution method. Creates signatures and deconvolutes the bulk data. Has options for subsampling and consensus runs.
 
@@ -160,6 +160,8 @@ def rectangle(
         The number of cpus to use for the DE analysis. None value takes all cpus available.
     correct_mrna_bias : bool
         A flag indicating whether to correct for mRNA bias. Defaults to True.
+    gene_expression_threshold : float
+        The threshold for gene expression. Genes with expression below this threshold are removed from the analysis.
 
     Returns
     -------
@@ -180,6 +182,7 @@ def rectangle(
         p=p,
         lfc=lfc,
         n_cpus=n_cpus,
+        gene_expression_threshold=gene_expression_threshold,
     )
     return estimations, signatures
 

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/src/rectanglepy/tl/deconvolution.py

@@ -180,6 +180,8 @@ def deconvolution(
         A DataFrame containing the estimated cell fractions resulting from deconvolution. Each row represents a sample and each column represents a cell type.
 
     """
+    bulks = bulks.div(bulks.sum(axis=1), axis=0) * 1e6
+
     if n_cpus is not None:
         num_processes = n_cpus
     else:
@@ -223,7 +225,7 @@ def _deconvolute(signatures: RectangleSignatureResult, bulk: pd.Series, correct_
     bias_factors = signatures.bias_factors
 
     if not correct_mrna_bias:
-        bias_factors = bias_factors * 0 + 1
+        bias_factors = bias_factors * 0 + 1  # set all bias factors to 1
 
     signature = pseudobulk_sig_cpm.loc[signature_genes_direct_reduced] * bias_factors
     start_fractions = _calculate_dwls(signature, bulk)
@@ -242,36 +244,30 @@ def _deconvolute(signatures: RectangleSignatureResult, bulk: pd.Series, correct_
     ]
     clustered_signature = clustered_pseudobulk_sig_cpm.loc[clustered_signature_genes] * cluster_bias_factors
 
-    union_genes = list(set(signature_genes_direct_reduced) | set(clustered_signature_genes))
-    union_direct_signature = pseudobulk_sig_cpm.loc[union_genes] * bias_factors
-
     try:
         clustered_fractions = _calculate_dwls(clustered_signature, bulk)
         recursive_fractions = _calculate_dwls(signature, bulk, signatures.assignments, clustered_fractions)
     except Exception as e:
         logger.warning(f"Recursive deconvolution failed with error: {e}")
+        start_fractions = correct_for_unknown_cell_content(bulk, pseudobulk_sig_cpm, start_fractions, bias_factors)
         return start_fractions
 
-    union_direct_fraction = _calculate_dwls(union_direct_signature, bulk)
-
-    averaged_start_fractions = (start_fractions + union_direct_fraction) / 2
-
     final_fractions = []
 
-    low_number_threshold = 30
+    low_number_threshold = 20
     cell_types_with_low_number_of_marker_genes = [
         cell_type
         for cell_type, num_marker_genes in signatures.marker_genes_per_cell_type.items()
         if len(num_marker_genes) < low_number_threshold
     ]
 
-    for cell_type in list(averaged_start_fractions.index):
+    for cell_type in list(start_fractions.index):
         if cell_type in cell_types_with_low_number_of_marker_genes:
             final_fractions.append(recursive_fractions[cell_type])
         else:
-            final_fractions.append(averaged_start_fractions[cell_type])
+            final_fractions.append(start_fractions[cell_type])
 
-    final_fractions = pd.Series(final_fractions, index=averaged_start_fractions.index)
+    final_fractions = pd.Series(final_fractions, index=start_fractions.index)
 
     final_fractions = correct_for_unknown_cell_content(bulk, pseudobulk_sig_cpm, final_fractions, bias_factors)
     return final_fractions
@@ -315,9 +311,11 @@ def correct_for_unknown_cell_content(
     if estimates.sum() == 0:
         estimates_fix = estimates
         # analysis fails if all cell fractions are zero, so we set the unknown cell content to ß
-        estimates_fix.loc["Unknown"] = 0
+        estimates_fix["Unknown"] = 0
         return estimates_fix
 
+    signature_genes = pseudo_signature_cpm.index
+    bulk = bulk.loc[signature_genes]
     signature = pseudo_signature_cpm.sort_index()
     bulk = bulk.sort_index()
 
@@ -330,11 +328,11 @@ def correct_for_unknown_cell_content(
     # Calculate the unknown cellular content ad the difference of
     # per-sample overall expression levels in the true vs. reconstructed
     # bulk RNA-seq data, divided by the overall expression in the true bulk
-    ukn_cc = (bulk - bulk_est).sum() / (bulk.sum())
+    ukn_cc = (bulk.sum() - bulk_est.sum()) / (bulk.sum())
     ukn_cc = max(0, ukn_cc)
     # Correct (i.e. scale) the cell fraction estimates so that their sum
     # equals 1 - the unknown cellular content estimated above
     estimates_fix = estimates / estimates.sum() * (1 - ukn_cc)
-    estimates_fix.loc["Unknown"] = abs(ukn_cc)
+    estimates_fix["Unknown"] = abs(ukn_cc)
 
     return estimates_fix

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/tests/test_pp.py

@@ -11,6 +11,7 @@ from rectanglepy.pp.create_signature import (
     _calculate_cluster_range,
     _create_annotations_from_cluster_labels,
     _create_bias_factors,
+    _create_bootstrap_signature,
     _create_fclusters,
     _create_linkage_matrix,
     _create_pseudo_count_sig,
@@ -171,7 +172,7 @@ def test_asses_fit(small_data):
     sc_counts, annotations, bulk = small_data
     sc_counts = sc_counts.astype("int")
     sc_pseudo = sc_counts.groupby(annotations.values, axis=1).sum()
-    de_result = _run_deseq2(sc_pseudo, None)
+    de_result = _run_deseq2(sc_pseudo, sc_counts.values, annotations)
 
     adata = AnnData(sc_counts.T, obs=annotations.to_frame(name="cell_type"))
     bulks, real_fractions = _generate_pseudo_bulks(adata.X.T, annotations, adata.var_names)
@@ -196,17 +197,16 @@ def test_de_analysis(small_data):
     sc_pseudo = sc_counts.groupby(annotations.values, axis=1).sum()
 
     adata = AnnData(sc_counts.T, obs=annotations.to_frame(name="cell_type"))
-    r1, r2, r3 = _de_analysis(sc_pseudo, adata.X.T, annotations, 0.3, 0.5, False, None, adata.var_names)
+    r1, r2, r3 = _de_analysis(sc_pseudo, adata.X.T, annotations, 0.4, 0.1, False, None, adata.var_names)
 
     sc_counts = sc_counts.astype(pd.SparseDtype("int"))
     csr_sparse_matrix = sc_counts.sparse.to_coo().tocsr()
     adata_sparse = AnnData(csr_sparse_matrix.T, obs=annotations.to_frame(name="cell_type"))
-    rs1, rs2, rs3 = _de_analysis(sc_pseudo, adata_sparse.X.T, annotations, 0.3, 0.5, False, None, adata.var_names)
+    # test with sparse matrix
+    _ = _de_analysis(sc_pseudo, adata_sparse.X.T, annotations, 0.4, 0.1, False, None, adata.var_names)
 
-    assert 30 < len(r1) < 40
+    assert 5 < len(r1) < 50
     assert len(r2) == 3
-    assert (r1.values == rs1.values).all()
-    assert r2 == rs2
 
 
 def test_even(small_data):
@@ -239,5 +239,15 @@ def test_build_rectangle_signatures_even(small_data):
         adata, "cell_type", bulks=bulk.T, p=0.5, lfc=0.1, optimize_cutoffs=False
     )
 
-    assert results_uneven.signature_genes.equals(results_even.signature_genes)
     assert results_even.bias_factors.equals(results_uneven.bias_factors)
+
+
+def test_create_bootstrap_signature(small_data):
+    bootstraps_per_cell = 5
+    sc_counts, annotations, bulk = small_data
+    sc_counts = sc_counts.astype("int")
+    sc_pseudo = sc_counts.groupby(annotations.values, axis=1).sum()
+    adata = AnnData(sc_counts.T, obs=annotations.to_frame(name="cell_type"))
+    bootstrap = _create_bootstrap_signature(sc_pseudo, adata.X.T, annotations)
+
+    assert len(bootstrap.columns) == len(sc_pseudo.columns) * bootstraps_per_cell

{rectanglepy-0.1.8 → rectanglepy-0.4.0}/tests/test_rectangle.py

@@ -15,7 +15,7 @@ def test_load_tutorial_data():
 
 def test_rectangle():
     sc_data, annotations, bulks = rectanglepy.load_tutorial_data()
-    sc_data = sc_data.iloc[:, :500]
+    sc_data = sc_data.iloc[:, :2000]
     sc_data_adata = AnnData(sc_data, obs=annotations.to_frame(name="cell_type"))
 
     result = rectanglepy.rectangle(sc_data_adata, bulks)
@@ -32,7 +32,7 @@ def test_rectangle_consensus():
     sc_data_adata = AnnData(sc_data, obs=annotations.to_frame(name="cell_type"))
 
     result = rectanglepy.rectangle_consens(
-        sc_data_adata, bulks, optimize_cutoffs=False, p=0.5, lfc=0.0, consensus_runs=3, sample_size=50
+        sc_data_adata, bulks, optimize_cutoffs=False, p=0.2, lfc=0.0, consensus_runs=3, sample_size=50
     )
 
     assert isinstance(result[0], pd.DataFrame)