diff --git a/pytometry/__init__.py b/pytometry/__init__.py index 144601b..6222248 100644 --- a/pytometry/__init__.py +++ b/pytometry/__init__.py @@ -20,7 +20,7 @@ """ -__version__ = "0.1.0" # denote a pre-release for 0.1.0 with 0.1a1 +__version__ = "0.1.1" # denote a pre-release for 0.1.0 with 0.1a1 from . import plotting as pl from . import preprocessing as pp diff --git a/pytometry/preprocessing/__init__.py b/pytometry/preprocessing/__init__.py index e46b47a..c1e8167 100644 --- a/pytometry/preprocessing/__init__.py +++ b/pytometry/preprocessing/__init__.py @@ -1 +1,7 @@ -from ._process_data import compensate, create_comp_mat, find_indexes, split_signal +from ._process_data import ( + _dummy_spillover, + compensate, + create_comp_mat, + find_indexes, + split_signal, +) diff --git a/pytometry/preprocessing/_process_data.py b/pytometry/preprocessing/_process_data.py index a63c155..7672885 100644 --- a/pytometry/preprocessing/_process_data.py +++ b/pytometry/preprocessing/_process_data.py @@ -20,11 +20,11 @@ def create_comp_mat(spillmat: pd.DataFrame, relevant_data: str = "") -> pd.DataF Returns: pd.DataFrame of the compensation matrix. """ + comp_mat = np.linalg.inv(spillmat) + if relevant_data == "": - comp_mat = np.linalg.inv(spillmat) compens = pd.DataFrame(comp_mat, columns=list(spillmat.columns)) else: - comp_mat = np.linalg.inv(spillmat) compens = pd.DataFrame(comp_mat, columns=relevant_data) return compens @@ -135,7 +135,7 @@ def compensate( f" '{matrix_type}'." ) # To Do: add checks that this input is correct - if adata.uns["meta"]["spill"] is not None: + elif adata.uns["meta"]["spill"] is not None: compens = adata.uns["meta"]["spill"] else: raise KeyError(f"Did not find .uns['meta']['spill'] nor '{comp_matrix}'.") @@ -244,3 +244,20 @@ def split_signal( adata._inplace_subset_var(indx) return None if inplace else adata + + +# create test compensation matrix +def _dummy_spillover(n_rows=10, row_names=None) -> pd.DataFrame: + """Create dummy spillover matrix for testing. + + Args: + n_rows (int, optional): Number of rows and columns_. Defaults to 10. + row_names (index or array-like, optional): Index to use for the resulting + dataframe. Also used as column names. Defaults to None. + + Returns: + pd.DataFrame: A dummy spillover matrix with 2's on the diagonal + """ + tmp_mat = np.diag(np.ones(n_rows) * 2) + dummy_spill = pd.DataFrame(data=tmp_mat, index=row_names, columns=row_names) + return dummy_spill diff --git a/pytometry/tools/_normalization.py b/pytometry/tools/_normalization.py index 8c4b0c6..799fd4c 100644 --- a/pytometry/tools/_normalization.py +++ b/pytometry/tools/_normalization.py @@ -23,7 +23,7 @@ def normalize_arcsinh(adata: AnnData, cofactor: float, inplace: bool = True): """ adata = adata if inplace else adata.copy() adata.X = np.arcsinh(adata.X / cofactor) - return adata if inplace else None + return None if inplace else adata def normalize_logicle( diff --git a/tests/test_base.py b/tests/test_base.py index 11bf9bd..87e353f 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -1,10 +1,102 @@ import anndata +import numpy +import pandas import readfcs +from pytometry.preprocessing import _dummy_spillover, compensate, create_comp_mat from pytometry.read_write import read_fcs +from pytometry.tools import normalize_arcsinh, normalize_biExp, normalize_logicle +# test read function def test_read_fcs(): path_data = readfcs.datasets.example() adata = read_fcs(path_data) assert isinstance(adata, anndata._core.anndata.AnnData) + + +# test compensate +def test_compensate(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + compensate(adata) + assert isinstance(adata, anndata._core.anndata.AnnData) + + +def test_compensate_inplace(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + adata2 = compensate(adata, inplace=False) + assert isinstance(adata2, anndata._core.anndata.AnnData) + + +def test_spill(): + n_rows = 12 + spillmat = _dummy_spillover(n_rows=n_rows) + assert isinstance(spillmat, pandas.DataFrame) + assert spillmat.shape == (n_rows, n_rows) + + +def test_create_comp_mat(): + n_rows = 5 + spillmat = _dummy_spillover(n_rows=n_rows) + comp_mat = create_comp_mat(spillmat) + assert numpy.sum(comp_mat.values) == n_rows * 0.5 + + +# test custom dummy compensation +def test_compensate2(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + # use extra compensation matrix + spillmat = _dummy_spillover( + n_rows=adata.uns["meta"]["spill"].shape[0], + row_names=adata.uns["meta"]["spill"].index, + ) + adata2 = compensate( + adata, comp_matrix=spillmat, matrix_type="spillover", inplace=False + ) + assert adata2.X.sum() != adata.X.sum() + + +# test return types for normalization +def test_normalize_arcsinh(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + normalize_arcsinh(adata, cofactor=1, inplace=True) + assert isinstance(adata, anndata._core.anndata.AnnData) + + +def test_normalize_arcsinh2(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + adata2 = normalize_arcsinh(adata, cofactor=1, inplace=False) + assert isinstance(adata2, anndata._core.anndata.AnnData) + + +def test_normalize_biexp(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + normalize_biExp(adata, inplace=True) + assert isinstance(adata, anndata._core.anndata.AnnData) + + +def test_normalize_biexp2(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + adata2 = normalize_biExp(adata, inplace=False) + assert isinstance(adata2, anndata._core.anndata.AnnData) + + +def test_normalize_logicle(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + normalize_logicle(adata, inplace=True) + assert isinstance(adata, anndata._core.anndata.AnnData) + + +def test_normalize_logicle2(): + path_data = readfcs.datasets.example() + adata = read_fcs(path_data) + adata2 = normalize_logicle(adata, inplace=False) + assert isinstance(adata2, anndata._core.anndata.AnnData)