scdesigner 0.0.5__py3-none-any.whl → 0.0.10__py3-none-any.whl

scdesigner/samplers/negbin.py

@@ -1,25 +0,0 @@
-from scipy.stats import nbinom
-from . import glm_factory as glm
-from typing import Union
-import numpy as np
-
-
-def negbin_regression_sample_array(local_parameters: dict) -> np.array:
-    r, mu = local_parameters["dispersion"], local_parameters["mean"] # dataframes of shape (n, g)
-    return nbinom(n=r, p=r / (r + mu)).rvs()
-
-
-def negbin_copula_sample_array(
-    local_parameters: dict, covariance: Union[dict, np.array], groups: dict
-) -> np.array:
-    # initialize uniformized gaussian samples
-    N, G = local_parameters["mean"].shape
-    u = glm.gaussian_copula_pseudo_obs(N, G, covariance, groups)
-
-    # transform the correlated uniforms to NB space
-    r, mu = local_parameters["dispersion"], local_parameters["mean"]
-    return nbinom(n=r, p=r / (r + mu)).ppf(u)
-
-
-negbin_sample = glm.glm_sample_factory(negbin_regression_sample_array)
-negbin_copula_sample = glm.gaussian_copula_sample_factory(negbin_copula_sample_array)

scdesigner/samplers/poisson.py

@@ -1,25 +0,0 @@
-from . import glm_factory as glm
-from scipy.stats import poisson
-from typing import Union
-import numpy as np
-
-
-def poisson_regression_sample_array(local_parameters: dict) -> np.array:
-    mu = local_parameters["mean"]
-    return poisson(mu).rvs()
-
-
-def poisson_copula_sample_array(
-    local_parameters: dict, covariance: Union[dict, np.array], groups: dict
-) -> np.array:
-    # initialize uniformized gaussian samples
-    N, G = local_parameters["mean"].shape
-    u = glm.gaussian_copula_pseudo_obs(N, G, covariance, groups)
-
-    # invert using poisson margins
-    mu = local_parameters["mean"]
-    return poisson(mu).ppf(u)
-
-
-poisson_sample = glm.glm_sample_factory(poisson_regression_sample_array)
-poisson_copula_sample = glm.gaussian_copula_sample_factory(poisson_copula_sample_array)

scdesigner/samplers/zero_inflated_negbin.py

@@ -1,40 +0,0 @@
-from scipy.stats import nbinom, bernoulli
-from . import glm_factory as glm
-from typing import Union
-import numpy as np
-
-
-def zero_inflated_negbin_sample_array(local_parameters: dict) -> np.array:
-    mu, r, pi = (
-        local_parameters["mean"],
-        local_parameters["dispersion"],
-        local_parameters["zero_inflation"],
-    )
-    return nbinom(n=r, p=r / (r + mu)).rvs() * bernoulli(1 - pi).rvs()
-
-
-def zero_inflated_negbin_copula_sample_array(
-    local_parameters: dict, covariance: Union[dict, np.array], groups: dict
-) -> np.array:
-    # initialize uniformized gaussian samples
-    N, G = local_parameters["mean"].shape
-    u = glm.gaussian_copula_pseudo_obs(N, G, covariance, groups)
-
-    # get zero inflated NB parameters
-    mu, r, pi = (
-        local_parameters["mean"],
-        local_parameters["dispersion"],
-        local_parameters["zero_inflation"],
-    )
-
-    # zero inflate after first simulating from NB
-    positive_part = nbinom(n=r, p=r / (r + mu)).ppf(u)
-    zero_inflation = bernoulli(1 - pi).ppf(u)
-    return zero_inflation * positive_part
-
-
-zero_inflated_negbin_sample = glm.glm_sample_factory(zero_inflated_negbin_sample_array)
-
-zero_inflated_negbin_copula_sample = glm.gaussian_copula_sample_factory(
-    zero_inflated_negbin_copula_sample_array
-)

scdesigner/samplers/zero_inflated_poisson.py

@@ -1,16 +0,0 @@
-from scipy.stats import poisson, bernoulli
-from . import glm_factory as glm
-import numpy as np
-
-
-def zero_inflated_poisson_sample_array(local_parameters: dict) -> np.array:
-    mu, pi = (
-        local_parameters["mean"],
-        local_parameters["zero_inflation"],
-    )
-    return poisson(mu).rvs() * bernoulli(1 - pi).rvs()
-
-
-zero_inflated_poisson_sample = glm.glm_sample_factory(
-    zero_inflated_poisson_sample_array
-)

scdesigner/simulators/composite_regressor.py

@@ -1,72 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/amplify.py

@@ -1,14 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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, dtype=bool)
-
-    result = deepcopy(params)
-    result[id][mask] = 0
-    return result

scdesigner/transform/split.py

@@ -1,23 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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.5.dist-info/RECORD

@@ -1,66 +0,0 @@
-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=TDkbc25TvXJp5O4_U2QipM8tmEoJ0HpNG53rlYthsBk,1221
-scdesigner/estimators/bernoulli.py,sha256=vnIETFbHjXErgkKps4ImgeM5W6nta0c-8-ZetYpqK8g,3324
-scdesigner/estimators/gaussian.py,sha256=-CKumYQWw8KbshdCmCdFgpcH5dNbqY-3vNTXCyjJbqc,4311
-scdesigner/estimators/gaussian_copula_factory.py,sha256=yeIx_C2fN2jiotTkJstV4pjQYW4aO6RJ-jMuuXR2HVs,14054
-scdesigner/estimators/glm_factory.py,sha256=tjVlEfJwBPK_Vk4G4P_eTYnBqeI8Y0r5_u_iSYB7qfA,2618
-scdesigner/estimators/negbin.py,sha256=4q_XZOZA8gYHXOOY5Mz17cexs-kzadqB9JlxqWnZ7VQ,5639
-scdesigner/estimators/pnmf.py,sha256=-0WDbwh0uU4V-eyl_0uQ3qLZpT2IuEo9Pa-GEC6vJYI,4781
-scdesigner/estimators/poisson.py,sha256=FMYtkip2NDYmmkyEuO_9hSuM6gtM-AZpPa9GwFrFfD8,4174
-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=lOafmycSpW5U7Yrmm_NgRJx8Y9GvkuS0BVf8IGFse9c,4536
-scdesigner/minimal/copula.py,sha256=nNnK9Pxrp4-jlYWFY4NBt0hiUXGVHjMQMH5P5EhxLVw,8884
-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=N6bFyRkJGkpi1NIHU9gwfJTbBP_Z51p6tX2ymxML5Fk,7483
-scdesigner/minimal/marginal.py,sha256=5SB1biCpO8PzMb_--mzBdpTHrnbTEt0BMp7188afxd0,5790
-scdesigner/minimal/negbin.py,sha256=NorV0CQ_wmKwTWuWd-Y1mE3gWYmVPHgmjp3pgI86bEI,2563
-scdesigner/minimal/positive_nonnegative_matrix_factorization.py,sha256=oMIC1aqdH4Cgn2pU446lh2-H3axEe-FSC_ZNcgSBrdk,7445
-scdesigner/minimal/scd3.py,sha256=4EKi6Wonc0LRfWjLdvn8HMhbuR-c5kZbmVNLGbJd7mw,3083
-scdesigner/minimal/scd3_instances.py,sha256=vbCbF_SbCqyCUdi_STwV2ufn9ouoEk14_D9g4Wc9O14,1969
-scdesigner/minimal/simulator.py,sha256=DmeT_uXswR9larJ_OuysXUt32BqIVwxS-2yYMk9PGQw,631
-scdesigner/minimal/standard_copula.py,sha256=_NHCKL90eR7oHmgYtZAC9dyZDBKqYj987nrUxYoDAtM,16204
-scdesigner/minimal/transform.py,sha256=j2sj2vHpFi3YdK9sz4Npl05i8UPGBcDU3kT-n72u28s,5459
-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=aQvFTgBKAk7kV-SnFJ61aSHQGwemxW9Hl4ZXBmwGJug,3607
-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=pEtYNDVT2Z_BmVc5CKl3CoxB37KOvqMReoQGnvFYMKE,792
-scdesigner/transform/split.py,sha256=AK3mU52DHSagdyW-d79tsZ12zMKc5xMF_MockUUvciE,741
-scdesigner/transform/substitute.py,sha256=pozV7IVJLyUzJVKeaSX86v0bl9foSFIAQpZ0oC18xak,326
-scdesigner-0.0.5.dist-info/METADATA,sha256=SykpXsuJatehhOj2nFtqVrW5o82d5JEij4r6ndCEf_8,741
-scdesigner-0.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scdesigner-0.0.5.dist-info/RECORD,,