exprmat 0.2.73__tar.gz → 0.2.77__tar.gz

{exprmat-0.2.73 → exprmat-0.2.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.2.73
+Version: 0.2.77
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -102,11 +102,19 @@ Requires-Dist: cuvs-cu12==25.8.* ; extra == 'cuda12'
 Requires-Dist: nx-cugraph-cu12==25.8.* ; extra == 'cuda12'
 Requires-Dist: cupy-cuda12x ; extra == 'cuda12'
 Requires-Dist: rapids-singlecell ; extra == 'cuda12'
+Requires-Dist: cudf-cu13==25.10.* ; extra == 'cuda13'
+Requires-Dist: cuml-cu13==25.10.* ; extra == 'cuda13'
+Requires-Dist: cugraph-cu13==25.10.* ; extra == 'cuda13'
+Requires-Dist: cuvs-cu13==25.10.* ; extra == 'cuda13'
+Requires-Dist: cupy-cuda13x ; extra == 'cuda13'
+Requires-Dist: rapids-singlecell ; extra == 'cuda13'
 Requires-Dist: sphinx ; extra == 'dev'
 Requires-Dist: twine ; extra == 'dev'
 Requires-Dist: ipykernel ; extra == 'dev'
 Requires-Dist: ipytree ; extra == 'dev'
+Requires-Dist: uv ; extra == 'dev'
 Provides-Extra: cuda12
+Provides-Extra: cuda13
 Provides-Extra: dev
 License-File: license
 Summary: exprmat: Routines for expression matrices

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/__init__.py

@@ -130,6 +130,7 @@ from exprmat.utils import setup_styles as _setup_styles
 from exprmat.ansi import pprog, pproga, info, error, warning, default_logger, logger
 from exprmat.reader.experiment import experiment, load_experiment
 from exprmat.reader.metadata import metadata, load_metadata
+from . import repertoire
 
 
 _setup_styles()
@@ -263,4 +264,4 @@ __all__ = [
     # constants
     'SPECIFICATION',
     'ENABLE_AGENT_PROMPT'
-]
+]

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/ansi.py

@@ -279,6 +279,4 @@ class pproga(tqdma):
         super().__init__(iterable, **progress_styles, **kwargs)
 
 
-def tqinfo(x):
-    if SILENT: return
-    tqdm.write(cyan('[i] ') + x)
+def tqinfo(x): tqdm.write(cyan('[i] ') + x)

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/descriptive/tcr.py

@@ -68,7 +68,7 @@ def pairwise_transition(
 ):
 
     mat, clono_ids, clust_ids = clone_cluster_matrix(adata, clonotype = clonotype, cluster = cluster)
-    adata.obs[key] = 0
+    adata.obs[key] = 0.0
     baseid = clust_ids.index(base)
 
     for j, cs in enumerate(clust_ids):
@@ -82,7 +82,10 @@ def pairwise_transition(
         weights = weights / weights.sum()
         submat = (submat.T / submat.sum(axis = 1)).T # row normalize
         
-        shannon_e = -(submat[:, 0] * np.log2(submat[:, 0]) + submat[:, 1] * np.log2(submat[:, 1]))
+        logarithms = np.zeros_like(submat)
+        positive = submat > 0
+        logarithms[positive] = np.log2(submat[positive])
+        shannon_e = -(submat * logarithms).sum(axis = 1)
         shannon_e[either_zero] = 0
         adata.obs.loc[adata.obs[cluster] == cs, key] = np.sum(shannon_e * weights)
 
@@ -103,4 +106,4 @@ def transition(adata, clonotype = 'clone.id', cluster = 'leiden', key = 'clone.t
 
 def migration(adata, clonotype = 'clone.id', cluster = 'tissue', key = 'clone.migr'):
     # completely the same.
-    transition(adata, clonotype = clonotype, cluster = cluster, key = key)
+    transition(adata, clonotype = clonotype, cluster = cluster, key = key)

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/plotting/expression.py

@@ -61,9 +61,9 @@ def barplot(
             data = dropzeros.loc[dropzeros['name'] == gene,:],
             x = "row", y = "logc", hue = 'split', ax = axes, fill = True,
             palette = palette, saturation = 0.8, log_scale = False,
-            color = '.8', linecolor = '0', order = selected_groups, gap = 0.3,
+            color = '.8', linecolor = '0', order = selected_groups, hue_order = selected_splits, gap = 0.3,
             flierprops = flierprops if flierprops else dict(markerfacecolor = '0.1', markersize = 1, linestyle = 'none'),
-            showfliers = True, width = 0.6
+            showfliers = True, width = 0.8
         )
     
     elif style == 'violin':
@@ -72,7 +72,7 @@ def barplot(
             data = dropzeros.loc[dropzeros['name'] == gene,:],
             x = "row", y = "logc", hue = 'split', ax = axes, fill = True,
             palette = palette, saturation = 0.8, log_scale = False,
-            color = '.8', linecolor = '0', order = selected_groups, gap = 0,
+            color = '.8', linecolor = '0', order = selected_groups, hue_order = selected_splits, gap = 0,
             width = 0.8, **violin_kwargs
         )
     
@@ -275,7 +275,7 @@ def volcano(
     names = plots['gene'].tolist()
 
     fig, axes = plt.subplots(1, 1, figsize = figsize, dpi = dpi)
-    axes.scatter(fc, pvals, c = color_null, s = 4)
+    axes.scatter(fc, pvals, c = color_null, s = 4, rasterized = True)
 
     sig_pvals = []
     sig_fc = []
@@ -283,12 +283,12 @@ def volcano(
 
     for p, f, nm in zip(pvals, fc, names):
         if nm in label:
-            sig_pvals += [p]
+            sig_pvals += [min(p, ylim)]
             sig_fc += [f]
             sig_names += [nm]
 
         if (p > highlight_min_logp and abs(f) >= highlight_min_lfc) and show_all:
-            sig_pvals += [p]
+            sig_pvals += [min(p, ylim)]
             sig_fc += [f]
             sig_names += [nm]
 
@@ -310,7 +310,7 @@ def volcano(
     axes.grid(False)
 
     xlim = min(np.abs(np.array(fc)).max(), xlim)
-    ylim = min(ylim, np.max(np.array(pvals)))
+    # ylim = min(ylim, np.max(np.array(pvals)))
     axes.set_xlim([-xlim, xlim])
     axes.set_ylim([-ylim / 20, ylim])
 

exprmat-0.2.77/exprmat/plotting/matrix.py

@@ -0,0 +1,276 @@
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.cluster.hierarchy import dendrogram, linkage, leaves_list
+from scipy.spatial.distance import pdist
+from typing import Optional, Tuple
+from exprmat import error
+
+
+def plot_matrix(
+    mat: pd.DataFrame,
+    dend_x: bool = True,
+    dend_y: bool = True,
+    show_dend_x: bool = True,
+    show_dend_y: bool = True,
+    width_dend_x = 1,
+    height_dend_y = 1,
+    dpi: int = 100,
+    figsize: Tuple[int, int] = (5, 4),
+    cmap: str = 'viridis',
+    meta_x: Optional[pd.DataFrame] = None,
+    meta_x_cmap: str | dict = 'reds/r',
+    meta_x_height_per_row: float = 0.15,
+    meta_x_pad: float = 0.5,
+    meta_x_show_legend: bool = True,
+) -> None:
+    
+    from exprmat.plotting.palettes import mpl
+    
+    if not isinstance(mat, pd.DataFrame):
+        error('mat should be a pandas dataframe')
+    
+    if not np.issubdtype(mat.values.dtype, np.number):
+        error('mat should contain numerical values')
+    
+    if mat.isnull().any().any():
+        error('mat contains non-numeric values (e.g. nan, inf)')
+    
+    if meta_x is not None and not isinstance(meta_x, pd.DataFrame):
+        error('meta_x should be a pandas dataframe')
+    
+    mat_copy = mat.copy()
+    
+    # column dendrogram
+    col_order = np.arange(mat_copy.shape[1])
+    col_linkage = None
+    if dend_x:
+        col_linkage = linkage(pdist(mat_copy.T, metric = 'euclidean'), method = 'ward')
+        col_order = leaves_list(col_linkage)
+        mat_copy = mat_copy.iloc[:, col_order]
+    
+    # row dendrogram
+    row_order = np.arange(mat_copy.shape[0])
+    row_linkage = None
+    if dend_y:
+        row_linkage = linkage(pdist(mat_copy, metric = 'euclidean'), method = 'ward')
+        row_order = leaves_list(row_linkage)
+        mat_copy = mat_copy.iloc[row_order, :]
+    
+    # metadata table — compute height before layout
+    meta_height = 0
+    meta_pad = 0
+    meta_bottom = 0.05
+    legend_height = 0
+    legend_entries = []
+    if meta_x is not None:
+        meta_x = meta_x.reindex(columns = mat_copy.columns)
+        meta_height = meta_x.shape[0] * meta_x_height_per_row / figsize[1]
+        meta_pad = meta_x_pad / figsize[1]
+        
+        # legend for metadata
+        if meta_x_show_legend:
+            legend_height_per_row = 0.08
+            for label, row_data in meta_x.iterrows():
+                is_numeric = False
+                try:
+                    row_data.astype(float)
+                    is_numeric = True
+                except: is_numeric = False
+
+                if is_numeric:
+                    legend_entries.append(('numeric', label, None, None,
+                                           row_data.min(), row_data.max()))
+                else:
+                    cats = pd.Categorical(row_data.dropna())
+                    n_cats = len(cats.categories)
+                    if isinstance(meta_x_cmap, dict) and label in meta_x_cmap and isinstance(meta_x_cmap[label], list):
+                        colors = list(meta_x_cmap[label])
+                    else:
+                        cat_cmap = plt.cm.tab10 if n_cats <= 10 else plt.cm.tab20
+                        colors = [cat_cmap((c + 0.5) / n_cats) for c in range(n_cats)]
+                    legend_entries.append(('categorical', label, cats.categories,
+                                           colors, None, None))
+            legend_height = len(legend_entries) * legend_height_per_row
+            meta_bottom = 0.15 + legend_height
+    
+    fig = plt.figure(figsize = figsize, dpi = dpi)
+    
+    heatmap_left = (0.05 + width_dend_x / figsize[0]) if show_dend_y else 0.1
+    heatmap_width = (figsize[0] * 0.9 - width_dend_x) / figsize[0] if show_dend_x else 0.8
+    
+    # heatmap keeps its original size; when meta is present, everything above
+    # shifts up so that metadata sits at the very bottom with a gap (meta_pad)
+    # between the metadata top and heatmap_bottom, giving room for x-axis labels
+    if show_dend_y:
+        heatmap_height = ((figsize[1] * 0.9 - height_dend_y) / figsize[1])
+    else:
+        heatmap_height = 0.9
+    
+    heatmap_bottom = meta_bottom + meta_height + meta_pad
+    
+    ax_row_dend = None
+    if show_dend_y and dend_y:
+        ax_row_dend = fig.add_axes([0.05, heatmap_bottom, width_dend_x / figsize[0], heatmap_height])
+
+        dendrogram(row_linkage, orientation='left', ax=ax_row_dend, no_labels=True)
+        ax_row_dend.set_xticks([])
+        ax_row_dend.set_yticks([])
+        ax_row_dend.spines['top'].set_visible(False)
+        ax_row_dend.spines['bottom'].set_visible(False)
+        ax_row_dend.spines['left'].set_visible(False)
+    
+    ax_col_dend = None
+    if show_dend_x and dend_x:
+        col_dend_bottom = heatmap_bottom + heatmap_height
+        ax_col_dend = fig.add_axes([heatmap_left, col_dend_bottom, heatmap_width, height_dend_y / figsize[1]])
+
+        dendrogram(col_linkage, orientation='top', ax=ax_col_dend, no_labels=True)
+        ax_col_dend.set_xticks([])
+        ax_col_dend.set_yticks([])
+        ax_col_dend.spines['top'].set_visible(False)
+        ax_col_dend.spines['left'].set_visible(False)
+        ax_col_dend.spines['right'].set_visible(False)
+    
+
+    ax_heatmap = fig.add_axes([heatmap_left, heatmap_bottom, heatmap_width, heatmap_height])
+    im = ax_heatmap.imshow(mat_copy.values, cmap = mpl(cmap), aspect = 'auto', interpolation = 'nearest')
+    # print(mat_copy.index.tolist())
+    # print(mat_copy.columns.tolist())
+    
+    ax_heatmap.set_xticks(range(len(mat_copy.columns)))
+    ax_heatmap.set_xticklabels(mat_copy.columns, rotation = 90, ha='center', fontsize=9)
+    ax_heatmap.set_yticks(range(len(mat_copy.index)))
+    ax_heatmap.yaxis.tick_right()
+    ax_heatmap.set_yticklabels(mat_copy.index, fontsize = 9, ha = 'left')
+    
+    # metadata table — placed at the very bottom, below the heatmap x-axis labels
+    if meta_x is not None:
+        for i, (label, row_data) in enumerate(meta_x.iterrows()):
+            row_bottom = meta_bottom + (meta_x.shape[0] - i - 1) * meta_x_height_per_row / figsize[1]
+            ax_meta = fig.add_axes([
+                heatmap_left,
+                row_bottom,
+                heatmap_width,
+                meta_x_height_per_row / figsize[1]
+            ])
+            
+            n_cols = len(row_data)
+            values = row_data.values.reshape(1, -1)
+
+            is_numeric = False
+            try:
+                row_data.astype(float)
+                is_numeric = True
+            except: is_numeric = False
+            
+            if is_numeric:
+                vmin, vmax = row_data.min(), row_data.max()
+                if vmax == vmin: normed = np.zeros_like(values, dtype = float)
+                else: normed = (values.astype(float) - vmin) / (vmax - vmin)
+                if isinstance(meta_x_cmap, dict) and label in meta_x_cmap:
+                    val = meta_x_cmap[label]
+                    if isinstance(val, str):
+                        _cmap = mpl(val)
+                    else:
+                        from matplotlib.colors import ListedColormap
+                        _cmap = ListedColormap(val)
+                else:
+                    _cmap = mpl(meta_x_cmap)
+                ax_meta.imshow(normed, cmap = _cmap, aspect = 'auto', vmin = 0, vmax = 1)
+            else:
+                cats = pd.Categorical(row_data)
+                codes = cats.codes.reshape(1, -1)
+                n_cats = len(cats.categories)
+                if isinstance(meta_x_cmap, dict) and label in meta_x_cmap and isinstance(meta_x_cmap[label], list):
+                    from matplotlib.colors import ListedColormap
+                    cat_cmap = ListedColormap(meta_x_cmap[label])
+                else:
+                    cat_cmap = plt.cm.tab10 if n_cats <= 10 else plt.cm.tab20
+                ax_meta.imshow(codes, cmap = cat_cmap, aspect = 'auto',
+                              vmin = -0.5, vmax = n_cats - 0.5)
+            
+            # borders
+            ax_meta.set_xticks(np.arange(-0.5, n_cols, 1), minor = True)
+            ax_meta.set_yticks(np.arange(-0.5, 1, 1), minor = True)
+            ax_meta.grid(which = 'minor', color = 'white', linewidth = 2)
+            ax_meta.tick_params(which = 'minor', length = 0)
+            ax_meta.set_xticks([])
+            ax_meta.set_yticks([])
+            ax_meta.spines['top'].set_visible(False)
+            ax_meta.spines['bottom'].set_visible(False)
+            ax_meta.spines['left'].set_visible(False)
+            ax_meta.spines['right'].set_visible(False)
+            
+            # label on the right
+            ax_meta.text(1.01, 0.5, str(label), transform = ax_meta.transAxes,
+                        fontsize = 9, va = 'center', ha = 'left')
+    
+    # legend for metadata — below the metadata table
+    if legend_entries:
+        from matplotlib.patches import Rectangle
+        
+        ax_legend = fig.add_axes([heatmap_left, 0.01, heatmap_width, legend_height])
+        ax_legend.set_xlim(0, 1)
+        ax_legend.set_ylim(0, 1)
+        ax_legend.axis('off')
+        
+        n_rows = len(legend_entries)
+        row_h = 1.0 / n_rows
+        
+        for i, entry in enumerate(legend_entries):
+            ltype, name, cats, colors, mn, mx = entry
+            y_c = (i + 0.5) * row_h
+            
+            # metadata name
+            ax_legend.text(-0.02, y_c, str(name), fontsize = 9, va = 'center',
+                          ha = 'right', transform = ax_legend.transAxes)
+            
+            if ltype == 'categorical':
+                x = 0.0
+                base_y = y_c
+                sub = 0
+                for cat, color in zip(cats, colors):
+                    if x > 0.85:
+                        sub += 1
+                        x = 0.0
+                    y_disp = base_y - sub * row_h * 0.55
+                    
+                    rect = Rectangle((x, y_disp - row_h * 0.3), 0.02, row_h * 0.6,
+                                    facecolor = color, edgecolor = 'gray',
+                                    linewidth = 0.3, transform = ax_legend.transAxes)
+                    ax_legend.add_patch(rect)
+                    ax_legend.text(x + 0.025, y_disp, str(cat), fontsize = 9,
+                                  va = 'center', ha = 'left',
+                                  transform = ax_legend.transAxes)
+                    x += 0.03 + max(0.05, len(str(cat)) * 0.012)
+                    
+            elif ltype == 'numeric':
+                gradient = np.linspace(0, 1, 256).reshape(1, -1)
+                cb_left = 0.0
+                cb_width = 0.35
+                cb_height = row_h * 0.4
+                cb_bottom = y_c - cb_height / 2
+                
+                if isinstance(meta_x_cmap, dict) and name in meta_x_cmap:
+                    val = meta_x_cmap[name]
+                    if isinstance(val, str):
+                        _lgnd_cmap = mpl(val)
+                    else:
+                        from matplotlib.colors import ListedColormap
+                        _lgnd_cmap = ListedColormap(val)
+                else:
+                    _lgnd_cmap = mpl(meta_x_cmap)
+                ax_legend.imshow(gradient, cmap = _lgnd_cmap, aspect = 'auto',
+                               extent = [cb_left + 0.05, cb_left + cb_width - 0.1,
+                                         cb_bottom, cb_bottom + cb_height])
+                
+                ax_legend.text(cb_left, cb_bottom + cb_height + 0.01, f'{mn:.2g}', fontsize = 9,
+                              va = 'top', ha = 'left',
+                              transform = ax_legend.transAxes)
+                ax_legend.text(cb_left + cb_width - 0.05, cb_bottom + cb_height + 0.01, f'{mx:.2g}', fontsize = 9,
+                              va = 'top', ha = 'right',
+                              transform = ax_legend.transAxes)
+    
+    return fig

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/plotting/order.py

@@ -306,7 +306,7 @@ def variable_order(
                 heat_data,
                 aspect = 'auto',
                 cmap = _mpl(cmap),
-                vmin = vmin_h, vmax = vmax_h,
+                # vmin = vmin_h, vmax = vmax_h,
                 extent = [0, 1, n_feat - 0.5, -0.5],
                 interpolation = 'nearest'
             )

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/plotting/track.py

@@ -227,7 +227,9 @@ def gene_track(
     xfrom, xto,
     chr = '1',
     assembly = 'grcm39',
-    show_gene_name = True
+    show_gene_name = True,
+    hide_unnamed = False,
+    show_only = None
 ):
     from exprmat.data.finders import get_genome, get_genome_model
     from exprmat import config as cfg
@@ -246,16 +248,6 @@ def gene_track(
         for name in gnames:
 
             gene = model[model['gid'] == name].copy()
-            requested_x = gene['start'].min()
-            requested_y = -1
-            for i, z in enumerate(waterflow):
-                if z < requested_x:
-                    requested_y = i
-                    break
-
-            if requested_y == -1:
-                waterflow += [requested_x]
-                requested_y = len(waterflow) - 1
 
             displayname = str(name)
             if show_gene_name:
@@ -266,6 +258,28 @@ def gene_track(
             
             if str(displayname) == 'nan':
                 displayname = ''
+
+            if (
+                displayname == '' or 
+                displayname.startswith('ENS') or 
+                displayname.startswith('Gm') or 
+                displayname.endswith('Rik')
+            ):
+                if hide_unnamed: continue
+
+            if show_only is not None:
+                if not displayname in show_only: continue
+
+            requested_x = gene['start'].min()
+            requested_y = -1
+            for i, z in enumerate(waterflow):
+                if z < requested_x:
+                    requested_y = i
+                    break
+
+            if requested_y == -1:
+                waterflow += [requested_x]
+                requested_y = len(waterflow) - 1
                 
             ntranscript = len(gene[gene['type'] == 'transcript'])
             if ntranscript > 1: displayname += f' ({ntranscript})'

{exprmat-0.2.73 → exprmat-0.2.77}/exprmat/preprocessing/__init__.py

@@ -103,7 +103,7 @@ def highly_variable(
 
     # method implemented in cellranger's selection of hvg.
     elif method == 'cellranger':
-        m_lognorm = choose_layer(adata, lognorm)
+        m_lognorm = choose_layer(adata, layer = lognorm)
         df = highly_variable_nb_log(m_lognorm, adata.var, **kwargs)
 
         # here, we get the full ranked list for all genes in the dataset.