exprmat 0.1.3__tar.gz

exprmat-0.1.3/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: exprmat
+Version: 0.1.3
+Summary: routines to process expression matrices
+Home-page: https://github.com/yang-z-03/exprmat
+Author: Zheng Yang
+Author-email: xornent@outlook.com
+License: GPLv3
+Requires-Dist: umap-learn>=0.5.0
+Requires-Dist: scvi-tools>=1.3.0
+Requires-Dist: scanpy
+Requires-Dist: anndata
+Requires-Dist: mudata
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: torch>=2.0
+Requires-Dist: annoy
+Requires-Dist: scikit-image
+Requires-Dist: scikit-misc
+Requires-Dist: igraph
+Requires-Dist: bbknn
+Requires-Dist: scanorama
+Requires-Dist: harmonypy
+Requires-Dist: pymde
+Requires-Dist: datashader
+Requires-Dist: fa2_modified
+Requires-Dist: pynndescent
+Requires-Dist: gseapy
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

exprmat-0.1.3/exprmat/__init__.py

@@ -0,0 +1,5 @@
+
+import mudata as mu
+import anndata as ad
+
+mu.set_options(pull_on_update = False)

exprmat-0.1.3/exprmat/ansi.py

@@ -0,0 +1,168 @@
+
+# ./shared/ansi.py:
+#   provides basic ansi console coloring and cursor manipulation support.
+#   considering adding later another alternative implementation of the same 
+#   interface for terminal/emulators that do not support ansi.
+# 
+# license: gplv3. <https://www.gnu.org/licenses>
+# contact: yang-z <xornent at outlook dot com>
+
+import re
+import os
+import sys
+
+# foregrounds -----------------------------------------------------------------
+
+def fore_black() -> None:
+    print('\033[30m', end = '')
+
+def fore_red() -> None:
+    print('\033[31m', end = '')
+
+def fore_green() -> None:
+    print('\033[32m', end = '')
+
+def fore_yellow() -> None:
+    print('\033[33m', end = '')
+
+def fore_blue() -> None:
+    print('\033[34m', end = '')
+
+def fore_purple() -> None:
+    print('\033[35m', end = '')
+
+def fore_cyan() -> None:
+    print('\033[36m', end = '')
+
+def fore_white() -> None:
+    print('\033[37m', end = '')
+
+def fore_gray() -> None:
+    print('\033[8m', end = '')
+
+# reset ansi controls ---------------------------------------------------------
+    
+def ansi_reset() -> None:
+    print('\033[0m', end = '')
+
+# backgrounds -----------------------------------------------------------------
+    
+def back_black() -> None:
+    print('\033[40m', end = '')
+
+def back_red() -> None:
+    print('\033[41m', end = '')
+
+def back_green() -> None:
+    print('\033[42m', end = '')
+
+def back_yellow() -> None:
+    print('\033[43m', end = '')
+
+def back_blue() -> None:
+    print('\033[44m', end = '')
+
+def back_purple() -> None:
+    print('\033[45m', end = '')
+
+def back_cyan() -> None:
+    print('\033[46m', end = '')
+
+def back_white() -> None:
+    print('\033[47m', end = '')
+
+# cursor operations
+
+def ansi_move_cursor(line: int, col: int) -> None:
+    if line == 0: pass
+    elif line > 0: print('\033[{0}B'.format(str(line)), end = '', flush = True) # moves down
+    elif line < 0: print('\033[{0}A'.format(str(-line)), end = '', flush = True) # moves up
+
+    if col == 0: pass
+    elif col > 0: print('\033[{0}C'.format(str(col)), end = '', flush = True) # moves right
+    elif col < 0: print('\033[{0}D'.format(str(-col)), end = '', flush = True) # moves left
+
+def fill_blank(blanks: int) -> None:
+    print(' ' * blanks, end = '', flush = True)
+
+def common_length(string: str, limit: int) -> str:
+
+    cn_re = '[\u201c-\u201d\u3001-\u3011\uff08-\uff1f\u4e00-\u9fa5]'
+    cn = re.findall(cn_re, string)
+    cn_length = len(cn)
+    
+    if limit <= 5:
+        x_str = string[-limit:]
+        cn = len(re.findall(cn_re, x_str))
+        while cn + len(x_str) > limit:
+            x_str = x_str[1:]
+            cn = len(re.findall(cn_re, x_str))
+        return x_str
+    
+    elif len(string) + cn_length > limit:
+        x_str = string[-(limit - 4):]
+        cn = len(re.findall(cn_re, x_str))
+        while cn + len(x_str) > limit - 4:
+            x_str = x_str[1:]
+            cn = len(re.findall(cn_re, x_str))
+        return '... ' + x_str
+        
+    else: return ('{:<' + str(limit - cn_length) + '}').format(string)
+
+def fill_blank(blanks: int, string: str) -> None:
+    print(common_length(string, blanks), end = '', flush = True)
+
+def line_start() -> None:
+    print('\r', end = '')
+
+def print_message(color, title, path, overwrite = True):
+    if overwrite:
+        print('\r{0}[{1}]\033[0m'.format(color, title), common_length(path, 70), end = '')
+        return '{0}[{1}]\033[0m'.format(color, title) + ' ' + common_length(path, 70)
+    else:
+        print('{0}[{1}]\033[0m'.format(color, title), common_length(path, 70))
+        return '{0}[{1}]\033[0m'.format(color, title) + ' ' + common_length(path, 70)
+    
+def format_file_size(size):
+    for suffix in ['B', 'KiB', 'MiB', 'GiB', 'TiB']:
+        if size < 1024.0 or suffix == 'TiB': break
+        size /= 1024.0
+    return f"{size:.2f} {suffix}"
+
+# prompt messages -------------------------------------------------------------
+    
+def error(text: str) -> None:
+    fore_red()
+    print('[error]', end = ' ')
+    ansi_reset()
+    print(text)
+    raise Exception()
+
+def warning(text: str) -> None:
+    fore_yellow()
+    print('[!]', end = ' ')
+    ansi_reset()
+    print(text)
+    ansi_reset()
+
+def info(text: str) -> None:
+    fore_cyan()
+    print('[i]', end = ' ')
+    ansi_reset()
+    print(text)
+    ansi_reset()
+
+def clear():
+    # for windows
+    if os.name == 'nt':
+        os.system('cls')
+
+    # for mac and linux(here, os.name is 'posix')
+    else: os.system('clear')
+
+def red(x): return '\033[31m' + x + '\033[0m'
+def green(x): return '\033[32m' + x + '\033[0m'
+def yellow(x): return '\033[33m' + x + '\033[0m'
+def blue(x): return '\033[34m' + x + '\033[0m'
+def purple(x): return '\033[35m' + x + '\033[0m'
+def cyan(x): return '\033[36m' + x + '\033[0m'

exprmat-0.1.3/exprmat/clustering/__init__.py

@@ -0,0 +1,2 @@
+
+from exprmat.clustering.leiden import leiden as run_leiden

exprmat-0.1.3/exprmat/clustering/leiden.py

@@ -0,0 +1,95 @@
+
+import anndata as ad
+import scanpy as sc
+
+
+def leiden(
+    adata: ad.AnnData,
+    resolution: float = 1,
+    *,
+    restrict_to = None,
+    random_state = 0,
+    key_added: str = 'leiden',
+    adjacency = None,
+    directed: bool | None = None,
+    use_weights: bool = True,
+    n_iterations: int = 2,
+    partition_type = None,
+    neighbors_key: str | None = None,
+    obsp: str | None = None,
+    flavor = 'igraph',
+    ** clustering_args,
+) -> ad.AnnData | None:
+    '''
+    Cluster cells using the Leiden algorithm, an improved version of the Louvain algorithm.
+
+    Parameters
+    ----------
+    adata
+        The annotated data matrix.
+    resolution
+        A parameter value controlling the coarseness of the clustering. Higher values lead 
+        to more clusters. Set to `None` if overriding `partition_type` to one that doesn't 
+        accept a `resolution_parameter`.
+
+    random_state
+        Change the initialization of the optimization.
+
+    restrict_to
+        Restrict the clustering to the categories within the key for sample annotation, 
+        tuple needs to contain `(obs_key, list_of_categories)`.
+
+    key_added
+        `adata.obs` key under which to add the cluster labels.
+
+    adjacency
+        Sparse adjacency matrix of the graph, defaults to neighbors connectivities.
+
+    directed
+        Whether to treat the graph as directed or undirected. `igrah` implementation
+        does not support a directed graph, you will need to drop back to `leidenalg`
+        method for directed neighbor graphs
+
+    use_weights
+        If `True`, edge weights from the graph are used in the computation.
+        (placing more emphasis on stronger edges).
+
+    n_iterations
+        How many iterations of the Leiden clustering algorithm to perform. Positive values 
+        above 2 define the total number of iterations to perform, -1 has the algorithm run 
+        until it reaches its optimal clustering. 2 is faster and the default for 
+        underlying packages.
+
+    partition_type
+        Type of partition to use. Defaults to `leidenalg.RBConfigurationVertexPartition`.
+        For the available options, consult the documentation for `leidenalg.find_partition`.
+    
+    neighbors_key
+        Use neighbors connectivities as adjacency. If not specified, leiden looks at 
+        .obsp['connectivities'] for connectivities (default storage place for pp.neighbors).
+        If specified, leiden looks at .obsp[.uns[neighbors_key]['connectivities_key']] for 
+        connectivities.
+
+    obsp
+        Use .obsp[obsp] as adjacency. You can't specify both `obsp` and `neighbors_key` 
+        at the same time.
+
+    copy
+        Whether to copy `adata` or modify it inplace.
+
+    flavor
+        Which package's implementation to use.
+
+    clustering_args
+        Any further arguments to pass to :func:`~leidenalg.find_partition` (which in turn 
+        passes arguments to the `partition_type`) or `igraph.Graph.community_leiden` from `igraph`.
+    '''
+    
+    return sc.tl.leiden(
+        adata, resolution = resolution,
+        restrict_to = restrict_to, random_state = random_state,
+        key_added = key_added, adjacency = adjacency, directed = directed,
+        use_weights = use_weights, n_iterations = n_iterations,
+        partition_type = partition_type, neighbors_key = neighbors_key,
+        copy = False, flavor = flavor, **clustering_args
+    )

exprmat-0.1.3/exprmat/clustering/spectral.py

@@ -0,0 +1,10 @@
+
+def get_spectral_clusters(A, k):
+    
+    from sklearn.cluster import SpectralClustering
+    spec = SpectralClustering(
+        n_clusters = k, random_state = 0, 
+        affinity = 'precomputed', assign_labels = 'discretize'
+    )
+
+    return spec.fit_predict(A)

exprmat-0.1.3/exprmat/clustering/utils.py

@@ -0,0 +1,61 @@
+
+import anndata as ad
+import numpy as np
+import pandas as pd
+from sklearn.utils import check_random_state
+import random
+
+
+class igraph_rng:
+
+    def __init__(self, random_state: int | np.random.RandomState = 0) -> None:
+        self._rng = check_random_state(random_state)
+
+    def __getattr__(self, attr: str):
+        return getattr(self._rng, "normal" if attr == "gauss" else attr)
+    
+
+def set_igraph_random_state(random_state):
+
+    import igraph
+    rng = igraph_rng(random_state)
+    try: igraph.set_random_number_generator(rng); yield None
+    finally: igraph.set_random_number_generator(random)
+
+
+def rename_groups(
+    adata: ad.AnnData,
+    restrict_key: str,
+    *,
+    key_added: str | None,
+    restrict_categories,
+    restrict_indices,
+    groups
+):
+
+    key_added = f"{restrict_key}_R" if key_added is None else key_added
+    all_groups = adata.obs[restrict_key].astype("U")
+    prefix = "-".join(restrict_categories) + ","
+    new_groups = [prefix + g for g in groups.astype("U")]
+    all_groups.iloc[restrict_indices] = new_groups
+    return all_groups
+
+
+def restrict_adjacency(
+    adata: ad.AnnData,
+    restrict_key: str,
+    *,
+    restrict_categories,
+    adjacency
+):
+    if not isinstance(restrict_categories[0], str):
+        msg = "You need to use strings to label categories, e.g. '1' instead of 1."
+        raise ValueError(msg)
+    for c in restrict_categories:
+        if c not in adata.obs[restrict_key].cat.categories:
+            msg = f"{c!r} is not a valid category for {restrict_key!r}"
+            raise ValueError(msg)
+    restrict_indices = adata.obs[restrict_key].isin(restrict_categories).values
+    adjacency = adjacency[restrict_indices, :]
+    adjacency = adjacency[:, restrict_indices]
+    return adjacency, restrict_indices

exprmat-0.1.3/exprmat/cnv/__init__.py

@@ -0,0 +1,3 @@
+
+from exprmat.cnv.infercnv import infercnv as run_infercnv
+from exprmat.cnv.cnvscore import cnv_score, ithcna, ithgex

exprmat-0.1.3/exprmat/cnv/cnvscore.py

@@ -0,0 +1,167 @@
+import warnings
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+import scipy.sparse as sp
+from anndata import AnnData
+
+from exprmat.utils import choose_representation as choose_rep
+from exprmat.ansi import warning, info, error
+
+
+def cnv_score(
+    adata: AnnData,
+    groupby: str = "leiden.cnv",
+    *,
+    use_rep: str = "cnv",
+    key_added: str = "score.cnv"
+) -> Mapping[Any, np.number] | None:
+    """
+    Assign each CNV cluster a CNV score.
+
+    Clusters with a high score are likely affected by copy number abberations.
+    Based on this score, cells can be divided into tumor / normal cells. Ths score 
+    is currently simply defined as the mean of the absolute values of the
+    CNV scores in each cluster.
+
+    Parameters
+    ----------
+    adata
+        Annotated data matrix
+
+    groupby
+        Key under which the clustering is stored in adata.obs. Usually the result of 
+        CNV leiden clustering, but could also be other grouping information, e.g. 
+        sample or patient information.
+
+    use_rep
+        Key under which the result of ``infercnv`` stored in adata.
+
+    key_added
+        Key under which the score will be stored in `adata.obs`.
+    """
+
+    if groupby not in adata.obs.columns:
+        error(f"`{groupby}` not found in `adata.obs`.")
+
+    cluster_score = {
+        cluster: np.mean(np.abs(adata.obsm[f"{use_rep}"][adata.obs[groupby].values == cluster, :]))
+        for cluster in adata.obs[groupby].unique()
+    }
+
+    score_array = np.array([cluster_score[c] for c in adata.obs[groupby]])
+    adata.obs[key_added] = score_array
+
+
+def ithgex(
+    adata: AnnData,
+    groupby: str,
+    *,
+    use_raw: bool | None = None,
+    layer: str | None = None,
+    key_added: str = "score.ithgex",
+) -> Mapping[str, float] | None:
+    """
+    Compute the ITHGEX diversity score based on gene expression. A high score indicates a 
+    high diversity of gene expression profiles of cells within a group.
+
+    The score is defined as follows:
+
+    Intratumoral heterogeneity scores based on CNAs and gene expressions
+    The calculations of intratumoral heterogeneity scores were inspired by a
+    previous study and modified as follows. First, to calculate ITHCNA, we used
+    the relative expression value matrix generated by inferCNV and calculated the
+    pairwise cell-cell distances using Pearson's correlation coefficients for each
+    patient. ITHCNA was defined as interquartile range (IQR) of the distribution for
+    all malignant cell pairs' Pearson's correlation coefficients. **Similarly, we also
+    used gene expression profiles of cancer cells of each patient to construct the
+    distribution of the intratumoral distances. ITHGEX was assigned as the IQR of the
+    distribution.**
+
+    Parameters
+    ----------
+    adata
+        Annotated data matrix
+
+    groupby
+        Calculate diversity for each group defined in this category.
+    """
+    
+    groups = adata.obs[groupby].unique()
+    ithgex = {}
+    
+    for group in groups:
+        tmp_adata = adata[adata.obs[groupby] == group, :]
+        X = choose_rep(tmp_adata, use_raw, layer)
+        if sp.issparse(X): X = X.todense()
+        if X.shape[0] <= 1: continue
+        
+        pcorr = np.corrcoef(X, rowvar = True)
+        assert pcorr.shape == (
+            tmp_adata.shape[0],
+            tmp_adata.shape[0],
+        ), f"pcorr is a cell by cell matrix {tmp_adata.shape[0]} {pcorr.shape}"
+        
+        q75, q25 = np.percentile(pcorr, [75, 25])
+        ithgex[group] = q75 - q25
+
+    ithgex_obs = np.empty(adata.shape[0])
+    for group in groups:
+        ithgex_obs[adata.obs[groupby] == group] = ithgex[group]
+    adata.obs[key_added] = ithgex_obs
+
+
+def ithcna(
+    adata: AnnData,
+    groupby: str,
+    *,
+    use_rep: str = "cnv",
+    key_added: str = "score.ithcna"
+) -> Mapping[str, float] | None:
+    """
+    Compute the ITHCNA diversity score based on copy number variation.
+    A high score indicates a high diversity of CNV profiles of cells within a group.
+
+    The score is defined as follows:
+
+    Intratumoral heterogeneity scores based on CNAs and gene expressions
+    The calculations of intratumoral heterogeneity scores were inspired by a
+    previous study and modified as follows. First, to calculate ITHCNA, we used
+    the relative expression value matrix generated by inferCNV and calculated the
+    pairwise cell-cell distances using Pearson's correlation coefficients for each
+    patient. ITHCNA was defined as interquartile range (IQR) of the distribution for
+    all malignant cell pairs' Pearson's correlation coefficients.
+
+    Parameters
+    ----------
+    adata
+        Annotated data matrix
+
+    groupby
+        Calculate diversity for each group defined in this category.
+    """
+
+    groups = adata.obs[groupby].unique()
+    ithcna = {}
+
+    for group in groups:
+        tmp_adata = adata[adata.obs[groupby] == group, :]
+        X = tmp_adata.obsm[use_rep]
+        if sp.issparse(X): X = X.todense()
+        if X.shape[0] <= 1: continue
+
+        pcorr = np.corrcoef(X, rowvar=True)
+        assert pcorr.shape == (
+            tmp_adata.shape[0],
+            tmp_adata.shape[0],
+        ), "pcorr is a cell by cell matrix"
+        
+        q75, q25 = np.percentile(pcorr, [75, 25])
+        ithcna[group] = q75 - q25
+
+    
+    ithcna_obs = np.empty(adata.shape[0])
+    for group in groups:
+        ithcna_obs[adata.obs[groupby] == group] = ithcna[group]
+    adata.obs[key_added] = ithcna_obs