exprmat 0.1.12__tar.gz → 0.1.15__tar.gz

{exprmat-0.1.12 → exprmat-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.1.12
+Version: 0.1.15
 Summary: routines to process expression matrices
 Home-page: https://github.com/yang-z-03/exprmat
 Author: Zheng Yang
@@ -31,6 +31,9 @@ Requires-Dist: gseapy
 Requires-Dist: metacells
 Requires-Dist: sh
 Requires-Dist: networkx
+Requires-Dist: palantir
+Requires-Dist: scfates
+Requires-Dist: rich
 Dynamic: author
 Dynamic: author-email
 Dynamic: home-page

{exprmat-0.1.12 → exprmat-0.1.15}/exprmat/__init__.py

@@ -4,4 +4,4 @@ import anndata as ad
 
 mu.set_options(pull_on_update = False)
 
-def version(): print('exprmat 0.1.12 [revision 1] [dev]')
+def version(): return 'exprmat 0.1.15-1 [dev]'

{exprmat-0.1.12 → exprmat-0.1.15}/exprmat/ansi.py

@@ -1,17 +1,8 @@
 
-# ./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 = '')
@@ -40,13 +31,11 @@ def fore_white() -> None:
 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 = '')
 
@@ -71,7 +60,6 @@ def back_cyan() -> None:
 def back_white() -> None:
     print('\033[47m', end = '')
 
-# cursor operations
 
 def ansi_move_cursor(line: int, col: int) -> None:
     if line == 0: pass
@@ -82,8 +70,6 @@ def ansi_move_cursor(line: int, col: int) -> None:
     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:
 
@@ -109,34 +95,27 @@ def common_length(string: str, limit: int) -> 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:
+
+def error(text: str, error = None) -> None:
     fore_red()
     print('[error]', end = ' ')
     ansi_reset()
     print(text)
-    raise Exception()
+
+    if error is None: raise Exception(text)
+    else: raise Exception(text) from error
+
 
 def warning(text: str) -> None:
     fore_yellow()
@@ -145,6 +124,7 @@ def warning(text: str) -> None:
     print(text)
     ansi_reset()
 
+
 def info(text: str) -> None:
     fore_cyan()
     print('[i]', end = ' ')
@@ -152,6 +132,7 @@ def info(text: str) -> None:
     print(text)
     ansi_reset()
 
+
 def clear():
     # for windows
     if os.name == 'nt':
@@ -160,6 +141,7 @@ def clear():
     # 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'

{exprmat-0.1.12 → exprmat-0.1.15}/exprmat/data/finders.py

@@ -31,7 +31,7 @@ def get_genome(taxa):
     genome[taxa]['genes'] = pandas.read_table(
         os.path.join(basepath, f'{taxa}', 'genome.tsv.gz'),
         # set low memory to false to allow correct adjustment to mixed dtype.
-        index_col = '.ugene', dtype = {'.seqid': str}
+        index_col = '.ugene', dtype = {'.seqid': str}, low_memory = False
     )
 
     return genome[taxa]['genes']
@@ -142,7 +142,10 @@ def update_mapper(taxa, name, ens):
     if (name not in genome[taxa]['mapper.name'].keys()):
         if (ens in genome[taxa]['mapper.ensembl'].keys()):
             genome[taxa]['mapper.name'][name] = genome[taxa]['mapper.ensembl'][ens]
-        else: info(f'{ens} -> {name} pair could not be established.')
+        else: 
+            # info(f'{ens} -> {name} pair could not be established.')
+            # this info log is too noisy.
+            pass
 
     else:
         if (ens not in genome[taxa]['mapper.ensembl'].keys()):

exprmat-0.1.15/exprmat/data/presets.py

@@ -0,0 +1,44 @@
+
+s_gene_sets = {
+    'mmu': [ # the original list
+        'Atad2', 'Blm', 'Brip1', 'Casp8ap2', 'Ccne2', 'Cdc45', 'Cdc6', 'Cdca7', 
+        'Chaf1b', 'Clspn', 'Dscc1', 'Dtl', 'E2f8', 'Exo1', 'Fen1', 'Gins2', 'Gmnn', 
+        'Hells', 'Mcm2', 'Mcm4', 'Mcm5', 'Mcm6', 'Msh2', 'Nasp', 'Pcna', 'Pola1', 
+        'Pold3', 'Prim1', 'Rad51', 'Rad51ap1', 'Rfc2', 'Rpa2', 'Rrm1', 'Rrm2', 
+        'Slbp', 'Tipin', 'Tyms', 'Ubr7', 'Uhrf1', 'Ung', 'Usp1', 'Wdr76'
+    ],
+    'hsa': [ # translated from mice
+        'MCM5', 'PCNA', 'TYMS', 'FEN1', 'MCM2', 'MCM4', 'RRM1', 'UNG', 'GINS2', 
+        'MCM6', 'CDCA7', 'DTL', 'PRIM1', 'UHRF1', 'MLF1IP', 'HELLS', 'RFC2', 
+        'RPA2', 'NASP', 'RAD51AP1', 'GMNN', 'WDR76', 'SLBP', 'CCNE2', 'UBR7', 
+        'POLD3', 'MSH2', 'ATAD2', 'RAD51', 'RRM2', 'CDC45', 'CDC6', 'EXO1', 
+        'TIPIN', 'DSCC1', 'BLM', 'CASP8AP2', 'USP1', 'CLSPN', 'POLA1', 'CHAF1B', 
+        'BRIP1', 'E2F8'
+    ]
+}
+
+g2m_genesets = {
+    'mmu': [
+        'Anln', 'Anp32e', 'Aurka', 'Aurkb', 'Birc5', 'Bub1', 'Cbx5', 'Ccnb2', 
+        'Cdc20', 'Cdc25c', 'Cdca2', 'Cdca3', 'Cdca8', 'Cdk1', 'Cenpa', 'Cenpe', 
+        'Cenpf', 'Ckap2', 'Ckap2l', 'Ckap5', 'Cks1b', 'Cks2', 'Ctcf', 'Dlgap5', 
+        'Ect2', 'G2e3', 'Gas2l3', 'Gtse1', 'Hjurp', 'Hmgb2', 'Hmmr', 'Kif11', 
+        'Kif20b', 'Kif23', 'Kif2c', 'Lbr', 'Mki67', 'Ncapd2', 'Ndc80', 'Nek2', 
+        'Nuf2', 'Nusap1', 'Psrc1', 'Rangap1', 'Smc4', 'Tacc3', 'Tmpo', 'Top2a', 
+        'Tpx2', 'Ttk', 'Tubb4b', 'Ube2c'
+    ],
+    'hsa': [
+        'HMGB2', 'CDK1', 'NUSAP1', 'UBE2C', 'BIRC5', 'TPX2', 'TOP2A', 'NDC80', 
+        'CKS2', 'NUF2', 'CKS1B', 'MKI67', 'TMPO', 'CENPF', 'TACC3', 'FAM64A', 
+        'SMC4', 'CCNB2', 'CKAP2L', 'CKAP2', 'AURKB', 'BUB1', 'KIF11', 'ANP32E', 
+        'TUBB4B', 'GTSE1', 'KIF20B', 'HJURP', 'CDCA3', 'HN1', 'CDC20', 'TTK', 
+        'CDC25C', 'KIF2C', 'RANGAP1', 'NCAPD2', 'DLGAP5', 'CDCA2', 'CDCA8', 
+        'ECT2', 'KIF23', 'HMMR', 'AURKA', 'PSRC1', 'ANLN', 'LBR', 'CKAP5', 'CENPE', 
+        'CTCF', 'NEK2', 'G2E3', 'GAS2L3', 'CBX5', 'CENPA'
+    ]
+}
+
+preset_genesets = {
+    's': s_gene_sets,
+    'g2m': g2m_genesets
+}

exprmat-0.1.15/exprmat/descriptive/tcr.py

@@ -0,0 +1,108 @@
+
+import numpy as np
+from exprmat.ansi import error, warning
+
+
+# expansion index for cluster.
+# maximal value if the cluster is `dominant` for a single clonotype e.g. mait cells.
+
+def clone_cluster_matrix(adata, clonotype = 'clone.id', cluster = 'leiden'):
+
+    clono_ids = adata.obs[clonotype].value_counts().index.tolist()
+    clust_ids = adata.obs[cluster].value_counts().index.tolist()
+    clono_col = adata.obs[clonotype]
+    clust_col = adata.obs[cluster]
+    mat = np.ndarray(shape = (len(clono_ids), len(clust_ids)), dtype = np.float32)
+    
+    for j, cs in enumerate(clust_ids):
+        specific_cluster = clono_col[clust_col == cs].copy()
+        clono_stat = specific_cluster.value_counts()
+
+        for i, cl in enumerate(clono_ids):
+            if cl in clono_stat.index: mat[i, j] = clono_stat[cl]
+            else: mat[i, j] = 0
+
+    return mat, clono_ids, clust_ids
+
+
+def expansion(adata, clonotype = 'clone.id', cluster = 'leiden', key = 'tcr.cluster.expansion'):
+    
+    mat, clono_ids, clust_ids = clone_cluster_matrix(adata, clonotype = clonotype, cluster = cluster)
+    adata.obs[key] = 0
+
+    for j, cs in enumerate(clust_ids):
+        props = mat[:, j] / np.sum(mat[:, j])
+        props = props[np.nonzero(mat[:, j])]
+        
+        if np.sum(mat[:, j]) < 5: 
+            adata.obs.loc[adata.obs[cluster] == cs, key] = 0
+        else:
+            shannon_e = - np.sum(props * np.log2(props))
+            adata.obs.loc[adata.obs[cluster] == cs, key] = 1 - (shannon_e / np.log2(len(props)))
+
+
+def plasticity(adata, clonotype = 'clone.id', cluster = 'leiden', key = 'tcr.cluster.plasticity'):
+
+    mat, clono_ids, clust_ids = clone_cluster_matrix(adata, clonotype = clonotype, cluster = cluster)
+    adata.obs[key] = 0
+
+    for j, cs in enumerate(clust_ids):
+        # select all clones that present in this cluster
+        submat = mat[mat[:, j] > 0, :]
+        submat = (submat.T / submat.sum(axis = 1)).T # row normalize
+        overall = submat.sum(axis = 0)
+        overall = overall / overall.sum()
+        overall = overall[np.nonzero(overall)]
+        # completely deterministic, 0. completely random, 1.
+
+        if np.sum(mat[:, j]) < 5: 
+            adata.obs.loc[adata.obs[cluster] == cs, key] = 0
+        else:
+            shannon_e = - np.sum(overall * np.log2(overall))
+            adata.obs.loc[adata.obs[cluster] == cs, key] = shannon_e
+
+
+def pairwise_transition(
+    adata, base,  clonotype = 'clone.id', cluster = 'leiden', 
+    key = 'tcr.cluster.ptrans'
+):
+
+    mat, clono_ids, clust_ids = clone_cluster_matrix(adata, clonotype = clonotype, cluster = cluster)
+    adata.obs[key] = 0
+    baseid = clust_ids.index(base)
+
+    for j, cs in enumerate(clust_ids):
+        if j == baseid: continue
+
+        # select all clones that present in this cluster
+        submat = mat[mat[:, j] + mat[:, baseid] > 0, :]
+        submat = submat[:, [baseid, j]]
+        either_zero = (submat[:, 0] == 0) | (submat[:, 1] == 0)
+        weights = submat[:, 0] + submat[:, 1]
+        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]))
+        shannon_e[either_zero] = 0
+        adata.obs.loc[adata.obs[cluster] == cs, key] = np.sum(shannon_e * weights)
+
+
+# per clone statistics
+
+def transition(adata, clonotype = 'clone.id', cluster = 'leiden', key = 'tcr.clone.trans'):
+
+    mat, clono_ids, clust_ids = clone_cluster_matrix(adata, clonotype = clonotype, cluster = cluster)
+    adata.obs[key] = 0
+
+    for i, cl in enumerate(clono_ids):
+        props = mat[i, :] / np.sum(mat[i, :])
+        props = props[np.nonzero(mat[i, :])]
+        shannon_e = - np.sum(props * np.log2(props))
+        adata.obs.loc[adata.obs[clonotype] == cl, key] = shannon_e
+
+
+
+
+def migration(adata, clonotype = 'clone.id', cluster = 'tissue', key = 'tcr.clone.migr'):
+    # completely the same.
+    transition(adata, clonotype = clonotype, cluster = cluster, key = key)

exprmat-0.1.15/exprmat/dynamics/__init__.py

@@ -0,0 +1,51 @@
+
+from exprmat.dynamics.preprocess import filter_and_normalize
+from exprmat.dynamics.pseudotime import velocity_pseudotime, terminal_states
+from exprmat.dynamics.transition import transition_matrix
+from exprmat.dynamics.moments import moments
+from exprmat.dynamics.velocity import velocity, velocity_confidence, velocity_embedding, velocity_graph
+from exprmat.dynamics.generank import rank_velocity_genes
+
+
+def run_velocity(
+    adata, 
+    neighbor_key = 'neighbors', neighbor_connectivity = 'connectivities', n_neighbors = 35, 
+    hvg = 'vst.norm', 
+    velocity_key = 'velocity',
+    n_cpus = None,
+    kwargs_filter = { 'enforce': False },
+    kwargs_velocity = {},
+    kwargs_velocity_graph = {},
+    kwargs_terminal_state = {},
+    kwargs_pseudotime = { 'save_diffmap': True },
+):
+    if (
+        ('spliced.counts' not in adata.layers.keys()) and 
+        ('unspliced.counts' not in adata.layers.keys())
+    ):
+        filter_and_normalize(adata, **kwargs_filter)
+    
+    moments(adata, neighbor_key = neighbor_key, mode = neighbor_connectivity)
+    
+    velocity(
+        adata, 
+        vkey = velocity_key, 
+        use_highly_variable = hvg, 
+        neighbor_key = neighbor_key, 
+        **kwargs_velocity
+    )
+
+    velocity_graph(
+        adata, 
+        n_jobs = n_cpus, 
+        vkey = velocity_key,
+        neighbor_key = neighbor_key,
+        mode_neighbors = neighbor_connectivity,
+        n_neighbors = n_neighbors,
+        **kwargs_velocity_graph
+    )
+
+    terminal_states(adata, vkey = velocity_key, neighbor_key = neighbor_key, **kwargs_terminal_state)
+    velocity_pseudotime(adata, vkey = velocity_key, neighbor_key = neighbor_key, **kwargs_pseudotime)
+    velocity_confidence(adata, vkey = velocity_key, neighbor_key = neighbor_key)
+