scdesigner 0.0.1__py3-none-any.whl

scdesigner/simulators/composite_regressor.py

@@ -0,0 +1,72 @@
+import anndata
+import pandas as pd
+
+
+class CompositeGLMSimulator:
+    def __init__(self, specification: dict, **kwargs):
+        self.specification = specification
+        self.params = {}
+        self.hyperparams = kwargs
+
+        for k in self.specification:
+            if "_fitted" not in self.specification[k].keys():
+                self.specification[k]["_fitted"] = False
+
+
+    def fit(self, adata: anndata.AnnData) -> dict:
+        self.specification = fill_var_names(self.specification, list(adata.var_names))
+
+        for k, spec in self.specification.items():
+            if not spec["_fitted"]:
+                spec["simulator"].fit(adata[:, spec["var_names"]], spec["formula"])
+            self.params[k] = subset_params(spec["simulator"].params, list(spec["var_names"]))
+            self.specification[k]["simulator"].params = self.params[k]
+            self.specification[k]["_fitted"] = True
+
+    def sample(self, obs: pd.DataFrame) -> anndata.AnnData:
+        anndata_list = []
+        for spec in self.specification.values():
+            anndata_list.append(spec["simulator"].sample(obs))
+        return anndata.concat(anndata_list, axis="var")
+
+    def predict(self, obs: pd.DataFrame) -> dict:
+        preds = {}
+        for k, spec in self.specification.items():
+            preds[k] = spec["simulator"].predict(obs)
+        return preds
+
+    def __repr__(self):
+        var_names = {k: list_string(v["var_names"]) for k, v in self.specification.items()}
+        simulators = {k: v["simulator"] for k, v in self.specification.items()}
+        return f"""scDesigner simulator object with
+    method: 'Composite'
+    features: {var_names}
+    simulators: {simulators}"""
+
+
+def list_string(l):
+    if l is None:
+        return
+    if len(l) <= 3:
+        return ", ".join(l)
+    return f"[{l[0]},{l[1]}, ..., {l[-1]}]"
+
+def fill_var_names(specification, var_names):
+    all_names = []
+    for k, v in specification.items():
+        if v["var_names"] is not None:
+            all_names += list(v["var_names"])
+
+    for k, v in specification.items():
+        if v["var_names"] is None:
+            specification[k]["var_names"] = list(set(var_names) - set(all_names))
+    return specification
+
+def subset_params(params, var_names):
+    result = {}
+    for k, v in params.items():
+        if "covariance" in k:
+            result[k] = v.loc[var_names, var_names]
+        else:
+            result[k] = v.loc[:, var_names]
+    return result

scdesigner/simulators/glm_simulator.py

@@ -0,0 +1,167 @@
+from .. import estimators as est
+from .. import predictors as prd
+from .. import samplers as smp
+from .. import diagnose
+from anndata import AnnData
+import pandas as pd
+from typing import Union
+
+
+def glm_simulator_generator(class_name, regressor, sampler, predictor, diagnose):
+    def __init__(self, **kwargs):
+        self.formula = None # formula should be a string or a dictionary of strings
+        self.params = None
+        self.marginal_aic = None
+        self.marginal_bic = None
+        self.copula_aic = None
+        self.copula_bic = None
+        self.hyperparams = kwargs
+        self.filtered_kwargs = {k: kwargs[k] for k in ["chunk_size", "batch_size"] if k in kwargs}
+
+    if "Copula" not in class_name:
+        # fitting and sampling methods for plain regressors
+        def fit(self, adata: AnnData, formula: Union[str, dict]) -> dict:
+            self.formula = formula
+            self.params = regressor(adata, formula, **self.hyperparams)
+            self.marginal_aic, self.marginal_bic = diagnose(
+                self.params, adata, formula, **self.filtered_kwargs
+            )
+
+        def sample(self, obs: pd.DataFrame) -> AnnData:
+            local_parameters = self.predict(obs) # a dictionary of parameters
+            return sampler(local_parameters, obs)
+
+    else:
+        # fitting and sampling for gaussian copula models
+
+        def fit(
+            self, adata: AnnData, formula: Union[str, dict] = "~ 1", copula_groups: str = None
+        ) -> dict:
+            self.formula = formula
+            self.copula_groups = copula_groups
+            self.params = regressor(adata, formula, copula_groups, **self.hyperparams)
+            self.marginal_aic, self.marginal_bic, self.copula_aic, self.copula_bic = diagnose(
+                self.params, adata, formula, copula_groups, **self.filtered_kwargs
+            )
+
+        def sample(self, obs: pd.DataFrame) -> AnnData:
+            groups = est.gaussian_copula_factory.group_indices(self.copula_groups, obs)
+            local_parameters = self.predict(obs)
+            return sampler(local_parameters, self.params["covariance"], groups, obs)
+
+    def predict(self, obs: pd.DataFrame) -> dict:
+        return predictor(self.params, obs, self.formula)
+        # The predictor function should handle different formula types: dict or string
+
+    def __repr__(self):
+        params_string = ", ".join(
+            [
+                f"{k} [{self.params[k].shape[0]}x{self.params[k].shape[1]}]"
+                for k in self.params.keys()
+            ]
+        )
+        return f"""scDesigner simulator object with
+    method: {self.__class__.__name__}
+    formula: {self.formula}
+    parameters: {params_string}"""
+
+    return type(
+        class_name,
+        (),
+        {
+            "__init__": __init__,
+            "fit": fit,
+            "sample": sample,
+            "predict": predict,
+            "__repr__": __repr__,
+        },
+    )
+
+
+NegBinRegressionSimulator = glm_simulator_generator(
+    "NegBinRegressionSimulator",
+    est.negbin_regression,
+    smp.negbin_sample,
+    prd.negbin_predict,
+    diagnose.negbin_regression_diagnose
+)
+
+NegBinCopulaSimulator = glm_simulator_generator(
+    "NegBinCopulaSimulator",
+    est.negbin_copula, 
+    smp.negbin_copula_sample,
+    prd.negbin_predict,
+    diagnose.negbin_gcopula_diagnose,
+)
+
+PoissonRegressionSimulator = glm_simulator_generator(
+    "PoissonRegressionSimulator",
+    est.poisson_regression,
+    smp.poisson_sample,
+    prd.poisson_predict,
+    diagnose.poisson_regression_diagnose,
+)
+
+PoissonCopulaSimulator = glm_simulator_generator(
+    "PoissonCopulaSimulator",
+    est.poisson_copula,
+    smp.poisson_copula_sample,
+    prd.poisson_predict,
+    diagnose.poisson_gcopula_diagnose,
+)
+
+BernoulliRegressionSimulator = glm_simulator_generator(
+    "BernoulliRegressionSimulator",
+    est.bernoulli_regression,
+    smp.bernoulli_sample,
+    prd.bernoulli_predict,
+    diagnose.bernoulli_regression_diagnose,
+)
+ 
+BernoulliCopulaSimulator = glm_simulator_generator(
+    "BernoulliCopulaSimulator",
+    est.bernoulli_copula,
+    smp.bernoulli_copula_sample,
+    prd.bernoulli_predict,
+    diagnose.bernoulli_gcopula_diagnose,
+)
+
+ZeroInflatedNegBinRegressionSimulator = glm_simulator_generator(
+    "ZeroInflatedNegbinRegressionSimulator",
+    est.zero_inflated_negbin_regression,
+    smp.zero_inflated_negbin_sample,
+    prd.zero_inflated_negbin_predict,
+    diagnose.zinb_regression_diagnose,
+)
+
+ZeroInflatedNegBinCopulaSimulator = glm_simulator_generator(
+    "ZeroInflatedNegBinCopulaSimulator",
+    est.zero_inflated_negbin_copula,
+    smp.zero_inflated_negbin_copula_sample,
+    prd.zero_inflated_negbin_predict,
+    diagnose.zinb_gcopula_diagnose,
+)
+
+ZeroInflatedPoissonRegressionSimulator = glm_simulator_generator(
+    "ZeroInflatedNegbinRegressionSimulator",
+    est.zero_inflated_poisson_regression,
+    smp.zero_inflated_poisson_sample,
+    prd.zero_inflated_poisson_predict,
+    diagnose.zip_regression_diagnose,
+)
+
+GaussianRegressionSimulator = glm_simulator_generator(
+    "GaussianRegressionSimulator",
+    est.gaussian_regression,
+    smp.gaussian_regression_sample,
+    prd.gaussian_predict,
+    diagnose.gaussian_regression_diagnose
+)
+
+GaussianCopulaSimulator = glm_simulator_generator(
+    "GaussianCopulaSimulator",
+    est.gaussian_copula,
+    smp.gaussian_copula_sample,
+    prd.gaussian_predict,
+    diagnose.gaussian_gcopula_diagnose
+)

scdesigner/simulators/pnmf_regression.py

@@ -0,0 +1,61 @@
+from anndata import AnnData
+from formulaic import model_matrix
+from ..format import format_input_anndata, format_matrix
+from scipy.stats import gamma
+from ..estimators.pnmf import pnmf, gamma_regression_array, format_gamma_parameters
+import numpy as np
+import pandas as pd
+
+
+class PNMFRegressionSimulator:
+    def __init__(self, nbase=20, maxIter=100, **kwargs):  # default input: cell x gene
+        self.var_names = None
+        self.formula = None
+        self.params = None
+        self.hyperparams = {"pnmf": {"nbase": nbase, "maxIter": maxIter}, "gamma": kwargs}
+
+    def fit(self, adata, formula: str):
+        adata = format_input_anndata(adata)
+        self.var_names = adata.var_names
+        self.formula = formula
+        log_data = np.log1p(adata.X).T
+        W, S = pnmf(log_data, **self.hyperparams["pnmf"])
+        adata = AnnData(X=S.T, obs=adata.obs)
+
+        x = model_matrix(formula, adata.obs)
+        parameters = gamma_regression_array(np.array(x), adata.X, **self.hyperparams["gamma"])
+        parameters["W"] = W
+        self.params = format_gamma_parameters(
+            parameters, list(self.var_names), list(x.columns)
+        )
+
+    def sample(self, obs: pd.DataFrame) -> AnnData:
+        W = self.params["W"]
+        params = self.predict(obs)
+        a, loc, beta = params["a"], params["loc"], params["beta"]
+        sim_score = gamma(a, loc, 1 / beta).rvs()
+        samples = np.exp(W @ sim_score.T).T
+
+        # thresholding samples
+        floor = np.floor(samples)
+        samples = floor + np.where(samples - floor < 0.9, 0, 1) - 1
+        samples = np.where(samples < 0, 0, samples)
+
+        result = AnnData(X=samples, obs=obs)
+        result.var_names = self.var_names
+        return result
+
+    def predict(self, obs: pd.DataFrame) -> dict:
+        x = format_matrix(obs, self.formula)
+        a, loc, beta = (
+            x @ np.exp(self.params["a"]),
+            x @ self.params["loc"],
+            x @ np.exp(self.params["beta"]),
+        )
+        return {"a": a, "loc": loc, "beta": beta}
+
+    def __repr__(self):
+        return f"""scDesigner simulator object with
+    method: 'PNMF Regression'
+    formula: '{self.formula}'
+    parameters: 'a', 'loc', 'beta', 'W'"""

scdesigner/transform/__init__.py

@@ -0,0 +1,7 @@
+from .nullify import nullify
+from .amplify import amplify
+from .substitute import substitute
+from .split import split_glm
+from .mask import data_frame_mask
+
+__all__ = ["amplify", "nullify", "data_frame_mask", "substitute", "split_glm"]

scdesigner/transform/amplify.py

@@ -0,0 +1,14 @@
+import numpy as np
+from typing import Union
+from copy import deepcopy
+
+
+def amplify(
+    params: dict, id: str, mask: Union[np.array, None] = None, factor: float = 1
+) -> dict:
+    if mask is None:
+        mask = np.ones(params[id].shape)
+
+    result = deepcopy(params)
+    result[id].values[mask] = factor * result[id].values[mask]
+    return result

scdesigner/transform/mask.py

@@ -0,0 +1,33 @@
+import numpy as np
+import re
+
+
+def str_match(string: str, string_list: list) -> bool:
+    for l in string_list:
+        if l in string:
+            return True
+    return False
+
+
+def data_frame_mask(df, row_pattern=".", col_pattern=".") -> np.array:
+    mask = np.zeros(df.shape, dtype=bool)
+    if isinstance(col_pattern, str):
+        col_pattern = [col_pattern]
+    if isinstance(row_pattern, str):
+        row_pattern = [row_pattern]
+
+    # check for columns that match at least one pattern
+    col_matches = np.zeros(df.shape[1], dtype=bool)
+    for col in df.columns:
+        if any(re.search(pat, col) for pat in col_pattern):
+            col_matches[df.columns.get_loc(col)] = True
+
+    # same with rows
+    row_matches = np.zeros(df.shape[0], dtype=bool)
+    for idx in df.index:
+        if any(re.search(pat, str(idx)) for pat in row_pattern):
+            row_matches[df.index.get_loc(idx)] = True
+
+    # set mask to the intersection of row and column matches
+    mask = np.outer(row_matches, col_matches)
+    return mask

scdesigner/transform/nullify.py

@@ -0,0 +1,25 @@
+from typing import Union
+from copy import deepcopy
+import numpy as np
+
+
+def nullify(params: dict, id: str, mask: Union[np.array, None] = None) -> dict:
+    """
+    # fit a model
+    example_sce = anndata.read_h5ad(save_path)
+    x = formulaic.model_matrix("~ bs(pseudotime, degree=2)", example_sce.obs)
+    x = x.to_numpy()
+    y = example_sce.X.todense()
+    params = negative_binomial_copula(x, y)
+
+    # nullify pseudotime for first ten genes
+    outcomes = example_sce.var_names[:10]
+    mask = anndata_formula_mask(outcomes, ["pseudotime], "~ bs(pseudotime, degree=2)", example_sce)
+    null_params = nullify(params, "beta", mask)
+    """
+    if mask is None:
+        mask = np.ones(params[id].shape)
+
+    result = deepcopy(params)
+    result[id][mask] = 0
+    return result

scdesigner/transform/split.py

@@ -0,0 +1,23 @@
+from copy import deepcopy
+from ..simulators import CompositeGLMSimulator
+
+
+def split_glm(simulator, submodel, keys=["group1", "group2"]):
+    initial_model = {
+        "formula": simulator.formula,
+        "simulator": simulator,
+        "var_names": None,
+        "_fitted": True,
+    }
+
+    # default to the formula in original model
+    if not "formula" in submodel:
+        submodel["formula"] = simulator.formula
+
+    # default to the original simulator type, but remove existing parameters
+    if not "simulator" in submodel:
+        submodel["simulator"] = deepcopy(simulator)
+        submodel["simulator"].params = None
+
+    specification = {keys[0]: initial_model, keys[1]: submodel}
+    return CompositeGLMSimulator(specification)

scdesigner/transform/substitute.py

@@ -0,0 +1,14 @@
+import numpy as np
+from copy import deepcopy
+from typing import Union
+
+
+def substitute(
+    params: dict, id: str, new_value: np.array, mask: Union[np.array, None] = None
+) -> dict:
+    if mask is None:
+        mask = np.ones(params[id].shape)
+
+    result = deepcopy(params)
+    result[id][mask] = new_value
+    return result

scdesigner-0.0.1.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: scdesigner
+Version: 0.0.1
+Summary: Interactive simulation for rigorous and transparent multi-omics analysis.
+Project-URL: Homepage, https://github.com/krisrs1128/scDesigner/
+Project-URL: Issues, https://github.com/krisrs1128/scDesigner/Issues/
+Author-email: Kris Sankaran <ksankaran@wisc.edu>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: formulaic
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rich
+Requires-Dist: scanpy
+Requires-Dist: scipy
+Requires-Dist: torch
+Requires-Dist: tqdm
+Description-Content-Type: text/markdown
+
+
+### scDesigner

scdesigner-0.0.1.dist-info/RECORD

@@ -0,0 +1,66 @@
+scdesigner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scdesigner/data/__init__.py,sha256=FvmtbC-bO1wOgqjsDexbH_oTNzYd4XyxQcdRMPtz-_s,562
+scdesigner/data/formula.py,sha256=q1NrD8FkCQqtFLGVmCjTSkpIpIQPlfYasykDylodIWQ,4479
+scdesigner/data/group.py,sha256=XGh1XTXE3BzkS4HGDVAs056TX-EbCk3xMcdGL7akHw4,4151
+scdesigner/data/sparse.py,sha256=lMp8gI8sq_fUTj3HiAmia0YiCdMRS1QGyyRePmuq3zY,1384
+scdesigner/diagnose/__init__.py,sha256=XRBlc0_ns9Tbwq-aMWMIv1c-tcTOgRFQBywBFV46Gt4,3579
+scdesigner/diagnose/aic_bic.py,sha256=9GmtxdEXbbmCvL__pm7jSvQeeCb8KjwawY3UebahVBs,5022
+scdesigner/diagnose/plot.py,sha256=JP1vLbZVnMs171aOBawKbbCUgGiwIfCGKWrQyNh7Y2s,7225
+scdesigner/estimators/__init__.py,sha256=XqtTCAE02FyxMJkbnlg-qi-C_eF-OoOzP2wqa3MJEJ8,907
+scdesigner/estimators/bernoulli.py,sha256=vnIETFbHjXErgkKps4ImgeM5W6nta0c-8-ZetYpqK8g,3324
+scdesigner/estimators/gaussian.py,sha256=-CKumYQWw8KbshdCmCdFgpcH5dNbqY-3vNTXCyjJbqc,4311
+scdesigner/estimators/gaussian_copula_factory.py,sha256=tAX4jABUWNmiheDot74k7yuRlviXwZ0iO7meECbotEM,5391
+scdesigner/estimators/glm_factory.py,sha256=tjVlEfJwBPK_Vk4G4P_eTYnBqeI8Y0r5_u_iSYB7qfA,2618
+scdesigner/estimators/negbin.py,sha256=JCVDIqFe-IfgYSmFz8gAPXFb4PiIaYiFTqNlU42iFZg,4812
+scdesigner/estimators/pnmf.py,sha256=-0WDbwh0uU4V-eyl_0uQ3qLZpT2IuEo9Pa-GEC6vJYI,4781
+scdesigner/estimators/poisson.py,sha256=-B-xXX-XRS22PQUkOTCFiT8HlWtKIXN2WCL_EJtb83w,3365
+scdesigner/estimators/zero_inflated_negbin.py,sha256=OeMbXf20wzhJUmll2meMXBdLfeHGSya2hikmXNRUKI4,7959
+scdesigner/estimators/zero_inflated_poisson.py,sha256=2lrD2H4QMBxhNbak3gDUHVxPBURLS16IyfN5eCEbq9Q,3364
+scdesigner/format/__init__.py,sha256=PR12wZFvixIqHEd--d1oZkuj6o8tAQx-rgnpUKkr03I,179
+scdesigner/format/format.py,sha256=WLsGnfeM52Mg3fhKHwPx0XbkYJSXfehu2_HmQfUpHdY,521
+scdesigner/format/print.py,sha256=HK3yLQcFw-f5-nSxMy52bD8Mixw_xxAYV2W9K4_ULwg,794
+scdesigner/minimal/__init__.py,sha256=IdMK1a2iiYyJ1gsWoupc2_3wyEu3Udjbm_iC0U724kM,378
+scdesigner/minimal/bernoulli.py,sha256=KvkXiS5aOYIT_L_xymaAWd92ZJyRXZowTcOv_b1RsJo,2304
+scdesigner/minimal/composite.py,sha256=H-OzRUzv52F49zw3eM9Bz6HPC4deXQDNr9zTkR_7Xz4,4548
+scdesigner/minimal/copula.py,sha256=VgjOuKgNhKgSnGEt8GXCdjUfIhucymHFTYmAtCn4c5U,1105
+scdesigner/minimal/formula.py,sha256=VFTadNxn-2elBvCkD_yuyh9O-vDZFiitSqjJkZYJy3Y,879
+scdesigner/minimal/gaussian.py,sha256=CKsluKk_XduYMNNUZTtENzH3wf4iTRGRc4L2nzq7qYw,2351
+scdesigner/minimal/kwargs.py,sha256=a32BLKNBj7ont5fR_uUpppYwel55dpP3fqaPeVbmCKM,979
+scdesigner/minimal/loader.py,sha256=gufdcWWKo7MyZQ5e7lzia96ZDKV5Pz8v0WwhZGQEeYM,5947
+scdesigner/minimal/marginal.py,sha256=mxGZH6walwNY8HUqYxp47chPrIysiLEMRacsqAvCxWI,5425
+scdesigner/minimal/negbin.py,sha256=RvReWG50h3LuBBfrHv34AFylcZ8TTjV5WOugR5tBTCg,2572
+scdesigner/minimal/positive_nonnegative_matrix_factorization.py,sha256=oMIC1aqdH4Cgn2pU446lh2-H3axEe-FSC_ZNcgSBrdk,7445
+scdesigner/minimal/scd3.py,sha256=8D8amY7zqSBgyRkrTvYzaf7r9i6mHNtZCCqeopcFbYY,3047
+scdesigner/minimal/scd3_instances.py,sha256=7Jb45VzEkpYegxbzqVlqpb-zMkIXebdiIMEWdZZnRzc,1993
+scdesigner/minimal/simulator.py,sha256=DmeT_uXswR9larJ_OuysXUt32BqIVwxS-2yYMk9PGQw,631
+scdesigner/minimal/standard_covariance.py,sha256=9JlAI9C8bWSGSQRFtBYnKMnoF3UghB0DG08A4piOJ4E,4956
+scdesigner/minimal/transform.py,sha256=FdTOsPoGk3I-M-t8Ugmqx-Znxo0avJs5Os3kCkHotIk,4919
+scdesigner/minimal/zero_inflated_negbin.py,sha256=npDoyAGWs9n5rl3HwvAUvDG9UDG3DlwRMUGwkpeqvlc,3179
+scdesigner/predictors/__init__.py,sha256=3ycFB7ifR2y-27Kx2GhESyfcyZsJ-6ds6vxgzwrl6ss,462
+scdesigner/predictors/bernoulli.py,sha256=ln7GpOTh7nxCVX0nvARPXw0E-l3SalDwur0iUEz-SWQ,261
+scdesigner/predictors/gaussian.py,sha256=R7zhob4AVExAJYGcV51IvjczmlrG5_QmZSFuE3BS2zk,572
+scdesigner/predictors/negbin.py,sha256=B08J_Y5eXbYc9tHH2PZxxnwYXQUaGKmoaAiB1X2wqQw,669
+scdesigner/predictors/poisson.py,sha256=FWrUbzGEbsRmGCV36RjE2AVmbQCgvFXen7yFB6E6JCg,359
+scdesigner/predictors/zero_inflated_negbin.py,sha256=t-lIFsNfzMKdPJFbj8c1B26E6M4_atrCZeUNK4Ujp2s,792
+scdesigner/predictors/zero_inflated_poisson.py,sha256=Krr4r-9vkh7SVy3d45v226NVUYia7AuY6GOEeulMRXI,577
+scdesigner/samplers/__init__.py,sha256=ns3tA_Q7jYIPgnYPfItvHCUpBV9fDimUg0dEHcNB7wE,775
+scdesigner/samplers/bernoulli.py,sha256=1GLOU69_D2sxcedmxC2dIj1MQbmX5D8i0ccvyxjTcR8,791
+scdesigner/samplers/gaussian.py,sha256=H8DwD4XzzALFguxB1uiwUsUURF_G1B6d2j4r0up-srU,943
+scdesigner/samplers/glm_factory.py,sha256=QUtphZEd-hWE8G0e8o98i3ojQqyvucqanrWiMN2oUew,1287
+scdesigner/samplers/negbin.py,sha256=d9oWIDxfXl_kNOPCjYUvtVie3uQmBN6yHfxHbrQiX-I,930
+scdesigner/samplers/poisson.py,sha256=_TxotqGuVDFRXJOIiBGqRE_qJK0XkXn96clkCDCRV1A,789
+scdesigner/samplers/zero_inflated_negbin.py,sha256=Z9kUSEQL8Z-lf48wWBLAuz74FcK7mjsKmeIzyBE9ov4,1287
+scdesigner/samplers/zero_inflated_poisson.py,sha256=rUvUZN9_nUfE7mcbnAA6foKv42owwOdxaEPLyuimxSQ,425
+scdesigner/simulators/__init__.py,sha256=D8xA3aR2FFVMqkYttJPT2FqdKN_PeyweMNVQk9V0w-E,976
+scdesigner/simulators/composite_regressor.py,sha256=eKwTnAOT5l2aIZ0X7AMchz4EEdzElr2NkfugIaAVt7o,2454
+scdesigner/simulators/glm_simulator.py,sha256=c01-5Fo2vvihaof5w_eXCWmMnHyh5TYbj9sIwc7H2tw,5410
+scdesigner/simulators/pnmf_regression.py,sha256=B_fMK7Q9D4q31HT77384EKZEST7XXVNC3v4MNP41Vw0,2214
+scdesigner/transform/__init__.py,sha256=cuLIP0_tocIA3dupO7npH2mLFpL1ApLZlLWPudzPt6M,236
+scdesigner/transform/amplify.py,sha256=aNxpuyoDpXI4xK5FyCaGKqLqUh4SxFCZhwZeW8XonEQ,351
+scdesigner/transform/mask.py,sha256=z-NQ6xcnEzCFWvlfCRhQOrE-TWvtAwQ6Cs8KBPahBSk,1032
+scdesigner/transform/nullify.py,sha256=OjeS9UJA1Cm8LImuGFytIKnA-Oy_qXY_C9NBFMjyjNQ,780
+scdesigner/transform/split.py,sha256=AK3mU52DHSagdyW-d79tsZ12zMKc5xMF_MockUUvciE,741
+scdesigner/transform/substitute.py,sha256=pozV7IVJLyUzJVKeaSX86v0bl9foSFIAQpZ0oC18xak,326
+scdesigner-0.0.1.dist-info/METADATA,sha256=qto7WngpF_FhsA4kruWYo2F1gQv9y3Ze0qdZ_c9WsEo,718
+scdesigner-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scdesigner-0.0.1.dist-info/RECORD,,

scdesigner-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any