pyfauxseq 0.1.0__py3-none-any.whl

pyfauxseq/__init__.py

@@ -0,0 +1,13 @@
+"""Top-level package for Python Implementation of the R Package fauxseq."""
+
+from importlib.metadata import version
+
+from .generate_rnaseq import generate_diffrhythmic_rnaseq, generate_rhythmic_rnaseq
+
+__version__ = version("pyfauxseq")
+
+__all__ = [
+    "generate_diffrhythmic_rnaseq",
+    "generate_rhythmic_rnaseq",
+    "normalize_counts",
+]

pyfauxseq/data/__init__.py

@@ -0,0 +1 @@
+"""Empirically estimated mean-dispersion data to sample from."""

pyfauxseq/estimators.py

@@ -0,0 +1,93 @@
+"""Functions for estimating empirical mean and dispersion of genes.
+
+This module provides:
+- nb_fit: to fit negative binomial model to count data
+- estimate_disp_dist: to estimate dispersion of genes from multiple samples
+"""
+
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures._base import Future
+
+import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
+from pandas.core.series import Series
+from scipy.optimize import minimize
+from scipy.stats import nbinom
+
+from .utils import downsample
+
+
+def nb_fit(x: NDArray) -> pd.Series:
+    """Fit negative binomial parameters to count data.
+
+    Parameters
+    ----------
+    x : ndarray
+        count data
+
+    Returns
+    -------
+    pandas Series
+        mean (mu) and reciprocal of dispersion (size) of count data
+    """
+    if np.var(x) < np.mean(x):
+        return pd.Series({"size": 1e6, "mu": np.mean(x)})
+
+    try:
+        m: float = np.mean(x)
+        v: float = np.var(x)
+
+        def neg_log_likelihood(params):
+            size, mu = params
+            return -np.sum(nbinom.logpmf(x, n=size, p=size / (size + mu)))
+
+        initial_guess: list[float] = [m / (v - m), m]
+        bounds: list[tuple[int, int | float]] = [(0, 1e6), (0, 1e6)]
+        result = minimize(
+            neg_log_likelihood, initial_guess, bounds=bounds, method="L-BFGS-B"
+        )
+
+        if result.success:
+            return pd.Series({"size": result.x[0], "mu": m})
+        else:
+            return pd.Series({"size": np.nan, "mu": np.nan})
+    except Exception:
+        return pd.Series({"size": np.nan, "mu": np.nan})
+
+
+def estimate_disp_dist(
+    counts: NDArray, parallel: bool = True, ncores: int | None = None
+) -> pd.DataFrame:
+    """Estimate mean and dispersion for all samples in data in parallel.
+
+    Parameters
+    ----------
+    counts : ndarray
+        count data matrix
+    parallel : bool, optional
+        should the samples be processed in parallel, by default True
+    ncores : _type_, optional
+        with how many cores, by default None
+
+    Returns
+    -------
+    pandas DataFrame
+        estimates of mean and dispersion for all genes in data
+    """
+    counts: NDArray = downsample(counts, parallel=parallel, ncores=ncores)
+
+    if parallel:
+        if ncores is None:
+            ncores: int = min(32, (os.cpu_count() or 1) + 4)
+        with ThreadPoolExecutor(max_workers=ncores) as executor:
+            futures: list[Future[Series]] = [
+                executor.submit(nb_fit, counts[i, :]) for i in range(counts.shape[0])
+            ]
+            ests: list[Series] = [future.result() for future in as_completed(futures)]
+    else:
+        ests: list[Series] = [nb_fit(counts[i, :]) for i in range(counts.shape[0])]
+
+    final_ests: pd.DataFrame = pd.DataFrame(ests).dropna()
+    return final_ests

pyfauxseq/generate_rnaseq.py

@@ -0,0 +1,415 @@
+"""Functions for generating rhythmic transcriptomic data.
+
+This module currently provides:
+- generate_rhythmic_rnaseq: to generate data under one condition
+- generate_diffrhythmic_rnaseq: to generate data under two conditions
+"""
+
+import numpy as np
+import pandas as pd
+from numpy.random._generator import Generator
+from numpy.typing import ArrayLike, NDArray
+from scipy.stats import nbinom
+
+from .utils import load_dataset
+
+
+def generate_rhythmic_rnaseq(
+    t: ArrayLike = (0, 4, 8, 12, 16, 20),
+    reps: int = 1,
+    period: int = 24,
+    n_genes: int = 10000,
+    rhy_frac: float = 0.1,
+    min_A_effect: float = 0.2,
+    A_spread: float = 0.5,
+    emp_dist: dict | str = "liver",
+    depth: int = 40000000,
+    lib_size_var: tuple[float, float] = (0.8, 1.2),
+    seed=None,
+) -> dict[str, pd.DataFrame]:
+    """Generate synthetic rhythmic RNA-seq count data in one condition.
+
+    This function generates artificial timeseries transcriptomic data under one
+    condition, with rhythmically expressed genes and empirically estimated
+    variability between replicates/samples.
+
+    Parameters
+    ----------
+    t : numpy array-like, optional
+        time points at which samples are generated, by default
+        (0, 4, 8, 12, 16, 20)
+    reps : int or array-like, optional
+        number of replicates at each time point, by default 1
+    period : int, optional
+        period of the rhythmic genes, by default 24
+    n_genes : int, optional
+        number of genes in the dataset, by default 10000
+    rhy_frac : float, optional
+        fraction of genes that are rhythmic, by default 0.1
+    min_A_effect : float, optional
+        minimum amplitude (in log2 fold) of rhythmic genes, by default 0.2
+    A_spread : int, optional
+        mean of the exponential distribution of rhythmic gene amplitudes (in
+        log2 fold), by default 0.5
+    emp_dist : dictionary with keys 'mu' and 'size'| str, optional
+        empirical mean (mu) and size (1/dispersion) values for a corpus of
+        genes or name of a file containing the dictionary, by default "liver"
+        (read from mouse liver dataset)
+    depth : int, optional
+        average sequencing depth of different samples, by default 4e7
+    lib_size_var : tuple of floats, optional
+        window of variability of sequencing depth of samples about 'depth',
+        by default (0.8, 1.2)
+    seed : int, optional
+        seed to ensure reproducible datasets, by default None
+
+    Returns
+    -------
+    dictionary
+        counts: pandas DataFrame (n_genes * n_samples) with count data
+        params: pandas DataFrame (n_rhythmic_genes * 3) with identity of
+        rhythmic genes, and their amplitudes (A) and phases (phi).
+        exp_design: pandas DataFrame (n_samples * 1) with time labels of
+        individual samples
+
+    Raises
+    ------
+    ValueError
+        if 'reps' is not an int or has different length than 't'
+    FileNotFoundError
+        if file containing 'emp_dist' does not exist.
+    ValueError
+        if provided 'emp_dist' is invalid
+
+    Notes
+    -----
+    We extended generative of model of gene expression of Soneson & Delorenz
+    [SD]_ to also include rhythmic genes.
+
+    References
+    ----------
+    .. [SD] Soneson C, Delorenzi M. A comparison of methods for differential
+    expression analysis of RNA-seq data. BMC Bioinformatics. 2013;14: 91.
+    """
+    rng: Generator = np.random.default_rng(seed)
+
+    if not isinstance(reps, int) and (
+        not isinstance(reps, list) or len(reps) != len(t)
+    ):
+        raise ValueError("Length of reps must be 1 or the same as length of t")
+
+    if isinstance(emp_dist, str):
+        match emp_dist:
+            case "liver":
+                emp_dist: pd.DataFrame = load_dataset("Mm_liver_LD_NC.csv.gz")
+            case "multitissue":
+                emp_dist: pd.DataFrame = load_dataset("Mm_multitissue_LD_ALF.csv.gz")
+            case _:
+                emp_dist: pd.DataFrame = load_dataset("Mm_liver_LD_NC.csv.gz")
+    elif not isinstance(emp_dist, pd.DataFrame):
+        raise ValueError("The provided emp_dist is invalid.")
+
+    if emp_dist.shape[1] > 2:
+        group_cols = list(pd.Index.difference(emp_dist.columns, ["size", "mu"]))
+
+        unique_groups = emp_dist[group_cols].drop_duplicates()
+        sampled_row = unique_groups.iloc[rng.choice(len(unique_groups))]
+
+        selected_key = (
+            sampled_row.iloc[0] if len(group_cols) == 1 else tuple(sampled_row)
+        )
+
+        by_param = group_cols[0] if len(group_cols) == 1 else group_cols
+        emp_dist = emp_dist.groupby(by=by_param).get_group(selected_key)
+
+    t: NDArray = np.array(t)
+    t: NDArray = np.repeat(t, reps)
+    N: int = len(t)
+
+    G_rhy: NDArray = rng.uniform(size=n_genes) <= rhy_frac
+
+    A: NDArray = min_A_effect + rng.exponential(A_spread, n_genes)
+
+    A[~G_rhy] = 0.0
+    phi: NDArray = rng.uniform(size=n_genes) * 2 * np.pi * G_rhy
+    params: pd.DataFrame = pd.DataFrame(
+        {
+            "id": [f"g{i + 1}" for i in np.where(G_rhy)[0]],
+            "A": A[G_rhy],
+            "phi": phi[G_rhy],
+        }
+    )
+
+    t_pattern: NDArray = np.cos(phi)[:, None] @ np.cos(
+        2 * np.pi * t[None, :] / period
+    ) + np.sin(phi)[:, None] @ np.sin(2 * np.pi * t[None, :] / period)
+
+    lib_size_fct: NDArray = rng.uniform(lib_size_var[0], lib_size_var[1], N)
+    lib_size: NDArray = lib_size_fct * depth
+
+    draw: NDArray = rng.choice(emp_dist.shape[0], n_genes, replace=True)
+    lambda_: NDArray = emp_dist["mu"].values[draw].reshape(-1, 1)
+
+    size: NDArray = emp_dist["size"].values[draw].reshape(-1, 1)
+
+    lambda_: NDArray = np.repeat(lambda_, N, axis=1) * 2 ** (A[:, None] * t_pattern)
+
+    mu: NDArray = lambda_ / (np.sum(lambda_, axis=0) / lib_size)
+
+    counts: NDArray[np.int_] = nbinom.rvs(
+        n=size, p=size / (mu + size), random_state=seed
+    )
+
+    exp_design = pd.DataFrame(
+        {
+            "time": t,
+        },
+        index=pd.Index(
+            "".join(rng.choice(list("abcdefghijklmnopqrstuvwxyz"), 5)) for _ in range(N)
+        ),
+    )
+
+    return {
+        "counts": pd.DataFrame(
+            counts,
+            index=pd.Index([f"g{i + 1}" for i in range(n_genes)]),
+            columns=exp_design.index,
+        ),
+        "params": params,
+        "exp_design": exp_design,
+    }
+
+
+def generate_diffrhythmic_rnaseq(
+    t: ArrayLike = (0, 4, 8, 12, 16, 20),
+    reps: int = 1,
+    period: int = 24,
+    n_genes: int = 10000,
+    rhy_frac: float = 0.1,
+    DR_probs: ArrayLike = (1.25, 1.25, 1.25, 1.25),
+    min_A_effect: float = 0.2,
+    A_spread: float = 0.5,
+    DE_frac: float = 0.1,
+    min_DE_effect: float = 0.5,
+    DE_spread: float = 0.5,
+    groups: tuple[str, str] = ("ctrl", "expt"),
+    emp_dist: pd.DataFrame | str = "liver",
+    depth: int = 40000000,
+    lib_size_var: tuple[float, float] = (0.8, 1.2),
+    seed=None,
+):
+    """Generate synthetic rhythmic RNA-seq count data in two conditions.
+
+    This function generates artificial timeseries transcriptomic data under two
+    conditions, which includes both differentially rhythmic and differential
+    expressed genes, as well as empirically estimated variability between
+    replicates/samples.
+
+    Parameters
+    ----------
+    t : numpy array, optional
+        time points at which samples are generated, by default
+        np.arange(0, 21, 4)
+    reps : int or array-like, optional
+        number of replicates at each time point, by default 1
+    period : int, optional
+        period of the rhythmic genes, by default 24
+    n_genes : int, optional
+        number of genes in the dataset, by default 10000
+    rhy_frac : float, optional
+        fraction of genes that are rhythmic, by default 0.1
+    DR_probs : numpy array, optional
+        determines the relative average number of ("same", "gain", "loss",
+        "change") group elements. The larger the numbers, more concentrated are
+        the actual numbers around the averages, by default (1.25, 1.25, 1.25,
+        1.25)
+    min_A_effect : float, optional
+        minimum amplitude (in log2 fold) of rhythmic genes, by default 0.2
+    A_spread : float, optional
+        mean of the exponential distribution of rhythmic gene amplitudes (in
+        log2 fold), by default 0.5
+    DE_frac : float, optional
+        fraction of differentially expressed (DE) genes, by default 0.1
+    min_DE_effect : float, optional
+        minimum log2 fold change in expression of DE genes, by default 0.5
+    DE_spread : float, optional
+        mean of the exponential distribution of DE fold changes, by default 0.5
+    groups : tuple, optional
+        labels for the two groups/conditions, by default ("ctrl", "expt")
+    emp_dist : dictionary with keys 'mu' and 'size'| str, optional
+        empirical mean (mu) and size (1/dispersion) values for a corpus of
+        genes or name of a file containing the dictionary, by default "liver"
+        (read from mouse liver dataset)
+    depth : int, optional
+        average sequencing depth of different samples, by default 4e7
+    lib_size_var : tuple of floats, optional
+        window of variability of sequencing depth of samples about 'depth',
+        by default (0.8, 1.2)
+    seed : int, optional
+        seed to ensure reproducible datasets, by default None
+
+    Returns
+    -------
+    dictionary
+        counts: pandas DataFrame (n_genes * n_samples * n_groups) with count
+            data
+        params: pandas DataFrame (n_genes * 7) with identity of gene,
+            differential rhythmicity category, amplitude (A) in two groups, phases
+            (phi) in the two groups, and DE effect size.
+        exp_design: pandas DataFrame ((2*n_samples) * 2) with time labels for
+            individual samples in each group
+
+    Raises
+    ------
+    ValueError
+        if 'reps' is not an int or has different length than 't'
+    FileNotFoundError
+        if file containing 'emp_dist' does not exist.
+    ValueError
+        if provided 'emp_dist' is invalid
+
+    Notes
+    -----
+    We extended the generative of model of differential gene expression of
+    Soneson & Delorenz [SD]_ to also include differentially rhythmic genes.
+
+    References
+    ----------
+    .. [SD] Soneson C, Delorenzi M. A comparison of methods for differential
+    expression analysis of RNA-seq data. BMC Bioinformatics. 2013;14: 91.
+    """
+    rng: Generator = np.random.default_rng(seed)
+
+    if not isinstance(reps, int) and (
+        not isinstance(reps, list) or len(reps) != len(t)
+    ):
+        raise ValueError("Length of reps must be 1 or the same as length of t")
+
+    if isinstance(emp_dist, str):
+        match emp_dist:
+            case "liver":
+                emp_dist: pd.DataFrame = load_dataset("Mm_liver_LD_NC.csv.gz")
+            case "multitissue":
+                emp_dist: pd.DataFrame = load_dataset("Mm_multitissue_LD_ALF.csv.gz")
+            case _:
+                emp_dist: pd.DataFrame = load_dataset("Mm_liver_LD_NC.csv.gz")
+    elif not isinstance(emp_dist, pd.DataFrame):
+        raise ValueError("The provided emp_dist is invalid.")
+
+    if emp_dist.shape[1] > 2:
+        group_cols = list(pd.Index.difference(emp_dist.columns, ["size", "mu"]))
+
+        unique_groups = emp_dist[group_cols].drop_duplicates()
+        sampled_row = unique_groups.iloc[rng.choice(len(unique_groups))]
+
+        selected_key = (
+            sampled_row.iloc[0] if len(group_cols) == 1 else tuple(sampled_row)
+        )
+
+        by_param = group_cols[0] if len(group_cols) == 1 else group_cols
+        emp_dist = emp_dist.groupby(by=by_param).get_group(selected_key)
+
+    t: NDArray = np.repeat(t, reps)
+    N: int = len(t)
+
+    G_rhy: NDArray = rng.uniform(size=n_genes) <= rhy_frac
+    prior_p = rng.gamma(shape=DR_probs, scale=1.0, size=4)
+    prior_p = prior_p / prior_p.sum()
+    DR_counts = rng.multinomial(G_rhy.sum(), prior_p, 1).squeeze()
+    DR_classes = np.array(["gain", "loss", "change", "same"])
+    DR_groups: NDArray = DR_classes[np.repeat(np.arange(4), DR_counts)]
+
+    A: NDArray = min_A_effect + rng.exponential(A_spread, (n_genes, 2))
+    A[~G_rhy, :] = 0.0
+    phi: NDArray = rng.uniform(size=(n_genes, 2)) * 2 * np.pi * G_rhy.reshape(-1, 1)
+
+    G_rhy_index: NDArray = np.where(G_rhy)[0]
+    for i in range(len(DR_groups)):
+        if DR_groups[i] == "gain":
+            A[G_rhy_index[i], 0] = 0.0
+        elif DR_groups[i] == "loss":
+            A[G_rhy_index[i], 1] = 0.0
+        elif DR_groups[i] == "same":
+            A[G_rhy_index[i], 0] = A[G_rhy_index[i], 1]
+            phi[G_rhy_index[i], 0] = phi[G_rhy_index[i], 1]
+
+    params: pd.DataFrame = pd.DataFrame(
+        {
+            "id": [f"g{i + 1}" for i in np.where(G_rhy)[0]],
+            "category": DR_groups,
+            "A_1": A[G_rhy, 0],
+            "A_2": A[G_rhy, 1],
+            "phi_1": phi[G_rhy, 0],
+            "phi_2": phi[G_rhy, 1],
+        }
+    )
+    params.columns: list[str] = [
+        "id",
+        "category",
+        "A_ctrl",
+        "A_expt",
+        "phi_ctrl",
+        "phi_expt",
+    ]
+
+    t_pattern: NDArray = np.hstack(
+        [
+            np.cos(phi[:, [0]]) @ np.cos(2 * np.pi * t[None, :] / period)
+            + np.sin(phi[:, [0]]) @ np.sin(2 * np.pi * t[None, :] / period),
+            np.cos(phi[:, [1]]) @ np.cos(2 * np.pi * t[None, :] / period)
+            + np.sin(phi[:, [1]]) @ np.sin(2 * np.pi * t[None, :] / period),
+        ]
+    )
+
+    G_DE: NDArray = rng.uniform(size=n_genes) <= DE_frac
+    DE_effects: NDArray = (
+        min_DE_effect + rng.exponential(DE_spread, n_genes)
+    ) * np.sign(2 * rng.uniform(size=n_genes) - 1)
+    DE_effects[~G_DE] = 0.0
+    params_de = pd.DataFrame(
+        {
+            "id": [f"g{i + 1}" for i in np.where(G_DE)[0]],
+            "DE_effect": DE_effects[G_DE],
+        }
+    )
+
+    params: pd.DataFrame = pd.merge(
+        params, params_de, on="id", how="outer", validate="one_to_one"
+    )
+
+    lib_size_fct: NDArray = rng.uniform(lib_size_var[0], lib_size_var[1], 2 * N)
+    lib_size: NDArray = lib_size_fct * depth
+
+    draw: NDArray = rng.choice(emp_dist.shape[0], n_genes, replace=True)
+
+    size: NDArray = emp_dist["size"].values[draw].reshape(-1, 1)
+
+    lambda_: NDArray = emp_dist["mu"].values[draw].reshape(-1, 1)
+
+    DE_effects: NDArray = np.hstack([np.ones((n_genes, 1)), DE_effects.reshape(-1, 1)])
+
+    lambda_: NDArray = np.repeat(lambda_, 2 * N, axis=1) * 2 ** (
+        DE_effects[:, np.repeat([0, 1], N)] + A[:, np.repeat([0, 1], N)] * t_pattern
+    )
+
+    mu: NDArray = lambda_ / (np.sum(lambda_, axis=0) / lib_size)
+
+    counts: NDArray = nbinom.rvs(n=size, p=size / (mu + size), random_state=seed)
+
+    exp_design: pd.DataFrame = pd.DataFrame(
+        {"time": np.tile(t, 2), "group": np.repeat(groups, N)},
+        index=pd.Index(
+            "".join(rng.choice(list("abcdefghijklmnopqrstuvwxyz"), 5))
+            for _ in range(2 * N)
+        ),
+    )
+
+    return {
+        "counts": pd.DataFrame(
+            counts,
+            index=pd.Index([f"g{i + 1}" for i in range(n_genes)]),
+            columns=exp_design.index,
+        ),
+        "params": params,
+        "exp_design": exp_design,
+    }

pyfauxseq/utils.py

@@ -0,0 +1,161 @@
+"""Utility functions to downsample and normalize count data.
+
+This module provides:
+- drop_counts: to downsample counts to a certain depth
+- downsample: to downsample counts in multiple samples to a common depth
+- load_dataset: to load csv data
+- normalize_counts: to normalize count data using median of ratios
+- median_of_ratios: to estimate median of ratios for the samples
+"""
+
+import importlib.resources
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures._base import Future
+
+import numpy as np
+import pandas as pd
+from numpy.typing import NDArray
+
+from pyfauxseq import data
+
+
+def drop_counts(y: NDArray, N: int) -> NDArray[np.int_]:
+    """Downsample count data for a single sample such that total counts equals N.
+
+    Parameters
+    ----------
+    y : array-like
+        count data for one sample
+    N : int
+        target total counts
+
+    Returns
+    -------
+    array
+        downsampled counts
+
+    Raises
+    ------
+    ValueError
+        if target counts exceeds actual sum of counts
+    """
+    total: int = np.sum(y)
+
+    if total < N:
+        raise ValueError("N is larger than the total counts.")
+
+    if total == N:
+        return y
+    else:
+        all_reads: NDArray = np.repeat(np.arange(y.shape[0]), y)
+        removed: NDArray = np.random.choice(all_reads, N, replace=False)
+        return np.bincount(removed, minlength=y.shape[0])
+
+
+def downsample(
+    counts: NDArray, parallel: bool = True, ncores: int | None = None
+) -> NDArray[np.int_]:
+    """Downsample multiple samples in parallel.
+
+    Parameters
+    ----------
+    counts : ndarray
+        count data to be downsampled (n_genes * n_samples)
+    parallel : bool, optional
+        should samples be processed in parallel, by default True
+    ncores : int | None, optional
+        number of cores to be used, by default None (use all available)
+
+    Returns
+    -------
+    ndarray
+        downsampled count data matrix
+    """
+    min_lib_size: float = np.min(np.sum(counts, axis=0))
+
+    if parallel:
+        if ncores is None:
+            ncores: int = min(32, (os.cpu_count() or 1) + 4)
+        with ThreadPoolExecutor(max_workers=ncores) as executor:
+            futures: list[Future] = [
+                executor.submit(drop_counts, counts[:, i], min_lib_size)
+                for i in range(counts.shape[1])
+            ]
+            downsampled_counts: NDArray = np.column_stack(
+                [future.result() for future in as_completed(futures)]
+            )
+    else:
+        downsampled_counts: NDArray = np.column_stack(
+            [drop_counts(counts[:, i], min_lib_size) for i in range(counts.shape[1])]
+        )
+
+    return downsampled_counts
+
+
+def load_dataset(filename: str) -> pd.DataFrame:
+    """Read data from files (currently only csv supported).
+
+    Parameters
+    ----------
+    filename : str
+        filename to be read
+
+    Returns
+    -------
+    pandas DataFrame
+        file contents as a DataFrame
+
+    Raises
+    ------
+    ValueError
+        if unsupported file format (not csv)
+    """
+    with importlib.resources.path(data, filename) as data_path:
+        if ".csv" in filename:
+            return pd.read_csv(data_path)
+        else:
+            raise ValueError("Unsupported file format")
+
+
+def normalize_counts(counts: pd.DataFrame, log: bool = True) -> pd.DataFrame:
+    """Normalize counts using median of ratios with optional log transform.
+
+    Parameters
+    ----------
+    counts : pandas DataFrame
+        count data to be normalized
+    log : bool, optional
+        should the normalized counts be log2 transformed, by default True
+
+    Returns
+    -------
+    pandas DataFrame
+        normalized count data
+    """
+    norm_counts: pd.DataFrame = (
+        counts / np.sum(counts, axis=0) / median_of_ratios(counts) * 1e6
+    )
+    if log:
+        norm_counts: pd.DataFrame = np.log2(1 + norm_counts)
+    return norm_counts
+
+
+def median_of_ratios(counts: pd.DataFrame) -> NDArray:
+    """Compute median of ratios for each sample.
+
+    Parameters
+    ----------
+    counts : pandas DataFrame
+        count data matrix (n_genes * n_samples)
+
+    Returns
+    -------
+    ndarray
+        median of ratios
+    """
+    counts: NDArray = counts.to_numpy()
+    return 2 ** np.ma.median(
+        np.ma.log2(counts) - np.ma.mean(np.ma.log2(counts), axis=1, keepdims=True),
+        axis=0,
+    )

pyfauxseq-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pyfauxseq
+Version: 0.1.0
+Summary: This package can generate synthetic timeseries RNA-seq data with a fraction of rhythmic genes and empirical relationship between mean expression and variability across replicates of genes.
+Project-URL: bugs, https://github.com/bharathananth/pyfauxseq/issues
+Project-URL: homepage, https://github.com/bharathananth/pyfauxseq
+Project-URL: documentation, https://bharathananth.github.io/pypfauxseq
+Author-email: Bharath Ananthasubramaniam <bharath.ananthasubramaniam@hu-berlin.de>
+Maintainer-email: Bharath Ananthasubramaniam <bharath.ananthasubramaniam@hu-berlin.de>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == 'docs'
+Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: mkdocstrings-python; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: coverage; extra == 'test'
+Requires-Dist: hypothesis; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Requires-Dist: ty; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pyfauxseq
+### A python Implementation of the R package fauxseq
+
+![PyPI - Version](https://img.shields.io/pypi/v/pyfauxseq)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/pyfauxseq)
+![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/bharathananth/pyfauxseq/total)
+
+## What pyfauxseq does
+
+This package can generate synthetic timeseries RNA-seq data with a fraction of rhythmic genes and empirical relationship between mean expression and variability across replicates of genes.
+
+`pyfauxseq` improves upon previous tools as follows:
+- generates negative-binomial count data with empirically-estimated mean-dispersion properties.
+- generates data with either differential expression or differential rhythmicity or both.
+
+## How to install pyfauxseq
+```python -m pip install pyfauxseq```
+
+## Get started with pyfauxseq
+Get started with synthetic RNA-seq data with the ground truth with the default parameters using
+```python
+import pyfauxseq as pf
+sim_data = pf.generate_rhythmic_rnaseq()
+sim_data["counts"] # the count data
+sim_data["params"] # parameters of the rhythmic genes
+sim_data["exp_design"] # time labels of the individual sample (columns) of count data
+```
+## How to cite pyfauxseq
+Please cite this software using CITATION.CFF or the "Cite this repository" link in the right sidebar.
+
+## Credits
+
+This package was created with [Cookiecutter](https://github.com/audreyfeldroy/cookiecutter) and the [audreyfeldroy/cookiecutter-pypackage](https://github.com/audreyfeldroy/cookiecutter-pypackage) project template.

pyfauxseq-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyfauxseq/__init__.py,sha256=_okOASUW014T2OEVG00Ck1ByqSvSADvIM-TV8doxLBs,344
+pyfauxseq/estimators.py,sha256=hZq57SGqzTbSkZ-sDW1DGxSZ54KS9LHSI1XYvEizw6k,2833
+pyfauxseq/generate_rnaseq.py,sha256=QxrC_9CFyf8nPPfIVR17lQQwj0IBR0PSZ37A5gl2Fm0,15078
+pyfauxseq/utils.py,sha256=dY8AvDfH-x8xWUEl9QXZvf-n6HaOFlgEdk5iygUOdxc,4373
+pyfauxseq/data/Mm_liver_LD_NC.csv.gz,sha256=TVJpEUt4hhgw8J4RBo3nv5l0pWRVDU2Wjpa8CMSc3X0,179263
+pyfauxseq/data/Mm_multitissue_LD_ALF.csv.gz,sha256=sD9oLmUj1NpUeDDRaH_k8wtY82MpxHPCw2WxnT9LhlI,615681
+pyfauxseq/data/Mm_multitissue_LD_ALF.json.gz,sha256=yCGE5GMRf09D7uw-Q6kb8V5mo3DVklYra345PsVoZyg,307165
+pyfauxseq/data/__init__.py,sha256=SnUIMg2StvU_Ut0Uskz98wRzyerh9HGionlsfoKrZHs,65
+pyfauxseq-0.1.0.dist-info/METADATA,sha256=D12aWFs5HbPn78zzGgF30NMnHnKRdKrmpW-FYaL0ZLc,3107
+pyfauxseq-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pyfauxseq-0.1.0.dist-info/licenses/LICENSE,sha256=shsJDDj0UNAzs_W2RC9eOKWWAX8BYLpPQuOI6qElzeQ,1084
+pyfauxseq-0.1.0.dist-info/RECORD,,

pyfauxseq-0.1.0.dist-info/WHEEL

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

pyfauxseq-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Bharath Ananthasubramaniam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.