pertpy 0.11.5__py3-none-any.whl → 1.0.1__py3-none-any.whl

pertpy/__init__.py

@@ -2,10 +2,11 @@
 
 __author__ = "Lukas Heumos"
 __email__ = "lukas.heumos@posteo.net"
-__version__ = "0.11.5"
+__version__ = "1.0.1"
 
 import warnings
 
+from anndata._core.aligned_df import ImplicitModificationWarning
 from matplotlib import MatplotlibDeprecationWarning
 from numba import NumbaDeprecationWarning
 
@@ -13,6 +14,8 @@ warnings.filterwarnings("ignore", category=NumbaDeprecationWarning)
 warnings.filterwarnings("ignore", category=MatplotlibDeprecationWarning)
 warnings.filterwarnings("ignore", category=SyntaxWarning)
 warnings.filterwarnings("ignore", category=UserWarning, module="scvi._settings")
+warnings.filterwarnings("ignore", message="Environment variable.*redefined by R")
+warnings.filterwarnings("ignore", message="Transforming to str index.", category=ImplicitModificationWarning)
 
 import mudata
 

pertpy/data/_dataloader.py

@@ -49,66 +49,69 @@ def _download(  # pragma: no cover
     Path(output_path).mkdir(parents=True, exist_ok=True)
     lock_path = Path(output_path) / f"{output_file_name}.lock"
 
-    with FileLock(lock_path, timeout=300):
-        if Path(download_to_path).exists() and not overwrite:
-            logger.warning(f"File {download_to_path} already exists!")
-            return download_to_path
-
-        temp_file_name = Path(f"{download_to_path}.part")
-
-        retry_count = 0
-        while retry_count <= max_retries:
-            try:
-                head_response = requests.head(url, timeout=timeout)
-                head_response.raise_for_status()
-                content_length = int(head_response.headers.get("content-length", 0))
-
-                free_space = shutil.disk_usage(output_path).free
-                if content_length > free_space:
-                    raise OSError(
-                        f"Insufficient disk space. Need {content_length} bytes, but only {free_space} available."
-                    )
-
-                response = requests.get(url, stream=True)
-                response.raise_for_status()
-                total = int(response.headers.get("content-length", 0))
-
-                with Progress(refresh_per_second=5) as progress:
-                    task = progress.add_task("[red]Downloading...", total=total)
-                    with Path(temp_file_name).open("wb") as file:
-                        for data in response.iter_content(block_size):
-                            file.write(data)
-                            progress.update(task, advance=len(data))
-                        progress.update(task, completed=total, refresh=True)
-
-                Path(temp_file_name).replace(download_to_path)
-
-                if is_zip:
-                    with ZipFile(download_to_path, "r") as zip_obj:
-                        zip_obj.extractall(path=output_path)
-                    return Path(output_path)
-
+    try:
+        with FileLock(lock_path, timeout=300):
+            if Path(download_to_path).exists() and not overwrite:
+                logger.warning(f"File {download_to_path} already exists!")
                 return download_to_path
-            except (OSError, RequestException) as e:
-                retry_count += 1
-                if retry_count <= max_retries:
-                    logger.warning(
-                        f"Download attempt {retry_count}/{max_retries} failed: {str(e)}. Retrying in {retry_delay} seconds..."
-                    )
-                    time.sleep(retry_delay)
-                else:
-                    logger.error(f"Download failed after {max_retries} attempts: {str(e)}")
+
+            temp_file_name = Path(f"{download_to_path}.part")
+
+            retry_count = 0
+            while retry_count <= max_retries:
+                try:
+                    head_response = requests.head(url, timeout=timeout)
+                    head_response.raise_for_status()
+                    content_length = int(head_response.headers.get("content-length", 0))
+
+                    free_space = shutil.disk_usage(output_path).free
+                    if content_length > free_space:
+                        raise OSError(
+                            f"Insufficient disk space. Need {content_length} bytes, but only {free_space} available."
+                        )
+
+                    response = requests.get(url, stream=True)
+                    response.raise_for_status()
+                    total = int(response.headers.get("content-length", 0))
+
+                    with Progress(refresh_per_second=5) as progress:
+                        task = progress.add_task("[red]Downloading...", total=total)
+                        with Path(temp_file_name).open("wb") as file:
+                            for data in response.iter_content(block_size):
+                                file.write(data)
+                                progress.update(task, advance=len(data))
+                            progress.update(task, completed=total, refresh=True)
+
+                    Path(temp_file_name).replace(download_to_path)
+
+                    if is_zip:
+                        with ZipFile(download_to_path, "r") as zip_obj:
+                            zip_obj.extractall(path=output_path)
+                        return Path(output_path)
+
+                    return download_to_path
+                except (OSError, RequestException) as e:
+                    retry_count += 1
+                    if retry_count <= max_retries:
+                        logger.warning(
+                            f"Download attempt {retry_count}/{max_retries} failed: {str(e)}. Retrying in {retry_delay} seconds..."
+                        )
+                        time.sleep(retry_delay)
+                    else:
+                        logger.error(f"Download failed after {max_retries} attempts: {str(e)}")
+                        if Path(temp_file_name).exists():
+                            Path(temp_file_name).unlink(missing_ok=True)
+                        raise
+
+                except Exception as e:
+                    logger.error(f"Download failed: {str(e)}")
                     if Path(temp_file_name).exists():
                         Path(temp_file_name).unlink(missing_ok=True)
                     raise
+                finally:
+                    if Path(temp_file_name).exists():
+                        Path(temp_file_name).unlink(missing_ok=True)
+    finally:
+        lock_path.unlink(missing_ok=True)
 
-            except Exception as e:
-                logger.error(f"Download failed: {str(e)}")
-                if Path(temp_file_name).exists():
-                    Path(temp_file_name).unlink(missing_ok=True)
-                raise
-            finally:
-                if Path(temp_file_name).exists():
-                    Path(temp_file_name).unlink(missing_ok=True)
-
-        return Path(download_to_path)
+    return Path(download_to_path)

pertpy/tools/__init__.py

@@ -1,24 +1,5 @@
 from importlib import import_module
 
-
-def lazy_import(module_path: str, class_name: str, extras: list[str]):
-    try:
-        for extra in extras:
-            import_module(extra)
-        module = import_module(module_path)
-        return getattr(module, class_name)
-    except ImportError:
-
-        class Placeholder:
-            def __init__(self, *args, **kwargs):
-                raise ImportError(
-                    f"Extra dependencies required: {', '.join(extras)}. "
-                    f"Please install with: pip install {' '.join(extras)}"
-                )
-
-        return Placeholder
-
-
 from pertpy.tools._augur import Augur
 from pertpy.tools._cinemaot import Cinemaot
 from pertpy.tools._coda._sccoda import Sccoda
@@ -42,15 +23,25 @@ from pertpy.tools._perturbation_space._simple import (
 )
 from pertpy.tools._scgen import Scgen
 
-CODA_EXTRAS = ["toytree", "ete4"]  # also "pyqt6" but it cannot be imported
-Tasccoda = lazy_import("pertpy.tools._coda._tasccoda", "Tasccoda", CODA_EXTRAS)
 
-DE_EXTRAS = ["formulaic", "pydeseq2"]
-EdgeR = lazy_import("pertpy.tools._differential_gene_expression", "EdgeR", DE_EXTRAS)  # edgeR will be imported via rpy2
-PyDESeq2 = lazy_import("pertpy.tools._differential_gene_expression", "PyDESeq2", DE_EXTRAS)
-Statsmodels = lazy_import("pertpy.tools._differential_gene_expression", "Statsmodels", DE_EXTRAS + ["statsmodels"])
-TTest = lazy_import("pertpy.tools._differential_gene_expression", "TTest", DE_EXTRAS)
-WilcoxonTest = lazy_import("pertpy.tools._differential_gene_expression", "WilcoxonTest", DE_EXTRAS)
+def __getattr__(name: str):
+    if name == "Tasccoda":
+        try:
+            for extra in ["toytree", "ete4"]:
+                import_module(extra)
+            module = import_module("pertpy.tools._coda._tasccoda")
+            return module.Tasccoda
+        except ImportError:
+            raise ImportError(
+                "Extra dependencies required: toytree, ete4. Please install with: pip install toytree ete4"
+            ) from None
+
+    elif name in ["EdgeR", "PyDESeq2", "Statsmodels", "TTest", "WilcoxonTest"]:
+        module = import_module("pertpy.tools._differential_gene_expression")
+        return getattr(module, name)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = [
     "Augur",

pertpy/tools/_coda/_base_coda.py

@@ -1181,7 +1181,7 @@ class CompositionalModel2(ABC):
                 r,
                 bars,
                 bottom=cum_bars,
-                color=palette(n % palette.N),
+                color=palette(n % palette.N),  # type: ignore
                 width=barwidth,
                 label=type_names[n],
                 linewidth=0,
@@ -1377,6 +1377,7 @@ class CompositionalModel2(ABC):
         plot_df.columns = covariate_names
         plot_df = pd.melt(plot_df, ignore_index=False, var_name="Covariate")
 
+        plot_df.index.name = "Cell Type"
         plot_df = plot_df.reset_index()
 
         if len(covariate_names_zero) != 0 and plot_facets and plot_zero_covariate and not plot_zero_cell_type:
@@ -1472,6 +1473,7 @@ class CompositionalModel2(ABC):
         if return_fig and not plot_facets:
             return plt.gcf()
         plt.show()
+
         return None
 
     @_doc_params(common_plot_args=doc_common_plot_args)
@@ -1823,6 +1825,7 @@ class CompositionalModel2(ABC):
         if return_fig:
             return plt.gcf()
         plt.show()
+
         return None
 
     @_doc_params(common_plot_args=doc_common_plot_args)
@@ -1881,7 +1884,7 @@ class CompositionalModel2(ABC):
             from ete4.treeview import CircleFace, NodeStyle, TextFace, TreeStyle, faces
         except ImportError:
             raise ImportError(
-                "To use tasccoda please install additional dependencies with `pip install pertpy[coda]`"
+                "To use tasccoda please install additional dependencies: `pip install pertpy[coda]`"
             ) from None
 
         if isinstance(data, MuData):
@@ -1902,8 +1905,8 @@ class CompositionalModel2(ABC):
             tree.render(save, tree_style=tree_style, units=units, w=figsize[0], h=figsize[1], dpi=dpi)  # type: ignore
         if return_fig:
             return tree, tree_style
+
         return tree.render("%%inline", tree_style=tree_style, units=units, w=figsize[0], h=figsize[1], dpi=dpi)  # type: ignore
-        return None
 
     @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_draw_effects(  # pragma: no cover # noqa: D417
@@ -1969,7 +1972,7 @@ class CompositionalModel2(ABC):
             from ete4.treeview import CircleFace, NodeStyle, TextFace, TreeStyle, faces
         except ImportError:
             raise ImportError(
-                "To use tasccoda please install additional dependencies as `pip install pertpy[coda]`"
+                "To use tasccoda please install additional dependencies: `pip install pertpy[coda]`"
             ) from None
 
         if isinstance(data, MuData):
@@ -2207,6 +2210,7 @@ class CompositionalModel2(ABC):
         if return_fig:
             return fig
         plt.show()
+
         return None
 
 
@@ -2325,6 +2329,7 @@ def df2newick(df: pd.DataFrame, levels: list[str], inner_label: bool = True) ->
     strs = [traverse(df_tax, a, 0, inner_label) for a in alevel]
 
     newick = f"({','.join(strs)});"
+
     return newick
 
 
@@ -2562,6 +2567,7 @@ def from_scanpy(
     covariate_obs = list(set(covariate_obs or []) | set(sample_identifier))
 
     if isinstance(sample_identifier, list):
+        adata.obs = adata.obs.copy()
         adata.obs["scCODA_sample_id"] = adata.obs[sample_identifier].agg("-".join, axis=1)
         sample_identifier = "scCODA_sample_id"
 

pertpy/tools/_coda/_sccoda.py

@@ -409,6 +409,48 @@ class Sccoda(CompositionalModel2):
         import arviz as az
 
         # Create arviz object
+        if use_posterior_predictive:
+            posterior_predictive = Predictive(self.model, self.mcmc.get_samples())(
+                rng_key,
+                counts=None,
+                covariates=numpyro_covariates,
+                n_total=numpyro_n_total,
+                ref_index=ref_index,
+                sample_adata=sample_adata,
+            )
+            # Remove problematic posterior predictive arrays with wrong dimensions
+            if posterior_predictive and "counts" in posterior_predictive:
+                counts_shape = posterior_predictive["counts"].shape
+                expected_dims = 2  # ['sample', 'cell_type']
+                if len(counts_shape) != expected_dims:
+                    posterior_predictive = {k: v for k, v in posterior_predictive.items() if k != "counts"}
+                    logger.warning(
+                        f"Removed 'counts' from posterior_predictive due to dimension mismatch: got {len(counts_shape)}D, expected {expected_dims}D"
+                    )
+        else:
+            posterior_predictive = None
+
+        if num_prior_samples > 0:
+            prior = Predictive(self.model, num_samples=num_prior_samples)(
+                rng_key,
+                counts=None,
+                covariates=numpyro_covariates,
+                n_total=numpyro_n_total,
+                ref_index=ref_index,
+                sample_adata=sample_adata,
+            )
+            # Remove problematic prior arrays with wrong dimensions
+            if prior and "counts" in prior:
+                counts_shape = prior["counts"].shape
+                expected_dims = 2  # ['sample', 'cell_type']
+                if len(counts_shape) != expected_dims:
+                    prior = {k: v for k, v in prior.items() if k != "counts"}
+                    logger.warning(
+                        f"Removed 'counts' from prior due to dimension mismatch: got {len(counts_shape)}D, expected {expected_dims}D"
+                    )
+        else:
+            prior = None
+
         arviz_data = az.from_numpyro(
             self.mcmc, prior=prior, posterior_predictive=posterior_predictive, dims=dims, coords=coords
         )

pertpy/tools/_dialogue.py

@@ -882,9 +882,9 @@ class Dialogue:
             if len(conditions_compare) != 2:
                 raise ValueError("Please specify conditions to compare or supply an object with only 2 conditions")
 
-        pvals = pd.DataFrame(1, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
-        tstats = pd.DataFrame(1, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
-        pvals_adj = pd.DataFrame(1, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
+        pvals = pd.DataFrame(1.0, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
+        tstats = pd.DataFrame(1.0, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
+        pvals_adj = pd.DataFrame(1.0, adata.obs[celltype_label].unique(), ["mcp_" + str(n) for n in range(n_mcps)])
 
         response = adata.obs.groupby(sample_label)[condition_label].agg(pd.Series.mode)
         for celltype in adata.obs[celltype_label].unique():

pertpy/tools/_differential_gene_expression/__init__.py

@@ -1,9 +1,52 @@
+import contextlib
+from importlib import import_module
+from importlib.util import find_spec
+
 from ._base import LinearModelBase, MethodBase
 from ._dge_comparison import DGEEVAL
 from ._edger import EdgeR
-from ._pydeseq2 import PyDESeq2
 from ._simple_tests import SimpleComparisonBase, TTest, WilcoxonTest
-from ._statsmodels import Statsmodels
+
+
+def __getattr__(name: str):
+    deps = {
+        "PyDESeq2": ["pydeseq2", "formulaic_contrasts", "formulaic"],
+        "EdgeR": ["rpy2", "formulaic_contrasts", "formulaic"],
+        "Statsmodels": ["formulaic_contrasts", "formulaic"],
+    }
+
+    if name in deps:
+        for dep in deps[name]:
+            if find_spec(dep) is None:
+                raise ImportError(f"{dep} is required but not installed")
+
+        module_map = {
+            "PyDESeq2": "pertpy.tools._differential_gene_expression._pydeseq2",
+            "EdgeR": "pertpy.tools._differential_gene_expression._edger",
+            "Statsmodels": "pertpy.tools._differential_gene_expression._statsmodels",
+        }
+
+        module = import_module(module_map[name])
+        return getattr(module, name)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def _get_available_methods():
+    methods = [WilcoxonTest, TTest]
+    from importlib.util import find_spec
+
+    for name in ["Statsmodels", "PyDESeq2", "EdgeR"]:
+        with contextlib.suppress(ImportError):
+            methods.append(__getattr__(name))
+
+    return methods
+
+
+AVAILABLE_METHODS = _get_available_methods()
+
+
+AVAILABLE_METHODS = _get_available_methods()
 
 __all__ = [
     "MethodBase",
@@ -15,5 +58,3 @@ __all__ = [
     "WilcoxonTest",
     "TTest",
 ]
-
-AVAILABLE_METHODS = [Statsmodels, EdgeR, PyDESeq2, WilcoxonTest, TTest]

pertpy/tools/_differential_gene_expression/_base.py

@@ -12,7 +12,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import seaborn as sns
-from formulaic_contrasts import FormulaicContrasts
 from lamin_utils import logger
 from matplotlib.pyplot import Figure
 from matplotlib.ticker import MaxNLocator
@@ -881,6 +880,8 @@ class LinearModelBase(MethodBase):
         super().__init__(adata, mask=mask, layer=layer)
         self._check_counts()
 
+        from formulaic_contrasts import FormulaicContrasts
+
         self.formulaic_contrasts = None
         if isinstance(design, str):
             self.formulaic_contrasts = FormulaicContrasts(adata.obs, design)

pertpy/tools/_differential_gene_expression/_edger.py

@@ -23,9 +23,6 @@ class EdgeR(LinearModelBase):
         Args:
             **kwargs: Keyword arguments specific to glmQLFit()
         """
-        # For running in notebook
-        # pandas2ri.activate()
-        # rpy2.robjects.numpy2ri.activate()
         try:
             from rpy2 import robjects as ro
             from rpy2.robjects import numpy2ri, pandas2ri
@@ -47,17 +44,17 @@ class EdgeR(LinearModelBase):
             expr = self.adata.X if self.layer is None else self.adata.layers[self.layer]
             expr = expr.T.toarray() if issparse(expr) else expr.T
 
-        with localconverter(get_conversion() + pandas2ri.converter):
-            expr_r = ro.conversion.py2rpy(pd.DataFrame(expr, index=self.adata.var_names, columns=self.adata.obs_names))
-            samples_r = ro.conversion.py2rpy(self.adata.obs)
+        with localconverter(get_conversion() + pandas2ri.converter) as cv:
+            expr_r = cv.py2rpy(pd.DataFrame(expr, index=self.adata.var_names, columns=self.adata.obs_names))
+            samples_r = cv.py2rpy(self.adata.obs)
 
         dge = edger.DGEList(counts=expr_r, samples=samples_r)
 
         logger.info("Calculating NormFactors")
         dge = edger.calcNormFactors(dge)
 
-        with localconverter(get_conversion() + numpy2ri.converter):
-            design_r = ro.conversion.py2rpy(self.design.values)
+        with localconverter(get_conversion() + numpy2ri.converter) as cv:
+            design_r = cv.py2rpy(self.design.values)
 
         logger.info("Estimating Dispersions")
         dge = edger.estimateDisp(dge, design=design_r)
@@ -100,8 +97,8 @@ class EdgeR(LinearModelBase):
             ) from None
 
         # Convert vector to R, which drops a category like `self.design_matrix` to use the intercept for the left out.
-        with localconverter(get_conversion() + numpy2ri.converter):
-            contrast_vec_r = ro.conversion.py2rpy(np.asarray(contrast))
+        with localconverter(get_conversion() + numpy2ri.converter) as cv:
+            contrast_vec_r = cv.py2rpy(np.asarray(contrast))
         ro.globalenv["contrast_vec"] = contrast_vec_r
 
         # Test contrast with R
@@ -121,8 +118,8 @@ class EdgeR(LinearModelBase):
             return de_res.reset_index().rename(columns={"PValue": "p_value", "logFC": "log_fc", "FDR": "adj_p_value"})
 
         # Convert to Pandas DataFrame if still an R object
-        with localconverter(get_conversion() + pandas2ri.converter):
-            de_res = ro.conversion.rpy2py(de_res)
+        with localconverter(get_conversion() + pandas2ri.converter) as cv:
+            de_res = cv.rpy2py(de_res)
 
         de_res.index.name = "variable"
         de_res = de_res.reset_index()

pertpy/tools/_differential_gene_expression/_pydeseq2.py

@@ -1,6 +1,4 @@
 import os
-import re
-import warnings
 
 import numpy as np
 import pandas as pd

pertpy/tools/_distances/_distance_tests.py

@@ -8,7 +8,7 @@ from rich.progress import track
 from sklearn.metrics import pairwise_distances
 from statsmodels.stats.multitest import multipletests
 
-from ._distances import Distance
+from ._distances import Distance, Metric
 
 if TYPE_CHECKING:
     from anndata import AnnData
@@ -43,7 +43,7 @@ class DistanceTest:
 
     def __init__(
         self,
-        metric: str,
+        metric: Metric,
         n_perms: int = 1000,
         layer_key: str = None,
         obsm_key: str = None,

pertpy/tools/_distances/_distances.py

@@ -34,6 +34,31 @@ class MeanVar(NamedTuple):
     variance: float
 
 
+Metric = Literal[
+    "edistance",
+    "euclidean",
+    "root_mean_squared_error",
+    "mse",
+    "mean_absolute_error",
+    "pearson_distance",
+    "spearman_distance",
+    "kendalltau_distance",
+    "cosine_distance",
+    "r2_distance",
+    "mean_pairwise",
+    "mmd",
+    "wasserstein",
+    "sym_kldiv",
+    "t_test",
+    "ks_test",
+    "nb_ll",
+    "classifier_proba",
+    "classifier_cp",
+    "mean_var_distribution",
+    "mahalanobis",
+]
+
+
 class Distance:
     """Distance class, used to compute distances between groups of cells.
 
@@ -112,7 +137,7 @@ class Distance:
 
     def __init__(
         self,
-        metric: str = "edistance",
+        metric: Metric = "edistance",
         agg_fct: Callable = np.mean,
         layer_key: str = None,
         obsm_key: str = None,
@@ -660,19 +685,19 @@ class MMD(AbstractDistance):
         super().__init__()
         self.accepts_precomputed = False
 
-    def __call__(self, X: np.ndarray, Y: np.ndarray, kernel="linear", **kwargs) -> float:
+    def __call__(self, X: np.ndarray, Y: np.ndarray, *, kernel="linear", gamma=1.0, degree=2, **kwargs) -> float:
         if kernel == "linear":
             XX = np.dot(X, X.T)
             YY = np.dot(Y, Y.T)
             XY = np.dot(X, Y.T)
         elif kernel == "rbf":
-            XX = rbf_kernel(X, X, gamma=1.0)
-            YY = rbf_kernel(Y, Y, gamma=1.0)
-            XY = rbf_kernel(X, Y, gamma=1.0)
+            XX = rbf_kernel(X, X, gamma=gamma)
+            YY = rbf_kernel(Y, Y, gamma=gamma)
+            XY = rbf_kernel(X, Y, gamma=gamma)
         elif kernel == "poly":
-            XX = polynomial_kernel(X, X, degree=2, gamma=1.0, coef0=0)
-            YY = polynomial_kernel(Y, Y, degree=2, gamma=1.0, coef0=0)
-            XY = polynomial_kernel(X, Y, degree=2, gamma=1.0, coef0=0)
+            XX = polynomial_kernel(X, X, degree=degree, gamma=gamma, coef0=0)
+            YY = polynomial_kernel(Y, Y, degree=degree, gamma=gamma, coef0=0)
+            XY = polynomial_kernel(X, Y, degree=degree, gamma=gamma, coef0=0)
         else:
             raise ValueError(f"Kernel {kernel} not recognized.")
 

pertpy/tools/_milo.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import random
 import re
+from importlib.util import find_spec
 from typing import TYPE_CHECKING, Literal
 
 import matplotlib.pyplot as plt
@@ -29,18 +30,6 @@ from sklearn.metrics.pairwise import euclidean_distances
 class Milo:
     """Python implementation of Milo."""
 
-    def __init__(self):
-        try:
-            from rpy2.robjects import conversion, numpy2ri, pandas2ri
-            from rpy2.robjects.packages import STAP, PackageNotInstalledError, importr
-        except ModuleNotFoundError:
-            raise ImportError("milo requires rpy2 to be installed.") from None
-
-        try:
-            importr("edgeR")
-        except ImportError as e:
-            raise ImportError("milo requires a valid R installation with edger installed:\n") from e
-
     def load(
         self,
         input: AnnData,
@@ -266,7 +255,7 @@ class Milo:
         subset_samples: list[str] | None = None,
         add_intercept: bool = True,
         feature_key: str | None = "rna",
-        solver: Literal["edger", "batchglm"] = "edger",
+        solver: Literal["edger", "pydeseq2"] = "edger",
     ):
         """Performs differential abundance testing on neighbourhoods using QLF test implementation as implemented in edgeR.
 
@@ -279,7 +268,9 @@ class Milo:
             subset_samples: subset of samples (obs in `milo_mdata['milo']`) to use for the test.
             add_intercept: whether to include an intercept in the model. If False, this is equivalent to adding + 0 in the design formula. When model_contrasts is specified, this is set to False by default.
             feature_key: If input data is MuData, specify key to cell-level AnnData object.
-            solver: The solver to fit the model to. One of "edger" (requires R, rpy2 and edgeR to be installed) or "batchglm"
+            solver: The solver to fit the model to.
+                The "edger" solver requires R, rpy2 and edgeR to be installed and is the closest to the R implementation.
+                The "pydeseq2" requires pydeseq2 to be installed. It is still very comparable to the "edger" solver but might be a bit slower.
 
         Returns:
             None, modifies `milo_mdata['milo']` in place, adding the results of the DA test to `.var`:
@@ -298,7 +289,6 @@ class Milo:
             >>> milo.make_nhoods(mdata["rna"])
             >>> mdata = milo.count_nhoods(mdata, sample_col="orig.ident")
             >>> milo.da_nhoods(mdata, design="~label")
-
         """
         try:
             sample_adata = mdata["milo"]
@@ -421,17 +411,71 @@ class Milo:
                     res = base.as_data_frame(
                         edgeR.topTags(edgeR.glmQLFTest(fit, coef=n_coef), sort_by="none", n=np.inf)
                     )
+            if res is None:
+                raise ValueError("Unable to generate results with edgeR. Is your installation correct?")
             if not isinstance(res, pd.DataFrame):
                 res = pd.DataFrame(res)
             # The columns of res looks like e.g. table.A, table.B, so remove the prefix
             res.columns = [col.replace("table.", "") for col in res.columns]
-        # Save outputs
+        elif solver == "pydeseq2":
+            if find_spec("pydeseq2") is None:
+                raise ImportError("pydeseq2 is required but not installed. Install with: pip install pydeseq2")
+
+            from pydeseq2.dds import DeseqDataSet
+            from pydeseq2.ds import DeseqStats
+
+            counts_filtered = count_mat[np.ix_(keep_nhoods, keep_smp)]
+            design_df_filtered = design_df.iloc[keep_smp].copy()
+
+            design_df_filtered = design_df_filtered.astype(
+                dict.fromkeys(design_df_filtered.select_dtypes(exclude=["number"]).columns, "category")
+            )
+
+            design_clean = design if design.startswith("~") else f"~{design}"
+
+            dds = DeseqDataSet(
+                counts=pd.DataFrame(counts_filtered.T, index=design_df_filtered.index),
+                metadata=design_df_filtered,
+                design=design_clean,
+                refit_cooks=True,
+            )
+
+            dds.deseq2()
+
+            if model_contrasts is not None and "-" in model_contrasts:
+                if "(" in model_contrasts or "+" in model_contrasts.split("-")[1]:
+                    raise ValueError(
+                        f"Complex contrasts like '{model_contrasts}' are not supported by pydeseq2. "
+                        "Use simple pairwise contrasts (e.g., 'GroupA-GroupB') or switch to solver='edger'."
+                    )
+
+                parts = model_contrasts.split("-")
+                factor_name = design_clean.replace("~", "").split("+")[-1].strip()
+                group1 = parts[0].replace(factor_name, "").strip()
+                group2 = parts[1].replace(factor_name, "").strip()
+                stat_res = DeseqStats(dds, contrast=[factor_name, group1, group2])
+            else:
+                factor_name = design_clean.replace("~", "").split("+")[-1].strip()
+                if not isinstance(design_df_filtered[factor_name], pd.CategoricalDtype):
+                    design_df_filtered[factor_name] = design_df_filtered[factor_name].astype("category")
+                categories = design_df_filtered[factor_name].cat.categories
+                stat_res = DeseqStats(dds, contrast=[factor_name, categories[-1], categories[0]])
+
+            stat_res.summary()
+            res = stat_res.results_df
+
+            res = res.rename(
+                columns={"baseMean": "logCPM", "log2FoldChange": "logFC", "pvalue": "PValue", "padj": "FDR"}
+            )
+
+            res = res[["logCPM", "logFC", "PValue", "FDR"]]
+
         res.index = sample_adata.var_names[keep_nhoods]  # type: ignore
         if any(col in sample_adata.var.columns for col in res.columns):
             sample_adata.var = sample_adata.var.drop(res.columns, axis=1)
         sample_adata.var = pd.concat([sample_adata.var, res], axis=1)
-        # Run Graph spatial FDR correction
-        self._graph_spatial_fdr(sample_adata, neighbors_key=adata.uns["nhood_neighbors_key"])
+
+        self._graph_spatial_fdr(sample_adata)
 
     def annotate_nhoods(
         self,
@@ -488,7 +532,7 @@ class Milo:
 
         anno_frac_dataframe = pd.DataFrame(anno_frac, columns=anno_dummies.columns, index=sample_adata.var_names)
         sample_adata.varm["frac_annotation"] = anno_frac_dataframe.values
-        sample_adata.uns["annotation_labels"] = anno_frac_dataframe.columns
+        sample_adata.uns["annotation_labels"] = anno_frac_dataframe.columns.to_list()
         sample_adata.uns["annotation_obs"] = anno_col
         sample_adata.var["nhood_annotation"] = anno_frac_dataframe.idxmax(1)
         sample_adata.var["nhood_annotation_frac"] = anno_frac_dataframe.max(1)
@@ -674,6 +718,17 @@ class Milo:
         self,
     ):
         """Set up rpy2 to run edgeR."""
+        try:
+            from rpy2.robjects import conversion, numpy2ri, pandas2ri
+            from rpy2.robjects.packages import STAP, PackageNotInstalledError, importr
+        except ModuleNotFoundError:
+            raise ImportError("milo requires rpy2 to be installed.") from None
+
+        try:
+            importr("edgeR")
+        except ImportError as e:
+            raise ImportError("milo requires a valid R installation with edger installed.") from e
+
         from rpy2.robjects.packages import importr
 
         edgeR = self._try_import_bioc_library("edgeR")
@@ -685,26 +740,27 @@ class Milo:
 
     def _try_import_bioc_library(
         self,
-        name: str,
+        r_package: str,
     ):
         """Import R packages.
 
         Args:
-            name (str): R packages name
+            r_package: R packages name
         """
         from rpy2.robjects.packages import PackageNotInstalledError, importr
 
         try:
-            _r_lib = importr(name)
+            _r_lib = importr(r_package)
             return _r_lib
         except PackageNotInstalledError:
-            logger.error(f"Install Bioconductor library `{name!r}` first as `BiocManager::install({name!r}).`")
+            logger.error(
+                f"Install Bioconductor library `{r_package!r}` first as `BiocManager::install({r_package!r}).`"
+            )
             raise
 
     def _graph_spatial_fdr(
         self,
         sample_adata: AnnData,
-        neighbors_key: str | None = None,
     ):
         """FDR correction weighted on inverse of connectivity of neighbourhoods.
 
@@ -712,7 +768,6 @@ class Milo:
 
         Args:
             sample_adata: Sample-level AnnData.
-            neighbors_key: The key in `adata.obsp` to use as KNN graph.
         """
         # use 1/connectivity as the weighting for the weighted BH adjustment from Cydar
         w = 1 / sample_adata.var["kth_distance"]

pertpy/tools/_perturbation_space/_discriminator_classifiers.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-import warnings
-
 import anndata
 import numpy as np
-import pandas as pd
 import scipy
 import torch
 from anndata import AnnData
+from fast_array_utils.conv import to_dense
 from pytorch_lightning import LightningModule, Trainer
 from pytorch_lightning.callbacks import EarlyStopping
 from sklearn.linear_model import LogisticRegression
@@ -112,18 +110,6 @@ class LRClassifierSpace(PerturbationSpace):
         return pert_adata
 
 
-# Ensure backward compatibility with DiscriminatorClassifierSpace
-def DiscriminatorClassifierSpace():
-    warnings.warn(
-        "The DiscriminatorClassifierSpace class is deprecated and will be removed in the future."
-        "Please use the MLPClassifierSpace or the LRClassifierSpace class instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    return MLPClassifierSpace()
-
-
 class MLPClassifierSpace(PerturbationSpace):
     """Fits an ANN classifier to the data and takes the feature space (weights in the last layer) as embedding.
 
@@ -202,7 +188,7 @@ class MLPClassifierSpace(PerturbationSpace):
         labels = adata.obs[target_col].values.reshape(-1, 1)
         encoder = OneHotEncoder()
         encoded_labels = encoder.fit_transform(labels).toarray()
-        adata.obs["encoded_perturbations"] = [np.float32(label) for label in encoded_labels]
+        adata.obsm["encoded_perturbations"] = encoded_labels.astype(np.float32)
 
         # Split the data in train, test and validation
         X = list(range(adata.n_obs))
@@ -226,7 +212,7 @@ class MLPClassifierSpace(PerturbationSpace):
         # Fix class unbalance (likely to happen in perturbation datasets)
         # Usually control cells are overrepresented such that predicting control all time would give good results
         # Cells with rare perturbations are sampled more
-        train_weights = 1 / (1 + torch.sum(torch.tensor(train_dataset.labels.to_list()), dim=1))
+        train_weights = 1 / (1 + torch.sum(torch.tensor(train_dataset.labels), dim=1))
         train_sampler = WeightedRandomSampler(train_weights, len(train_weights))
 
         self.train_dataloader = DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler, num_workers=4)
@@ -278,11 +264,10 @@ class MLPClassifierSpace(PerturbationSpace):
         pert_adata.obs = pert_adata.obs.reset_index(drop=True)
         if "perturbations" in self.adata_obs.columns:
             self.adata_obs = self.adata_obs.drop("perturbations", axis=1)
-        pert_adata.obs = pd.concat([pert_adata.obs, self.adata_obs], axis=1)
-
-        # Drop the 'encoded_perturbations' colums, since this stores the one-hot encoded labels as numpy arrays,
-        # which would cause errors in the downstream processing of the AnnData object (e.g. when plotting)
-        pert_adata.obs = pert_adata.obs.drop("encoded_perturbations", axis=1)
+        obs_subset = self.adata_obs.iloc[: len(pert_adata.obs)].copy()
+        for col in obs_subset.columns:
+            if col not in ["perturbations", "encoded_perturbations"]:
+                pert_adata.obs[col] = obs_subset[col].values
 
         return pert_adata
 
@@ -397,7 +382,13 @@ class PLDataset(Dataset):
         else:
             self.data = adata.X
 
-        self.labels = adata.obs[target_col]
+        if target_col in adata.obs.columns:
+            self.labels = adata.obs[target_col]
+        elif target_col in adata.obsm:
+            self.labels = adata.obsm[target_col]
+        else:
+            raise ValueError(f"Target column {target_col} not found in obs or obsm")
+
         self.pert_labels = adata.obs[label_col]
 
     def __len__(self):
@@ -405,8 +396,8 @@ class PLDataset(Dataset):
 
     def __getitem__(self, idx):
         """Returns a sample and corresponding perturbations applied (labels)."""
-        sample = self.data[idx].toarray().squeeze() if scipy.sparse.issparse(self.data) else self.data[idx]
-        num_label = self.labels.iloc[idx]
+        sample = to_dense(self.data[idx]).squeeze() if scipy.sparse.issparse(self.data) else self.data[idx]
+        num_label = self.labels.iloc[idx] if hasattr(self.labels, "iloc") else self.labels[idx]
         str_label = self.pert_labels.iloc[idx]
 
         return sample, num_label, str_label

pertpy/tools/_perturbation_space/_perturbation_space.py

@@ -80,7 +80,7 @@ class PerturbationSpace:
         group_masks = (
             [(adata.obs[group_col] == sample) for sample in adata.obs[group_col].unique()]
             if group_col
-            else [[True] * adata.n_obs]
+            else [np.array([True] * adata.n_obs)]
         )
 
         if layer_key:

pertpy/tools/_perturbation_space/_simple.py

@@ -161,12 +161,20 @@ class PseudobulkSpace(PerturbationSpace):
                 adata = adata_emb
 
         adata.obs[target_col] = adata.obs[target_col].astype("category")
+        grouping_cols = [target_col] if groups_col is None else [target_col, groups_col]
+        original_obs = adata.obs.copy()
         ps_adata = sc.get.aggregate(
             adata, by=[target_col] if groups_col is None else [target_col, groups_col], func=mode, layer=layer_key
         )
+
         if mode in ps_adata.layers:
             ps_adata.X = ps_adata.layers[mode]
 
+        for col in original_obs.columns:
+            if col not in ps_adata.obs.columns:
+                grouped_values = original_obs.groupby(grouping_cols)[col].first()
+                ps_adata.obs[col] = grouped_values.reindex(ps_adata.obs.index).values
+
         ps_adata.obs[target_col] = ps_adata.obs[target_col].astype("category")
 
         return ps_adata

{pertpy-0.11.5.dist-info → pertpy-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pertpy
-Version: 0.11.5
+Version: 1.0.1
 Summary: Perturbation Analysis in the scverse ecosystem.
 Project-URL: Documentation, https://pertpy.readthedocs.io
 Project-URL: Source, https://github.com/scverse/pertpy
@@ -49,7 +49,7 @@ Requires-Python: <3.14,>=3.11
 Requires-Dist: adjusttext
 Requires-Dist: arviz
 Requires-Dist: blitzgsea
-Requires-Dist: fast-array-utils
+Requires-Dist: fast-array-utils[accel,sparse]
 Requires-Dist: lamin-utils
 Requires-Dist: mudata
 Requires-Dist: openpyxl
@@ -93,7 +93,7 @@ Requires-Dist: sphinxext-opengraph; extra == 'doc'
 Provides-Extra: tcoda
 Requires-Dist: ete4; extra == 'tcoda'
 Requires-Dist: pyqt6; extra == 'tcoda'
-Requires-Dist: toytree; extra == 'tcoda'
+Requires-Dist: toytree>=3.0; extra == 'tcoda'
 Provides-Extra: test
 Requires-Dist: coverage; extra == 'test'
 Requires-Dist: leidenalg; extra == 'test'
@@ -155,7 +155,13 @@ pip install 'pertpy[tcoda]'
 
 ### milo
 
-milo further requires edger, statmod, and rpy2 to be installed:
+milo requires either the "de" extra for the "pydeseq2" solver:
+
+```console
+pip install 'pertpy[de]'
+```
+
+or, edger, statmod, and rpy2 for the "edger" solver:
 
 ```R
 BiocManager::install("edgeR")

{pertpy-0.11.5.dist-info → pertpy-1.0.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-pertpy/__init__.py,sha256=KIxMlqyHlppcGM5Uc2HpTwCEtGFavXRPW50dM5dFB7U,716
+pertpy/__init__.py,sha256=R-RrfgZrhMfn7G60kmTDN88ECqS90AyY9Ed5615hQEg,972
 pertpy/_doc.py,sha256=j5TMNC-DA9yIMqIIUNpjpcVgWfRqyBBfvbRjnCM_OLs,427
 pertpy/_types.py,sha256=IcHCojCUqx8CapibNkcYf2TUqjBFP2ujeELvn_IBSBQ,154
 pertpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pertpy/data/__init__.py,sha256=ah3yvoxkgbdMUNAWxS3SyqcUuVamBOSeuWkF2QRAEwM,2703
-pertpy/data/_dataloader.py,sha256=Osml8irOaoL2n2MhKRKre70Poxiv6NfJBKaK8vRe07Q,4411
+pertpy/data/_dataloader.py,sha256=Cb08iJj7vH-VishU4NJ5nzPPgviFLY1f5p3K4eVvTeg,4679
 pertpy/data/_datasets.py,sha256=4IceyYURpstZSFRrD6gBjoYg8uRbEPo1QLXTt-SwB5k,65507
 pertpy/metadata/__init__.py,sha256=wROPCXmJX2v5schJaBTPQtGW-FGCNWPfO_6bpnXwk-c,276
 pertpy/metadata/_cell_line.py,sha256=hKmaZvjIsQ3wHo__0aKo3JlWvsf8-4OD-gIBNQnW8_E,42716
@@ -16,43 +16,43 @@ pertpy/plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pertpy/preprocessing/__init__.py,sha256=VAPFaeq2_qCvdFkQTCj_Hm460HC4Tersu8Rig_tnp_Y,71
 pertpy/preprocessing/_guide_rna.py,sha256=ijL-bjQ-9qn4r3DlhBxzsqk-bD4RqPsFlok-Otj4hg8,15872
 pertpy/preprocessing/_guide_rna_mixture.py,sha256=pT_YkjmN4iEJ-THBROu_dpbr8E6u8GJw36YoGseikD0,6422
-pertpy/tools/__init__.py,sha256=xjfw3Dd_KGytjjCID0uEs6Fz7DalH46fCjVL2Zf2kOo,2629
+pertpy/tools/__init__.py,sha256=oOhB99SZBx1XUohaqXV7T_hZoN6xf-WMOpqgvw5gn1I,2073
 pertpy/tools/_augur.py,sha256=tc1YKyc0BwzrEGgctsfyy7DsTNKxyvy7ZvWraTWCc1A,55262
 pertpy/tools/_cinemaot.py,sha256=54-rS0AEj31dMe7iU4kEmLoAunq3jNuhsBE3IEp9hrI,38071
-pertpy/tools/_dialogue.py,sha256=mygIZm5i_bnEE37TTQtr1efl_KJq-ejzeL3V1Bmr7Pg,52354
+pertpy/tools/_dialogue.py,sha256=xWW5XiQUEHTvB7WURzndmm-EF4EhLeEnOV_-7NP6heU,52360
 pertpy/tools/_enrichment.py,sha256=55mwotLH9DXQOhl85MCkxXu-MX0RysLyrPheJysAnF0,21369
-pertpy/tools/_milo.py,sha256=zIYG0aP8B39_eiNgpZONhTKmDvcRwCzOLo5FMOTMUms,45530
+pertpy/tools/_milo.py,sha256=PfLgEsYa5i35j25BNgGEkXk9UPM-ZhFxQbEWDA1e_fc,48192
 pertpy/tools/_mixscape.py,sha256=HfrpBeRlxHXaOpZkF2FmX7dg35kUB1rL0_-n2aSi2_0,57905
 pertpy/tools/decoupler_LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 pertpy/tools/transferlearning_MMD_LICENSE,sha256=MUvDA-o_j9htRpI8fStVdCRuyLdPkQUuIH0a_EIc57w,1069
 pertpy/tools/_coda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pertpy/tools/_coda/_base_coda.py,sha256=NjKIQBtTIUENnRmeIC2O8cMdU_9DKaJ5_AHPvFnc8XQ,111744
-pertpy/tools/_coda/_sccoda.py,sha256=0Ret6O56kAfCNOdBvtxqiyuj2rUPp18SV1GVK1AvYGU,22607
+pertpy/tools/_coda/_base_coda.py,sha256=2YIB7rVf9CxwYyQCpC8e3VYCxfurvyAqUs-4qJ5pubg,111817
+pertpy/tools/_coda/_sccoda.py,sha256=FaXn20K4ROYtbrZop_dWRokfwX0vlCizKV02V3Cf7zo,24611
 pertpy/tools/_coda/_tasccoda.py,sha256=BTaOAmL458zQ_og3x4ENlDnJHD6_F4YkdCoXWsF4i1U,30465
-pertpy/tools/_differential_gene_expression/__init__.py,sha256=SEydWg0iT3Y1pApjnCAOuHxFeI6xVUfgyBHv2s3LADU,487
-pertpy/tools/_differential_gene_expression/_base.py,sha256=ELx0e9DChJGO3yRpCLUOykt3oNOyDAPOQZZGSwzBSR0,38265
+pertpy/tools/_differential_gene_expression/__init__.py,sha256=8_u7nsHY5GfFITT0Rs3v1p1vXpsGIWcBzwipuhXM3Ww,1653
+pertpy/tools/_differential_gene_expression/_base.py,sha256=GbBi8o7rTA3wH5DZJ9C1QzfqB5yak4r3xMvKQrizsTY,38274
 pertpy/tools/_differential_gene_expression/_checks.py,sha256=hH_GP0lWGO-5zrCFX4YiIVCZBCuK0ZJ0jFmdlx2Qm4k,1639
 pertpy/tools/_differential_gene_expression/_dge_comparison.py,sha256=LXhp5djKKCAk9VI7OqxOuja849G5lnd8Ehcs9Epk8rg,4159
-pertpy/tools/_differential_gene_expression/_edger.py,sha256=nSHMDA4drGq_sJwUXs5I2EbMHwqjiS08GqOU_1_dXPc,4798
-pertpy/tools/_differential_gene_expression/_pydeseq2.py,sha256=OowFb67jHT-UwibvRolR6Vw_yHEAxQ_ybJ7a65HJg8M,2943
+pertpy/tools/_differential_gene_expression/_edger.py,sha256=P7smGNOIsEF5-zHDP1IPU0vhR5yF9Y54akrZYjjg9H0,4658
+pertpy/tools/_differential_gene_expression/_pydeseq2.py,sha256=dtRgVkfqLlLw-N0-Y8cEJ06KVjr6LIUWJAeDQx4ZA1I,2917
 pertpy/tools/_differential_gene_expression/_simple_tests.py,sha256=SfU8s_P2JzEA1RkmS0_xsARs4-BdnIYAwMmQv9-fxRg,6610
 pertpy/tools/_differential_gene_expression/_statsmodels.py,sha256=90h9EPuoCtNxAbJ1Xq4j_E4yYJJpk64zTP7GyTdmrxY,2220
 pertpy/tools/_distances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pertpy/tools/_distances/_distance_tests.py,sha256=6_nqfHUfKxkI2Yhkzspq3ujMpq56zV_Ddn7bgPzgjyo,13513
-pertpy/tools/_distances/_distances.py,sha256=_XbVU8dlYt_Jl2thYPUWg7HT6OXVe-Ki6qthF566sqQ,50503
+pertpy/tools/_distances/_distance_tests.py,sha256=wDDRkM-WmcfT5m5Zat-3ianGU1aC6HfRy51tuWA_sJg,13524
+pertpy/tools/_distances/_distances.py,sha256=iJNqMc9CxgZfEMHcxIocKGc4X4S2dJsRy3YerxVnFKo,51003
 pertpy/tools/_perturbation_space/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pertpy/tools/_perturbation_space/_clustering.py,sha256=pNx_SpPkZfCbgF7vzHWqAaiiHdbxPaA-L-hTWTbzFhI,3528
 pertpy/tools/_perturbation_space/_comparison.py,sha256=-NzCPRT-IlhJ9hOz7NQLSk0riIzr2C0yZvX6zm3kon4,4291
-pertpy/tools/_perturbation_space/_discriminator_classifiers.py,sha256=a53-YmUwDHQBCT7ZWe_RH7PZsGXvoSHmJaQyL0CBJng,23383
+pertpy/tools/_perturbation_space/_discriminator_classifiers.py,sha256=ARdNatcmsz370CF-PexDHPwUrih7KW4A5URzHVDNrcw,23126
 pertpy/tools/_perturbation_space/_metrics.py,sha256=y8-baP8WRdB1iDgvP3uuQxSCDxA2lcxvEHHM2C_vWHY,3248
-pertpy/tools/_perturbation_space/_perturbation_space.py,sha256=8RxVUkVEPZj5YZ-C-NP5zO4aYYVD04PzlsYuaIG-wjY,19447
-pertpy/tools/_perturbation_space/_simple.py,sha256=AJlHRaEP-vViBeMDvvMtUnXMuIKqZVc7wggnjsHMfMw,12721
+pertpy/tools/_perturbation_space/_perturbation_space.py,sha256=Vyh15wWw9dcu2YUWhziQd2mA9-4IY8EC5dzkBT9HaIo,19457
+pertpy/tools/_perturbation_space/_simple.py,sha256=xS7Lrq3RzJC8IgVKKs2Utqbs7iJ5L1DANquCRcS3Fhg,13109
 pertpy/tools/_scgen/__init__.py,sha256=uERFlFyF88TH0uLiwmsUGEfHfLVCiZMFuk8gO5f7164,45
 pertpy/tools/_scgen/_base_components.py,sha256=Qq8myRUm43q9XBrZ9gBggfa2cSV2wbz_KYoLgH7iF1A,3009
 pertpy/tools/_scgen/_scgen.py,sha256=AQNGsDe-9HEqli3oq7UBDg68ofLCoXm-R_jnLFQ-rlc,30856
 pertpy/tools/_scgen/_scgenvae.py,sha256=bPk4v7EdJc7ROdLuDitHiX_Pvwa7Flw2qHRUwBvjLJY,3889
 pertpy/tools/_scgen/_utils.py,sha256=qz5QUn_Bvk2NGyYVzp3jgjWTFOMt1YyHwUo6HWtoThY,2871
-pertpy-0.11.5.dist-info/METADATA,sha256=YEYgYTHkjmyWyboRL3RhBaSxOw86O5vr0wpXdvaLTGk,8827
-pertpy-0.11.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pertpy-0.11.5.dist-info/licenses/LICENSE,sha256=XuiT2hxeRInhquEIBKMZ5M21n5syhDQ4XbABoposIAg,1100
-pertpy-0.11.5.dist-info/RECORD,,
+pertpy-1.0.1.dist-info/METADATA,sha256=U9XINrPTrqx9UfLIsUt1X9p6LQLvNSV89GGAZnEHnks,8939
+pertpy-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pertpy-1.0.1.dist-info/licenses/LICENSE,sha256=XuiT2hxeRInhquEIBKMZ5M21n5syhDQ4XbABoposIAg,1100
+pertpy-1.0.1.dist-info/RECORD,,