exprmat 0.1.8__tar.gz → 0.1.9__tar.gz

{exprmat-0.1.8 → exprmat-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.1.8
+Version: 0.1.9
 Summary: routines to process expression matrices
 Home-page: https://github.com/yang-z-03/exprmat
 Author: Zheng Yang

{exprmat-0.1.8 → exprmat-0.1.9}/exprmat/data/geneset.py

@@ -28,8 +28,7 @@ def get_genesets(taxa, name, identifier = 'entrez'):
         lines = gfile.read().splitlines()
     
     gene_set = {}
-    import tqdm
-    for line in tqdm.tqdm(lines, ncols = 80):
+    for line in lines:
         
         if len(line.strip()) == 0: continue
         if line.startswith('#'): continue
@@ -53,6 +52,9 @@ def get_genesets(taxa, name, identifier = 'entrez'):
 
 def translate_id(taxa, genes, idfrom = 'entrez', idto = 'ugene', keep_nones = True):
 
+    if not taxa in genome.keys():
+        get_genome(taxa)
+
     # setup the conversion table cache
     if not 'conversion' in genome[taxa].keys():
 
@@ -86,6 +88,8 @@ def translate_id(taxa, genes, idfrom = 'entrez', idto = 'ugene', keep_nones = Tr
     
     else:
         result = []
+        froms = gtable[idfrom].tolist()
+        tos = gtable[idto].tolist()
         for x in genes:
             if x in froms:
                 t = tos[froms.index(x)]

{exprmat-0.1.8 → exprmat-0.1.9}/exprmat/descriptive/gse.py

@@ -45,14 +45,44 @@ def gse(
 
     import gseapy as gp
     import pandas as pd
+
+    prernk = pd.DataFrame({
+        'gene': translate_id(taxa, names, 'ugene', identifier, keep_nones = True),
+        'lfc': input_gnames['lfc'].tolist()
+    })
+
+    prernk = prernk.loc[~ prernk['gene'].duplicated(), :].copy()
+    prernk = prernk.loc[~ prernk['gene'].isna(), :].copy()
     gsea = gp.prerank(
-        pd.DataFrame({
-            'gene': translate_id(taxa, names, 'ugene', identifier, keep_nones = False),
-            'lfc': input_gnames['lfc'].tolist()
-        }),
+        rnk = prernk,
         gene_sets = get_genesets(taxa = taxa, name = gene_sets, identifier = identifier)
     )
 
-    # adata.uns[key_added] = gsea.results
-    # adata.uns[key_added + '.table'] = gsea.res2d
-    return gsea
+    adata.uns[key_added] = {
+        'config': {
+            'module': gsea.module,
+            'ranking.key': np.array(gsea.ranking.index.tolist()),
+            'ranking.value': np.array(gsea.ranking.values),
+            'seed': gsea.seed,
+            'negative': gsea.pheno_neg,
+            'positive': gsea.pheno_pos
+        },
+        'results': {}
+    }
+
+    for k in gsea.results.keys():
+        adata.uns[key_added]['results'][k] = {
+            'name': gsea.results[k]['name'],
+            'es': gsea.results[k]['es'],
+            'res': np.array(gsea.results[k]['RES']),
+            'nes': gsea.results[k]['nes'],
+            'p': gsea.results[k]['pval'],
+            'fdr': gsea.results[k]['fdr'],
+            'fwerp': gsea.results[k]['fwerp'],
+            'tag': gsea.results[k]['tag %'],
+            'lead': np.array(gsea.results[k]['lead_genes'].split(';'), dtype = str),
+            'match': np.array(gsea.results[k]['matched_genes'].split(';'), dtype = 'str'),
+            'hits': np.array(gsea.results[k]['hits'])
+        }
+    
+    pass

exprmat-0.1.9/exprmat/plotting/gse.py

@@ -0,0 +1,323 @@
+
+import sys
+import operator
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import pandas as pd
+
+import matplotlib.pyplot as plt
+import matplotlib.transforms as transforms
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+from matplotlib.figure import Figure
+from matplotlib.colors import Normalize
+
+from exprmat.ansi import error
+
+
+class normalize_midpoint(Normalize):
+    def __init__(self, vmin=None, vmax=None, vcenter=None, clip=False):
+        self.vcenter = vcenter
+        Normalize.__init__(self, vmin, vmax, clip)
+
+    def __call__(self, value, clip = None):
+        x, y = [self.vmin, self.vcenter, self.vmax], [0, 0.5, 1]
+        return np.ma.masked_array(np.interp(value, x, y, left = -np.inf, right = np.inf))
+
+    def inverse(self, value):
+        y, x = [self.vmin, self.vcenter, self.vmax], [0, 0.5, 1]
+        return np.interp(value, x, y, left = -np.inf, right = np.inf)
+
+
+def zscore(data2d: pd.DataFrame, axis: Optional[int] = 0):
+    
+    if axis is None:
+        # normalized to mean and std using entire matrix
+        # z_scored = (data2d - data2d.values.mean()) / data2d.values.std(ddof=1)
+        return data2d
+    
+    assert axis in [0, 1]
+    z_scored = data2d.apply(
+        lambda x: (x - x.mean()) / x.std(ddof=1), axis = operator.xor(1, axis)
+    )
+
+    return z_scored
+
+
+class nesplot:
+
+    def __init__(
+        self,
+        term: str,
+        tag: Sequence[int],
+        runes: Sequence[float],
+        nes: float,
+        pval: float,
+        fdr: float,
+        rank_metric: Optional[Sequence[float]] = None,
+        pheno_pos: str = "",
+        pheno_neg: str = "",
+        color: Optional[str] = "#88C544",
+        figsize: Tuple[float, float] = (4, 4),
+        cmap: str = "seismic",
+        ax: Optional[plt.Axes] = None,
+        module = 'gsea',
+        title = None,
+        ** kwargs
+    ):
+        
+        self._x = np.arange(len(runes))
+        self.rankings = None
+        self._zero_score_ind = None
+        self._z_score_label = None
+        self.color = color
+        self.module = module
+
+        if rank_metric is not None:
+            self.rankings = np.asarray(rank_metric)
+            self._zero_score_ind = np.abs(self.rankings).argmin()
+            self._z_score_label = str(self._zero_score_ind)
+
+        self.running_es = np.asarray(runes)
+
+        self.figsize = figsize
+        self.term = term
+        self.cmap = cmap
+
+        self._pos_label = pheno_pos
+        self._neg_label = pheno_neg
+        self._hit_indices = tag
+        
+        if self.module == "ssgsea":
+            self._nes_label  = "Enrichment Score: " + "{:.3f}".format(float(nes))
+            self._fdr_label  = "False discovery rate: -"
+            self._pval_label = "p value: -"
+        
+        else:
+            self._nes_label  = "Normalized enrichment score: " + "{:.3f}".format(float(nes))
+            self._fdr_label  = "False discovery rate: " + "{:.3f}".format(float(fdr))
+            self._pval_label = "p value: " + "{:.3f}".format(float(pval))
+
+        if ax is None:
+            if hasattr(sys, "ps1"):
+                # working inside python console, show figure
+                self.fig = plt.figure(figsize=self.figsize, facecolor = "white")
+            else:
+                # if working on command line, don't show figure
+                self.fig = Figure(figsize=self.figsize, facecolor = "white")
+                self._canvas = FigureCanvas(self.fig)
+
+        elif isinstance(ax, plt.Axes): self.fig = ax.figure
+        else: error("`ax` must be matplotlib axes.")
+        self.fig.suptitle(
+            self.term if title is None else title, fontsize = 11, 
+            wrap = True, fontweight = "bold"
+        )
+
+
+    def axes_rank(self, rect):
+        
+        ax1 = self.fig.add_axes(rect)
+        if self.module == "ssgsea":
+            ax1.fill_between(self._x, y1 = np.log(self.rankings), y2=0, color = "#C9D3DB")
+            ax1.set_ylabel("Ranked metric (log)", fontsize = 9)
+        else:
+            ax1.fill_between(self._x, y1=self.rankings, y2 = 0, color="#C9D3DB")
+            ax1.set_ylabel("Ranked metric", fontsize = 9)
+
+        ax1.text(
+            0.05, 0.9,
+            self._pos_label,
+            color = "red",
+            horizontalalignment = "left",
+            verticalalignment = "top",
+            transform = ax1.transAxes,
+        )
+
+        ax1.text(
+            0.95, 0.05,
+            self._neg_label,
+            color = "Blue",
+            horizontalalignment = "right",
+            verticalalignment = "bottom",
+            transform = ax1.transAxes,
+        )
+
+        # the x coords of this transformation are data, and the y coord are axes
+        trans1 = transforms.blended_transform_factory(ax1.transData, ax1.transAxes)
+        ax1.vlines(
+            self._zero_score_ind, 0, 1, linewidth = 0.5,
+            transform = trans1, linestyles = "--", color = "grey",
+        )
+
+        hap = self._zero_score_ind / max(self._x)
+        if hap < 0.25: ha = "left"
+        elif hap > 0.75: ha = "right"
+        else: ha = "center"
+        ax1.text(
+            hap, 0.5, self._z_score_label,
+            horizontalalignment = ha, verticalalignment = "center",
+            transform = ax1.transAxes, fontsize = 9,
+        )
+
+        ax1.set_xlabel("Gene ranking", fontsize = 9)
+        ax1.spines["top"].set_visible(False)
+        ax1.tick_params(
+            axis = "both", which = "both", 
+            top = False, right = False, left = False, labelsize = 9
+        )
+        ax1.locator_params(axis = "y", nbins = 5)
+        ax1.yaxis.set_major_formatter(
+            plt.FuncFormatter(lambda tick_loc, tick_num: "{:.1f}".format(tick_loc))
+        )
+
+
+    def axes_hits(self, rect, bottom: bool = False):
+        
+        ax2 = self.fig.add_axes(rect)
+        # the x coords of this transformation are data, and the y coord are axes
+        trans2 = transforms.blended_transform_factory(ax2.transData, ax2.transAxes)
+        # to make axes shared with same x cooridincates, make the vlines same ranges to x
+        ax2.vlines(
+            [self._x[0], self._x[-1]],
+            0, 1, linewidth = 0.5, transform = trans2,
+            color = "white", alpha = 0,
+        )
+
+        # add hits line
+        ax2.vlines(self._hit_indices, 0, 1, linewidth = 0.5, transform = trans2, color = "black")
+
+        ax2.tick_params(
+            axis = "both", which = "both",
+            bottom = bottom, top = False, right = False, left = False,
+            labelbottom = bottom, labelleft = False,
+        )
+
+        if bottom:
+            ax2.set_xlabel("Gene ranking", fontsize = 9)
+            ax2.spines["bottom"].set_visible(True)
+
+
+    def axes_cmap(self, rect):
+        
+        # center color map at midpoint = 0
+        mat = self.rankings
+        if self.rankings is None:
+            mat = self.running_es
+        vmin = np.percentile(mat.min(), 2)
+        vmax = np.percentile(mat.max(), 98)
+        midnorm = normalize_midpoint(vmin = vmin, vcenter = 0, vmax = vmax)
+        
+        # colormap
+        ax3 = self.fig.add_axes(rect)
+        ax3.pcolormesh(
+            mat[np.newaxis, :],
+            rasterized = True,
+            norm = midnorm,
+            cmap = self.cmap,
+        )
+
+        ax3.spines["bottom"].set_visible(False)
+        ax3.tick_params(
+            axis = "both", which = "both",
+            bottom = False, top = False, right = False, left = False,
+            labelbottom = False, labelleft = False,
+        )
+
+
+    def axes_stat(self, rect):
+
+        # enrichment score plot
+        ax4 = self.fig.add_axes(rect)
+        ax4.plot(self._x, self.running_es, linewidth = 4, color = self.color)
+        ax4.text(0.02, 0.05, self._fdr_label, transform = ax4.transAxes, fontsize = 9)
+        ax4.text(0.02, 0.15, self._pval_label, transform = ax4.transAxes, fontsize = 9)
+        ax4.text(0.02, 0.25, self._nes_label, transform = ax4.transAxes, fontsize = 9)
+
+        # the y coords of this transformation are data, and the x coord are axes
+        trans4 = transforms.blended_transform_factory(ax4.transAxes, ax4.transData)
+        ax4.hlines(0, 0, 1, linewidth = 1, transform = trans4, color = "grey")
+        ax4.set_ylabel("Enrichment score", fontsize = 9)
+
+        ax4.tick_params(
+            axis = "both", which = "both",
+            bottom = False, top = False, right = False, labelbottom = False,
+            labelsize = 9
+        )
+        ax4.locator_params(axis = "y", nbins = 5)
+        ax4.yaxis.set_major_formatter(
+            plt.FuncFormatter(lambda tick_loc, tick_num: "{:.1f}".format(tick_loc))
+        )
+        self.ax = ax4
+
+
+    def add_axes(self):
+
+        left = 0.1
+        width = 0.8
+        bottom = 0.1
+        height = 0
+
+        stat_height_ratio = 0.4
+        hits_height_ratio = 0.05
+        cmap_height_ratio = 0.05
+        rank_height_ratio = 0.3
+        
+        if self.rankings is None:
+            rank_height_ratio = 0
+            cmap_height_ratio = 0
+        
+        base = 0.8 / (
+            stat_height_ratio
+            + hits_height_ratio
+            + cmap_height_ratio
+            + rank_height_ratio
+        )
+
+        if self.rankings is not None:
+            height = rank_height_ratio * base
+            self.axes_rank([left, bottom, width, height])
+            bottom += height
+            height = cmap_height_ratio * base
+            self.axes_cmap([left, bottom, width, height])
+            bottom += height
+
+        height = hits_height_ratio * base
+        self.axes_hits(
+            [left, bottom, width, height], bottom=False if bottom > 0.1 else True
+        )
+
+        bottom += height
+        height = stat_height_ratio * base
+        self.axes_stat([left, bottom, width, height])
+
+
+def esplot(
+    adata, *, gsea, terms, figsize = (4, 4), title = None,
+    colors = None, show_ranking = True, sample_name = None
+):
+    
+    gsdict = adata.uns[gsea]['results'][terms]
+    ranking = pd.DataFrame({
+        'gene_names': adata.uns[gsea]['config']['ranking.key'],
+        'value': adata.uns[gsea]['config']['ranking.value']
+    })
+
+    ranking.set_index('gene_names')
+    g = nesplot(
+        term = terms,
+        tag = gsdict["hits"],
+        rank_metric = ranking['value'] if (show_ranking) else None,
+        runes = gsdict["res"],
+        nes = gsdict["nes"],
+        pval = gsdict["p"],
+        fdr = gsdict["fdr"],
+        pheno_pos = '', # adata.uns[gsea]['config']['positive'],
+        pheno_neg = '', # adata.uns[gsea]['config']['negative'],
+        color = colors,
+        title = title,
+        figsize = figsize,
+    )
+
+    g.add_axes()
+    return g.fig

{exprmat-0.1.8 → exprmat-0.1.9}/exprmat/reader/experiment.py

@@ -364,6 +364,8 @@ class experiment:
 
             if not run_on_splits:
                 figure = func(self.mudata['rna'], 'integrated', **kwargs)
+                import warnings
+                warnings.filterwarnings('ignore')
                 figure.tight_layout()
                 return figure
 
@@ -493,7 +495,10 @@ class experiment:
                 x if str(x) != 'nan' else y 
                 for x, y in zip(fromslot, toslot)
             ]
+
             info(f'merged {annotation} to {to} in current dataset.')
+            print(self.mudata[slot].obs[to].value_counts())
+            self.mudata[slot].obs[to] = self.mudata[slot].obs[to].astype('category')
 
         # if todf is another subset.
         elif isinstance(todf, str) and os.path.exists(
@@ -510,7 +515,10 @@ class experiment:
                     x if str(x) != 'nan' else y 
                     for x, y in zip(fromslot, toslot)
                 ]
+
                 info(f'merged {annotation} to {to} in current dataset.')
+                print(self.mudata[slot].obs[to].value_counts())
+                self.mudata[slot].obs[to] = self.mudata[slot].obs[to].astype('category')
 
             else:
                 
@@ -534,6 +542,8 @@ class experiment:
 
                 del mdata[slot].obs['.temp']
                 info(f'updated {annotation} to {to} in {todf}.h5mu')
+                print(mdata[slot].obs[to].value_counts())
+                mdata[slot].obs[to] = mdata[slot].obs[to].astype('category')
                 mdata.write_h5mu(os.path.join(self.directory, 'subsets', todf + '.h5mu'))
         
         elif isinstance(todf, str) and todf == 'integrated':
@@ -557,6 +567,8 @@ class experiment:
 
             del mdata[slot].obs['.temp']
             info(f'updated {annotation} to {to} in main integrated.h5mu')
+            print(mdata[slot].obs[to].value_counts())
+            mdata[slot].obs[to] = mdata[slot].obs[to].astype('category')
             mdata.write_h5mu(os.path.join(self.directory, 'integrated.h5mu'))
             
             
@@ -1221,6 +1233,17 @@ class experiment:
     def rna_plot_cnv_matrix(adata, sample_name, **kwargs):
         from exprmat.plotting.cnv import chromosome_heatmap
         return chromosome_heatmap(adata, sample_name = sample_name, **kwargs)
+    
+
+    @staticmethod
+    def rna_plot_gsea_running_es(
+        adata, sample_name, gsea, terms, figsize = (4, 4), colors = None, title = None, **kwargs
+    ):
+        from exprmat.plotting.gse import esplot
+        return esplot(
+            adata, sample_name = sample_name, title = title,
+            gsea = gsea, terms = terms, figsize = figsize, colors = colors, **kwargs
+        )
 
 
     # wrapper functions
@@ -1404,11 +1427,14 @@ class experiment:
         fig.tight_layout()
         return fig
     
+    def plot_rna_gsea_running_es(self, run_on_samples = False, **kwargs):
+        return self.plot_for_rna(run_on_samples, experiment.rna_plot_gsea_running_es, **kwargs)
+    
     
     # accessor wrappers
 
     def get_rna_markers(
-        self, de_slot = 'markers', group_name = None,
+        self, de_slot = 'markers', group_name = None, max_q = None,
         min_pct = 0.25, max_pct_reference = 0.75, min_lfc = 1, max_lfc = 100, remove_zero_pval = False
     ):
         self.check_merged('rna')
@@ -1431,9 +1457,43 @@ class experiment:
             tab = tab[tab['lfc'] <= max_lfc]
         if remove_zero_pval:
             tab = tab[~ np.isinf(tab['log10.q'].to_numpy())]
+        if max_q is not None and 'q' in tab.columns:
+            tab = tab[tab['q'] <= max_q]
         
         tab = tab.sort_values(by = ['scores'], ascending = False)
         return tab
+    
+
+    def get_rna_gsea(self, gsea_slot = 'gsea', max_fdr = 1.00, max_p = 0.05):
+        
+        df = {
+            'name': [],
+            'es': [],
+            'nes': [],
+            'p': [],
+            'fwerp': [],
+            'fdr': [],
+            'tag': []
+        }
+
+        for gs in self.mudata['rna'].uns[gsea_slot]['results'].keys():
+            data = self.mudata['rna'].uns[gsea_slot]['results'][gs]
+            df['name'].append(gs)
+            df['es'].append(data['es'])
+            df['nes'].append(data['nes'])
+            df['p'].append(data['p'])
+            df['fwerp'].append(data['fwerp'])
+            df['fdr'].append(data['fdr'])
+            df['tag'].append(data['tag'])
+        
+        df = pd.DataFrame(df)
+        if max_fdr is not None:
+            df = df[df['fdr'] <= max_fdr]
+        if max_p is not None:
+            df = df[df['p'] <= max_p]
+        
+        df.sort_values(['p'])
+        return df
 
 
     def save(self, fdir = None, save_samples = True):

{exprmat-0.1.8 → exprmat-0.1.9}/exprmat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.1.8
+Version: 0.1.9
 Summary: routines to process expression matrices
 Home-page: https://github.com/yang-z-03/exprmat
 Author: Zheng Yang

{exprmat-0.1.8 → exprmat-0.1.9}/exprmat.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ exprmat/plotting/__init__.py
 exprmat/plotting/cnv.py
 exprmat/plotting/de.py
 exprmat/plotting/expression.py
+exprmat/plotting/gse.py
 exprmat/plotting/palettes.py
 exprmat/plotting/summary.py
 exprmat/preprocessing/__init__.py

{exprmat-0.1.8 → exprmat-0.1.9}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name                 = 'exprmat',
-    version              = '0.1.8',
+    version              = '0.1.9',
     description          = 'routines to process expression matrices',
     url                  = 'https://github.com/yang-z-03/exprmat',
     author               = 'Zheng Yang',