edgepython 0.2.0__py3-none-any.whl

edgepython/weighted_lowess.py

@@ -0,0 +1,323 @@
+# This code was written by Claude (Anthropic). The project was directed by Lior Pachter.
+"""Port of limma's weightedLowess C code.
+
+Weighted local regression with delta-based binning to approximately npts
+seed points. Matches the behavior of limma's weighted_lowess() C function
+in src/weighted_lowess.c.
+
+The algorithm:
+1. Sort data by x
+2. Select ~npts seed points spaced at least delta apart
+3. For each seed, find the span window where cumulative weight >= span * total_weight
+4. Fit local weighted linear regression (tricube kernel) at each seed
+5. Linearly interpolate between seeds
+6. Optionally iterate with bisquare robustness weights
+"""
+
+import numpy as np
+from numba import njit
+
+_THRESHOLD = 1e-7
+
+
+def weighted_lowess(x, y, weights=None, span=0.3, iterations=4, npts=200, delta=None):
+    """Weighted lowess smoothing matching limma's C implementation.
+
+    Parameters
+    ----------
+    x : array-like
+        Covariate values.
+    y : array-like
+        Response values.
+    weights : array-like, optional
+        Prior weights (default: all ones).
+    span : float
+        Proportion of total weight to use in each local regression window.
+    iterations : int
+        Total number of fitting passes (1 = no robustness iterations).
+    npts : int
+        Approximate number of seed points for binning.
+    delta : float, optional
+        Minimum distance between seed points. Computed from npts if None.
+
+    Returns
+    -------
+    dict with keys 'fitted', 'residuals', 'weights' (robustness weights), 'delta'.
+    """
+    x = np.asarray(x, dtype=np.float64)
+    y = np.asarray(y, dtype=np.float64)
+    n = len(x)
+
+    if weights is None:
+        weights = np.ones(n, dtype=np.float64)
+    else:
+        weights = np.asarray(weights, dtype=np.float64).copy()
+
+    if n < 2:
+        raise ValueError("Need at least two points")
+
+    # Sort by x (mergesort for stable ordering matching R's order())
+    o = np.argsort(x, kind='mergesort')
+    xs = x[o].copy()
+    ys = y[o].copy()
+    ws = weights[o].copy()
+
+    # Compute delta if not provided (matching R wrapper logic)
+    if delta is None:
+        npts = int(npts + 0.5)
+        if npts >= n:
+            delta = 0.0
+        else:
+            dx = np.sort(np.diff(xs))
+            cumrange = np.cumsum(dx)
+            numclusters = np.arange(npts)
+            # R 1-based to Python 0-based index conversion
+            indices = len(dx) - 1 - numclusters
+            delta = float(np.min(cumrange[indices] / (npts - numclusters)))
+
+    delta = float(delta)
+
+    # Compute total weight and span weight
+    total_weight = np.sum(ws)
+    span_weight = total_weight * span
+    subrange = (xs[-1] - xs[0]) / n
+
+    # Find seed points (binned to ~npts)
+    seed_idx, nseeds = _find_seeds(xs, n, delta)
+
+    # Find span limits for each seed
+    frame_start, frame_end, max_dist = _find_limits(
+        seed_idx, nseeds, xs, ws, n, span_weight)
+
+    # Initialize fitted values and robustness weights
+    fitted = np.zeros(n, dtype=np.float64)
+    rob_w = np.ones(n, dtype=np.float64)
+
+    # Run iterations in compiled code
+    _lowess_iterations(xs, ys, ws, fitted, rob_w, seed_idx, nseeds,
+                       frame_start, frame_end, max_dist, total_weight,
+                       subrange, iterations)
+
+    # Map back to original (unsorted) order
+    fitted_orig = np.empty(n, dtype=np.float64)
+    fitted_orig[o] = fitted
+    rob_orig = np.empty(n, dtype=np.float64)
+    rob_orig[o] = rob_w
+
+    return {
+        'fitted': fitted_orig,
+        'residuals': y - fitted_orig,
+        'weights': rob_orig,
+        'delta': delta
+    }
+
+
+def _find_seeds(xs, n, delta):
+    """Find seed point indices for delta-based binning.
+
+    Always includes first and last points. Interior points are included
+    if they are more than delta away from the last included point.
+    """
+    if delta <= 0 or n <= 2:
+        return np.arange(n, dtype=np.intp), n
+
+    seeds = [0]
+    last_pt = 0
+    for pt in range(1, n - 1):
+        if xs[pt] - xs[last_pt] > delta:
+            seeds.append(pt)
+            last_pt = pt
+    seeds.append(n - 1)
+
+    return np.array(seeds, dtype=np.intp), len(seeds)
+
+
+@njit(cache=True)
+def _find_limits(seed_idx, nseeds, xs, ws, n, span_weight):
+    """Find span window [start, end] and max distance for each seed.
+
+    For each seed point, extends the window left and right (choosing
+    the closer direction each step) until the cumulative weight in the
+    window reaches span_weight. Then extends to include ties.
+    """
+    frame_start = np.empty(nseeds, dtype=np.intp)
+    frame_end = np.empty(nseeds, dtype=np.intp)
+    max_dist = np.empty(nseeds, dtype=np.float64)
+
+    for s in range(nseeds):
+        curpt = seed_idx[s]
+        left = curpt
+        right = curpt
+        cur_w = ws[curpt]
+        at_start = (left == 0)
+        at_end = (right == n - 1)
+        mdist = 0.0
+
+        while cur_w < span_weight and (not at_end or not at_start):
+            if at_end:
+                # Can only extend left
+                left -= 1
+                cur_w += ws[left]
+                if left == 0:
+                    at_start = True
+                ldist = xs[curpt] - xs[left]
+                if mdist < ldist:
+                    mdist = ldist
+            elif at_start:
+                # Can only extend right
+                right += 1
+                cur_w += ws[right]
+                if right == n - 1:
+                    at_end = True
+                rdist = xs[right] - xs[curpt]
+                if mdist < rdist:
+                    mdist = rdist
+            else:
+                # Extend in direction of closer point
+                ldist = xs[curpt] - xs[left - 1]
+                rdist = xs[right + 1] - xs[curpt]
+                if ldist < rdist:
+                    left -= 1
+                    cur_w += ws[left]
+                    if left == 0:
+                        at_start = True
+                    if mdist < ldist:
+                        mdist = ldist
+                else:
+                    right += 1
+                    cur_w += ws[right]
+                    if right == n - 1:
+                        at_end = True
+                    if mdist < rdist:
+                        mdist = rdist
+
+        # Extend to ties
+        while left > 0 and xs[left] == xs[left - 1]:
+            left -= 1
+        while right < n - 1 and xs[right] == xs[right + 1]:
+            right += 1
+
+        frame_start[s] = left
+        frame_end[s] = right
+        max_dist[s] = mdist
+
+    return frame_start, frame_end, max_dist
+
+
+@njit(cache=True)
+def _lowess_fit(xs, ys, ws, rw, curpt, left, right, dist):
+    """Local weighted linear regression at a single point."""
+    threshold = 1e-7
+    allweight = 0.0
+    xmean = 0.0
+    ymean = 0.0
+
+    if dist < threshold:
+        for i in range(left, right + 1):
+            w = ws[i] * rw[i]
+            allweight += w
+        if allweight == 0.0:
+            return 0.0
+        val = 0.0
+        for i in range(left, right + 1):
+            val += ys[i] * ws[i] * rw[i]
+        return val / allweight
+
+    for i in range(left, right + 1):
+        u = abs(xs[curpt] - xs[i]) / dist
+        tricube = (1.0 - u * u * u)
+        tricube = tricube * tricube * tricube
+        w = tricube * ws[i] * rw[i]
+        allweight += w
+        xmean += w * xs[i]
+        ymean += w * ys[i]
+
+    if allweight == 0.0:
+        return 0.0
+
+    xmean /= allweight
+    ymean /= allweight
+
+    var = 0.0
+    covar = 0.0
+    for i in range(left, right + 1):
+        u = abs(xs[curpt] - xs[i]) / dist
+        tricube = (1.0 - u * u * u)
+        tricube = tricube * tricube * tricube
+        w = tricube * ws[i] * rw[i]
+        temp = xs[i] - xmean
+        var += temp * temp * w
+        covar += temp * (ys[i] - ymean) * w
+
+    if var < threshold:
+        return ymean
+
+    slope = covar / var
+    return slope * xs[curpt] + ymean - slope * xmean
+
+
+@njit(cache=True)
+def _lowess_iterations(xs, ys, ws, fitted, rob_w, seed_idx, nseeds,
+                       frame_start, frame_end, max_dist, total_weight,
+                       subrange, iterations):
+    """Run the full lowess iteration loop in compiled code."""
+    n = len(xs)
+    threshold = 1e-7
+
+    for _it in range(iterations):
+        fitted[0] = _lowess_fit(xs, ys, ws, rob_w,
+                                0, frame_start[0], frame_end[0], max_dist[0])
+        last_pt = 0
+        for s in range(1, nseeds):
+            pt = seed_idx[s]
+            fitted[pt] = _lowess_fit(xs, ys, ws, rob_w,
+                                     pt, frame_start[s], frame_end[s],
+                                     max_dist[s])
+            if pt - last_pt > 1:
+                dx_interp = xs[pt] - xs[last_pt]
+                if dx_interp > threshold * subrange:
+                    slope = (fitted[pt] - fitted[last_pt]) / dx_interp
+                    intercept = fitted[pt] - slope * xs[pt]
+                    for j in range(last_pt + 1, pt):
+                        fitted[j] = slope * xs[j] + intercept
+                else:
+                    avg = 0.5 * (fitted[pt] + fitted[last_pt])
+                    for j in range(last_pt + 1, pt):
+                        fitted[j] = avg
+            last_pt = pt
+
+        # Compute absolute residuals
+        abs_resid = np.empty(n)
+        resid_sum = 0.0
+        for i in range(n):
+            abs_resid[i] = abs(ys[i] - fitted[i])
+            resid_sum += abs_resid[i]
+        resid_scale = resid_sum / n
+
+        # Sort residuals
+        ror = np.argsort(abs_resid)
+        sorted_resid = abs_resid[ror]
+
+        cumw = 0.0
+        half_weight = total_weight / 2.0
+        cmad = 0.0
+        for i in range(n):
+            cumw += ws[ror[i]]
+            if cumw == half_weight and i < n - 1:
+                cmad = 3.0 * (sorted_resid[i] + sorted_resid[i + 1])
+                break
+            elif cumw > half_weight:
+                cmad = 6.0 * sorted_resid[i]
+                break
+
+        if cmad <= threshold * resid_scale:
+            break
+
+        for i in range(n):
+            rob_w[i] = 0.0
+        for i in range(n):
+            if sorted_resid[i] < cmad:
+                u = sorted_resid[i] / cmad
+                rob_w[ror[i]] = (1.0 - u * u) * (1.0 - u * u)
+            else:
+                break

edgepython-0.2.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: edgepython
+Version: 0.2.0
+Summary: Python port of the edgeR Bioconductor package for differential expression analysis of digital gene expression data.
+Author: Lior Pachter
+License-Expression: GPL-3.0-or-later
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: statsmodels>=0.13
+Requires-Dist: numba>=0.57
+Provides-Extra: h5
+Requires-Dist: h5py>=3.0; extra == "h5"
+Provides-Extra: anndata
+Requires-Dist: anndata>=0.7; extra == "anndata"
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=8.0; extra == "parquet"
+Provides-Extra: formula
+Requires-Dist: patsy>=0.5; extra == "formula"
+Provides-Extra: all
+Requires-Dist: h5py>=3.0; extra == "all"
+Requires-Dist: anndata>=0.7; extra == "all"
+Requires-Dist: pyarrow>=8.0; extra == "all"
+Requires-Dist: patsy>=0.5; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# edgePython
+
+`edgePython` is a Python implementation of the Bioconductor `edgeR` package for differential analysis of genomics count data. It also includes a new single-cell differential expression method that extends the NEBULA-LN negative binomial mixed model with edgeR's TMM normalization and empirical Bayes dispersion shrinkage.
+
+## Installation
+
+From source:
+
+```bash
+pip install .
+```
+
+With optional extras:
+
+```bash
+pip install .[all]
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import edgepython as ep
+
+# genes x samples count matrix
+counts = np.random.poisson(lam=10, size=(1000, 6))
+group = np.array(["A", "A", "A", "B", "B", "B"])
+
+y = ep.make_dgelist(counts=counts, group=group)
+y = ep.calc_norm_factors(y)
+y = ep.estimate_disp(y)
+
+design = np.column_stack([np.ones(6), (group == "B").astype(float)])
+fit = ep.glm_ql_fit(y, design)
+res = ep.glm_ql_ftest(fit, coef=1)
+top = ep.top_tags(res, n=10)
+print(top["table"].head())
+```
+
+## Features
+
+### Data Structures
+
+`DGEList`-style data structures (`make_dgelist`, `cbind_dgelist`, `rbind_dgelist`, `valid_dgelist`) with accessor functions (`get_counts`, `get_dispersion`, `get_norm_lib_sizes`, `get_offset`).
+
+### Normalization
+
+TMM, TMMwsp, RLE, and upper-quartile normalization via `calc_norm_factors`. Normalized expression values via `cpm`, `rpkm`, `tpm`, `ave_log_cpm`, `cpm_by_group`, and `rpkm_by_group`.
+
+### Filtering
+
+Gene filtering by expression level via `filter_by_expr`.
+
+### Dispersion Estimation
+
+Common, trended, and tagwise dispersion estimation (`estimate_disp`, `estimate_common_disp`, `estimate_trended_disp`, `estimate_tagwise_disp`) with GLM variants (`estimate_glm_common_disp`, `estimate_glm_trended_disp`, `estimate_glm_tagwise_disp`). Weighted likelihood empirical Bayes shrinkage via `WLEB`.
+
+### Differential Expression Testing
+
+- **Exact test**: `exact_test` for two-group comparisons with exact negative binomial tests, plus helpers (`exact_test_double_tail`, `equalize_lib_sizes`, `q2q_nbinom`, `split_into_groups`).
+- **GLM fitting**: `glm_fit`, `glm_ql_fit` for generalized linear model fitting.
+- **GLM testing**: likelihood ratio tests (`glm_lrt`), quasi-likelihood F-tests (`glm_ql_ftest`), and fold-change threshold testing (`glm_treat`).
+- **Results**: `top_tags` for extracting top DE genes with p-value adjustment, `decide_tests` for classifying genes as up/down/unchanged.
+
+### Gene Set Testing
+
+Competitive and self-contained gene set tests: `camera`, `fry`, `roast`, `mroast`, `romer`. Gene ontology and KEGG pathway enrichment via `goana` and `kegga`.
+
+### Differential Splicing
+
+Differential exon and transcript usage testing via `diff_splice` (GLM-based with LRT or QL tests), `diff_splice_dge` (exact test for two-group comparisons), and `splice_variants` (chi-squared tests for homogeneity of proportions across exons).
+
+### Quantification Uncertainty
+
+Reading quantification output with bootstrap or Gibbs sampling uncertainty from Salmon (`catch_salmon`), kallisto (`catch_kallisto`), and RSEM (`catch_rsem`). Overdispersion estimates from quantification uncertainty are used for differential transcript expression following the approach of Baldoni et al. (2024).
+
+### I/O
+
+- **Universal reader**: `read_data` with auto-detection for kallisto (H5/TSV), Salmon, oarfish, RSEM, 10X CellRanger, CSV/TSV count tables, AnnData (`.h5ad`), and RDS files.
+- **Specialized readers**: `read_dge` (collates per-sample count files), `read_10x` (10X Genomics output), `feature_counts_to_dgelist` (featureCounts output), `read_bismark2dge` (Bismark methylation coverage).
+- **Single-cell aggregation**: `seurat_to_pb` for pseudo-bulk aggregation.
+- **Export**: `to_anndata` for converting DGEList and results to AnnData format.
+
+### Visualization
+
+`plot_md` (mean-difference plots), `plot_bcv` (biological coefficient of variation), `plot_mds` (multidimensional scaling), `plot_ql_disp` (quasi-likelihood dispersion), `plot_smear` (smear plots), `ma_plot` (MA plots), and `gof` (goodness of fit).
+
+### Single-Cell Mixed Model
+
+NEBULA-LN-style negative binomial gamma mixed model for multi-subject single-cell data: `glm_sc_fit`, `shrink_sc_disp`, `glm_sc_test`.
+
+### ChIP-Seq
+
+ChIP-seq normalization to matched input controls via `normalize_chip_to_input` and `calc_norm_offsets_for_chip`.
+
+### Methylation/RRBS
+
+Bismark coverage file reader (`read_bismark2dge`) and methylation-specific design matrix construction (`model_matrix_meth`).
+
+### Utilities
+
+Design matrix construction (`model_matrix`), prior count addition (`add_prior_count`), predicted fold changes (`pred_fc`), Good-Turing smoothing (`good_turing`), count thinning/downsampling (`thin_counts`), Gini coefficient (`gini`), sum technical replicates (`sum_tech_reps`), negative binomial z-scores (`zscore_nbinom`), nearest TSS annotation (`nearest_tss`), and variance shrinkage (`squeeze_var`).
+
+## Examples
+
+The [examples/mammary](examples/mammary) directory contains two notebooks for the GSE60450 mouse mammary dataset ([Fu et al. 2015](https://www.nature.com/articles/ncb3117)):
+
+- [mouse_mammary_tutorial.ipynb](examples/mammary/mouse_mammary_tutorial.ipynb) — edgePython-only tutorial (Colab-ready)
+- [mouse_mammary_R_vs_Python.ipynb](examples/mammary/mouse_mammary_R_vs_Python.ipynb) — side-by-side edgeR vs edgePython comparison
+
+The [examples/hoxa1](examples/hoxa1) directory contains two notebooks for the GSE37704 HOXA1 knockdown dataset ([Trapnell et al. 2013](https://doi.org/10.1038/nbt.2594)), with transcript-level quantification by kallisto:
+
+- [hoxa1_tutorial.ipynb](examples/hoxa1/hoxa1_tutorial.ipynb) — edgePython-only tutorial with scaled analysis using bootstrap overdispersion (Colab-ready)
+- [hoxa1_R_vs_Python.ipynb](examples/hoxa1/hoxa1_R_vs_Python.ipynb) — side-by-side edgeR vs edgePython comparison reproducing Figure 1 panels
+
+The [examples/clytia](examples/clytia) directory contains a notebook for the *Clytia hemisphaerica* single-cell RNA-seq dataset ([Chari et al. 2021](https://doi.org/10.1016/j.celrep.2021.109751)), demonstrating the NEBULA-LN mixed model with empirical Bayes dispersion shrinkage:
+
+- [clytia_tutorial.ipynb](examples/clytia/clytia_tutorial.ipynb) — single-cell differential expression of fed vs starved gastrodigestive cells across 10 organisms, reproducing Figure 2 panels (Colab-ready)
+
+## Development
+
+Run tests:
+
+```bash
+pytest -q
+```
+
+## Authorship
+
+This code was written by Claude (Anthropic). The project was directed by Lior Pachter.
+
+## edgeR
+
+`edgePython` is based on the [edgeR](https://bioconductor.org/packages/edgeR/) Bioconductor package. The edgeR publications are:
+
+- Robinson MD, Smyth GK (2007). Moderated statistical tests for assessing differences in tag abundance. *Bioinformatics*, 23(21), 2881-2887. [doi:10.1093/bioinformatics/btm453](https://doi.org/10.1093/bioinformatics/btm453)
+
+- Robinson MD, Smyth GK (2007). Small-sample estimation of negative binomial dispersion, with applications to SAGE data. *Biostatistics*, 9(2), 321-332. [doi:10.1093/biostatistics/kxm030](https://doi.org/10.1093/biostatistics/kxm030)
+
+- Robinson MD, McCarthy DJ, Smyth GK (2010). edgeR: a Bioconductor package for differential expression analysis of digital gene expression data. *Bioinformatics*, 26(1), 139-140. [doi:10.1093/bioinformatics/btp616](https://doi.org/10.1093/bioinformatics/btp616)
+
+- Robinson MD, Oshlack A (2010). A scaling normalization method for differential expression analysis of RNA-seq data. *Genome Biology*, 11(3), R25. [doi:10.1186/gb-2010-11-3-r25](https://doi.org/10.1186/gb-2010-11-3-r25)
+
+- McCarthy DJ, Chen Y, Smyth GK (2012). Differential expression analysis of multifactor RNA-Seq experiments with respect to biological variation. *Nucleic Acids Research*, 40(10), 4288-4297. [doi:10.1093/nar/gks042](https://doi.org/10.1093/nar/gks042)
+
+- Chen Y, Lun ATL, Smyth GK (2014). Differential expression analysis of complex RNA-seq experiments using edgeR. In *Statistical Analysis of Next Generation Sequencing Data*, Springer, 51-74. [doi:10.1007/978-3-319-07212-8_3](https://doi.org/10.1007/978-3-319-07212-8_3)
+
+- Zhou X, Lindsay H, Robinson MD (2014). Robustly detecting differential expression in RNA sequencing data using observation weights. *Nucleic Acids Research*, 42(11), e91. [doi:10.1093/nar/gku310](https://doi.org/10.1093/nar/gku310)
+
+- Dai Z, Sheridan JM, Gearing LJ, Moore DL, Su S, Wormald S, Wilcox S, O'Connor L, Dickins RA, Blewitt ME, Ritchie ME (2014). edgeR: a versatile tool for the analysis of shRNA-seq and CRISPR-Cas9 genetic screens. *F1000Research*, 3, 95. [doi:10.12688/f1000research.3928.2](https://doi.org/10.12688/f1000research.3928.2)
+
+- Lun ATL, Chen Y, Smyth GK (2016). It's DE-licious: A recipe for differential expression analyses of RNA-seq experiments using quasi-likelihood methods in edgeR. In *Statistical Genomics*, Springer, 391-416. [doi:10.1007/978-1-4939-3578-9_19](https://doi.org/10.1007/978-1-4939-3578-9_19)
+
+- Chen Y, Lun ATL, Smyth GK (2016). From reads to genes to pathways: differential expression analysis of RNA-Seq experiments using Rsubread and the edgeR quasi-likelihood pipeline. *F1000Research*, 5, 1438. [doi:10.12688/f1000research.8987.2](https://doi.org/10.12688/f1000research.8987.2)
+
+- Chen Y, Pal B, Visvader JE, Smyth GK (2018). Differential methylation analysis of reduced representation bisulfite sequencing experiments using edgeR. *F1000Research*, 6, 2055. [doi:10.12688/f1000research.13196.2](https://doi.org/10.12688/f1000research.13196.2)
+
+- Baldoni PL, Chen Y, Hediyeh-zadeh S, Liao Y, Dong X, Ritchie ME, Shi W, Smyth GK (2024). Dividing out quantification uncertainty allows efficient assessment of differential transcript expression with edgeR. *Nucleic Acids Research*, 52(3), e13. [doi:10.1093/nar/gkad1167](https://doi.org/10.1093/nar/gkad1167)
+
+- Chen Y, Chen L, Lun ATL, Baldoni PL, Smyth GK (2025). edgeR v4: powerful differential analysis of sequencing data with expanded functionality and improved support for small counts and larger datasets. *Nucleic Acids Research*, 53(2), gkaf018. [doi:10.1093/nar/gkaf018](https://doi.org/10.1093/nar/gkaf018)
+
+The single-cell mixed model in `edgePython` is based on NEBULA:
+
+- He L, Davila-Velderrain J, Sumida TS, Hafler DA, Kellis M, Kulminski AM (2021). NEBULA is a fast negative binomial mixed model for differential or co-expression analysis of large-scale multi-subject single-cell data. *Communications Biology*, 4, 629. [doi:10.1038/s42003-021-02146-6](https://doi.org/10.1038/s42003-021-02146-6)
+
+## License
+
+This project is licensed under the GNU General Public License v3.0.

edgepython-0.2.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+edgepython/__init__.py,sha256=SA-OSJITfGIkrgRKLewTCB3eMTN44t3HkqQjIuYt5h8,2489
+edgepython/classes.py,sha256=tUgpQJFeFdR-48aEYOst0aAMo24eL-LLlXDUbWTgmjQ,16399
+edgepython/compressed_matrix.py,sha256=XugtBswZX_Y8KxRBKe9eDM6FevxVStItw9RNYHYBQ5Q,14768
+edgepython/dgelist.py,sha256=YAi8Sdf1eXdh7e5VUOWXvye9gAr1dF8_kQz0JbGacQU,10682
+edgepython/dispersion.py,sha256=ybA-AQlParEb2GvGJv79me1RXnlc1csgl2uDad7EOBw,31664
+edgepython/dispersion_lowlevel.py,sha256=I-21X-3vdOFo2gWXKLcfNJdonUWzMDxNLXNjpvgUd7g,35368
+edgepython/exact_test.py,sha256=GtWbIpgWOHGuEh6dyPrYL1ASjh56cLCqU6vewcUkEwQ,16461
+edgepython/expression.py,sha256=7QXdle37JSoqCi5TNDLQQo7fT2Av3kSzNjaR_eav8SM,11123
+edgepython/filtering.py,sha256=f5f1imjrNzX3a2m-oI605V3J_D1JIEOlHYr2_DRwXRc,2843
+edgepython/gene_sets.py,sha256=EIi64MDQU7uUuoextCMsuVR8YGWhEGrNDH91JKvKtC0,42208
+edgepython/glm_fit.py,sha256=V5mLHUDSGYyKcQTZRnJMwWzYEfi4gpURFym7Y-kMleg,23250
+edgepython/glm_levenberg.py,sha256=jQkmRtnnYZKj6ZiW_iVxFmgBpvbkdYKzgtP9b8aqAdA,12093
+edgepython/glm_test.py,sha256=QVJHjZrcGqIdULdWVwcO4Qj3fycyX7RLHcoJciYh6mo,12134
+edgepython/io.py,sha256=FjePd6ziup23MCpiCU2ApSsVW0hfpqAHGk3rTKxdLgs,64373
+edgepython/limma_port.py,sha256=sMvphlGWCp-pOrGDDWlPjiS0O3w6BjfaSkHI-4JJ0wM,32453
+edgepython/normalization.py,sha256=5ZIBV1t-XfD7qy-3HNYJ2-wdHYEu59YI2nRkLc_2a6w,18852
+edgepython/ql_weights.py,sha256=XpUEwAS_UYvbFNF-g935jQhzcdfe-UXNkAAuDrx-m-A,68132
+edgepython/results.py,sha256=2M_nNq8efUNp512OGeLZE60XB6_atygSJVwFpmS7Lfc,7197
+edgepython/sc_fit.py,sha256=dN_UcHyFF4wCSwx5pHhorst4qxz96TDDxBD-96aWQd8,48333
+edgepython/smoothing.py,sha256=5rEP0dUKrDr8YaEzekRtJ7tX5Ip3rgBc2lxMywrA9ZU,13751
+edgepython/splicing.py,sha256=Do_JOGxOPawLxj0qQObPgytYBTi9N39tcHlPgYDICDc,19047
+edgepython/utils.py,sha256=mP9wcffw_7cRjPypkKvQFw7kiNj4OCABX5Mrigh4CkE,34647
+edgepython/visualization.py,sha256=VeDeWtSCpPWQ5Pn6oDCWg2gDZMwf4F1yWcEMihMPcR8,12227
+edgepython/weighted_lowess.py,sha256=ldUHZJcKFFY9NdAFeq0pWkJS6e-HgCARAJ5NN7kklc0,10251
+edgepython-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+edgepython-0.2.0.dist-info/METADATA,sha256=pQuv9fwnUvhdwd88yhsHsMymLJLkqQ8XeKxzRlChafo,11674
+edgepython-0.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+edgepython-0.2.0.dist-info/top_level.txt,sha256=XDJV3dwIsV8JKQQDZX0qoQT7Z0iXfwZnjA0PLr_srBU,11
+edgepython-0.2.0.dist-info/RECORD,,

edgepython-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+