exprmat 0.1.40__tar.gz → 0.1.42__tar.gz

{exprmat-0.1.40 → exprmat-0.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.1.40
+Version: 0.1.42
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/ansi.py

@@ -1,6 +1,7 @@
 
 import re
 import os
+import sys
 
 from functools import partial
 from tqdm import tqdm
@@ -91,12 +92,12 @@ def common_length(string: str, limit: int) -> str:
         return x_str
     
     elif len(string) + cn_length > limit:
-        x_str = string[-(limit - 4):]
+        x_str = string[-(limit - 3):]
         cn = len(re.findall(cn_re, x_str))
-        while cn + len(x_str) > limit - 4:
+        while cn + len(x_str) > limit - 3:
             x_str = x_str[1:]
             cn = len(re.findall(cn_re, x_str))
-        return '... ' + x_str
+        return '.. ' + x_str
         
     else: return ('{:<' + str(limit - cn_length) + '}').format(string)
 
@@ -161,7 +162,8 @@ def cyan(x): return '\033[36m' + x + '\033[0m'
 progress_styles = {
     'ncols': 80,
     'ascii': '-━',
-    'bar_format': '   {bar} {desc:20} {n:5d} / {total:<5d} ({elapsed} < {remaining})'
+    'bar_format': '   {bar} {desc:20} {n:5d} / {total:<5d} ({elapsed} < {remaining})',
+    'file': sys.stderr
 }
 
 pprog = partial(tqdm, **progress_styles)

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/preprocessing/linear.py

@@ -68,7 +68,9 @@ def normalize_total(
     if target_total is None:
         target_total = np.mean(tots_use)
 
-    b = np.array(float(target_total) / tots_use.T)[0]
+    b = np.array(float(target_total) / tots_use.T)
+    if len(b.shape) == 2: b = b[0]
+    
     if not sp.issparse(E):
         # this will densify the matrix, causing incredibly large memory comsumption
         # when treating with an sparse matrix.

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/preprocessing/qc.py

@@ -129,9 +129,9 @@ def rna_qc(
     elif outlier_mode == 'tukey':
         umi_lower, umi_upper = tukey(adata.obs['n.umi'].to_numpy(), n = outlier_n)
     elif isinstance(outlier_mode, int):
-        umi_lower, umi_upper = 200, 100000
+        umi_lower, umi_upper = 200, 2147483646
         max_genes = outlier_mode
-    else: umi_lower, umi_upper = 200, 100000
+    else: umi_lower, umi_upper = 200, 2147483646
 
     f_obs = \
         (adata.obs['n.umi'] <= umi_upper) & \
@@ -152,10 +152,10 @@ def rna_qc(
     
     doublet_failed = False
     if doublet_method == 'scrublet':
-        try:
+        # try:
             scrublet_init(subset, random_state = 42)
             scrublet(subset)
-        except: doublet_failed = True
+        # except: doublet_failed = True
     
     adata.obs['filter'] = f_obs
     adata.obs['score.doublet'] = 0.0

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/reader/experiment.py

@@ -25,11 +25,11 @@ import os
 from exprmat.reader.metadata import metadata, load_metadata
 from exprmat.data.finders import get_genome
 from exprmat.reader.matcher import (
-    read_mtx_rna, read_h5ad_rna, read_table_rna, 
+    read_mtx_rna, read_h5ad_rna, read_table_rna, read_h5_rna,
     parse_tcr_10x, attach_splice_reads_mtx, attach_splice_reads_loom
 )
 from exprmat.reader.matcher import attach_tcr
-from exprmat.ansi import warning, info, error, red, green
+from exprmat.ansi import warning, info, error, red, green, pprog
 from exprmat import config as cfg
 import exprmat.reader.static as st
 import exprmat as em
@@ -44,10 +44,6 @@ class experiment:
         dump = '.', subset = None,
         version = em.SPECIFICATION
     ):
-        
-        from exprmat.reader.updater import update
-        version = update(meta, modalities, mudata, version)
-
         # TODO: we support rna only at present.
         table = meta.dataframe.to_dict(orient = 'list')
         self.mudata = mudata
@@ -100,21 +96,41 @@ class experiment:
                 # we automatically infer from the given location names to select
                 # the correct way of loading samples:
 
-                if i_loc.endswith('.tsv.gz') or i_loc.endswith('.csv.gz') or \
-                    i_loc.endswith('.tsv') or i_loc.endswith('.csv'):
+                if i_loc.endswith('.tsv.gz') or i_loc.endswith('.tsv'):
 
                     self.modalities['rna'][i_sample] = read_table_rna(
                         src = i_loc, metadata = meta, sample = i_sample,
-                        raw = False, default_taxa = i_taxa, eccentric = eccentric
+                        raw = False, default_taxa = i_taxa, eccentric = eccentric, sep = '\t'
+                    )
+
+                elif i_loc.endswith('.csv.gz') or i_loc.endswith('.csv'):
+
+                    self.modalities['rna'][i_sample] = read_table_rna(
+                        src = i_loc, metadata = meta, sample = i_sample,
+                        raw = False, default_taxa = i_taxa, eccentric = eccentric, sep = ','
+                    )
+                
+                elif i_loc.endswith('.ssv.gz') or i_loc.endswith('.ssv'):
+
+                    self.modalities['rna'][i_sample] = read_table_rna(
+                        src = i_loc, metadata = meta, sample = i_sample,
+                        raw = False, default_taxa = i_taxa, eccentric = eccentric, sep = ' '
                     )
 
-                elif i_loc.endswith('.h5') or i_loc.endswith('.h5ad'):
+                elif i_loc.endswith('.h5ad'):
 
                     self.modalities['rna'][i_sample] = read_h5ad_rna(
                         src = i_loc, metadata = meta, sample = i_sample,
                         raw = False, default_taxa = i_taxa
                     )
 
+                elif i_loc.endswith('.h5'):
+                    
+                    self.modalities['rna'][i_sample] = read_h5_rna(
+                        src = i_loc, metadata = meta, sample = i_sample,
+                        raw = False, default_taxa = i_taxa, eccentric = eccentric
+                    )
+
                 else:
                     self.modalities['rna'][i_sample] = read_mtx_rna(
                         src = i_loc, prefix = '', metadata = meta, sample = i_sample,
@@ -265,6 +281,15 @@ class experiment:
             else: warning(f'sample {i_sample} have no supported modalities')
 
 
+        self.metadata.dataframe = self.metadata.dataframe.loc[
+            self.metadata.dataframe['modality'] != 'rna.splicing', :
+        ].copy()
+        
+        self.metadata.dataframe = self.metadata.dataframe.loc[
+            self.metadata.dataframe['modality'] != 'rna.tcr', :
+        ].copy()
+
+
         # attaching bulk datasets.
 
         for i_mod in ['rna-bulk', 'atac-bulk']:
@@ -894,6 +919,8 @@ class experiment:
                 p.imap_unordered(partial_task, args),
                 total = len(args), desc = 'processing anndata'
             ))
+
+            p.close()
             
             results = {}
             for data, key, out in output:
@@ -1434,6 +1461,9 @@ class experiment:
 
     def run_rna_umap(self, run_on_samples = False, **kwargs):
         self.do_for_rna(run_on_samples, st.rna_umap, **kwargs)
+    
+    def run_rna_diffmap(self, run_on_samples = False, **kwargs):
+        self.do_for_rna(run_on_samples, st.rna_diffmap, **kwargs)
 
     def run_rna_mde(self, run_on_samples = False, **kwargs):
         self.do_for_rna(run_on_samples, st.rna_mde, **kwargs)
@@ -2292,7 +2322,7 @@ class experiment:
 
     def __repr__(self):
 
-        from exprmat.ansi import green, cyan, red, yellow
+        from exprmat.ansi import green, cyan, red, yellow, common_length
 
         def print_anndata(adata: ad.AnnData):
             print(yellow('annotated data'), 'of size', adata.n_obs, '×', adata.n_vars)
@@ -2376,6 +2406,7 @@ class experiment:
             print(red('[*]'), 'composed of samples:')
             len_mod = 2
             len_batch = 2
+            len_sample = 2
             
             for i_loc, i_sample, i_batch, i_grp, i_mod, i_taxa in zip(
                 self.metadata.dataframe['location'], 
@@ -2387,6 +2418,10 @@ class experiment:
             ):
                 if len(i_mod) > len_mod: len_mod = len(i_mod)
                 if len(i_batch) > len_batch: len_batch = len(i_batch)
+                if len(i_sample) > len_sample: len_sample = len(i_sample)
+
+            if len_batch > 30: len_batch = 30
+            if len_sample > 30: len_sample = 30
 
             for i_loc, i_sample, i_batch, i_grp, i_mod, i_taxa in zip(
                 self.metadata.dataframe['location'], 
@@ -2406,8 +2441,12 @@ class experiment:
                 p_sample = i_sample if len(i_sample) < 30 else i_sample[:27] + ' ..'
                 p_batch = i_batch if len(i_batch) < 30 else i_batch[:27] + ' ..'
                 print(
-                    f'  {p_sample:30}', cyan(f'{i_mod:13}'), yellow(f'{i_taxa:4}'),
-                    f'batch {green(f"{p_batch:12}")}',
+                    ' ',
+                    common_length(i_sample, len_sample), ' ',
+                    cyan(common_length(i_mod, len_mod)), 
+                    yellow(f'{i_taxa:4}'), ' ',
+                    f'batch {green(common_length(i_batch, len_batch))}', ' ',
+                    'of size',
                     red('dataset not loaded') if not loaded else 
                     f'{green(str(self.modalities[i_mod][i_sample].n_obs))} × ' +
                     f'{yellow(str(self.modalities[i_mod][i_sample].n_vars))}'
@@ -2439,9 +2478,22 @@ def load_experiment(direc, load_samples = True, load_subset = None):
     # read individual modality and sample
     meta = load_metadata(os.path.join(direc, 'metadata.tsv'))
 
+    # load specification
+    version = load_experiment_specification(direc)
+    
+    # update the object to the newest version
+    from exprmat.reader.updater import update
+    version = update(meta, direc, version)
+
+    meta.dataframe = meta.dataframe.loc[
+        ['.' not in x for x in meta.dataframe['modality']], :
+    ].copy()
+
     modalities = {}
     if load_samples:
+        prog = pprog(desc = 'loading samples', total = len(meta.dataframe['sample']))
         for modal, samp in zip(meta.dataframe['modality'], meta.dataframe['sample']):
+            prog.update()
             if '.' in modal: continue
             attempt = os.path.join(direc, modal, samp + '.h5ad')
             if os.path.exists(attempt):
@@ -2459,9 +2511,6 @@ def load_experiment(direc, load_samples = True, load_subset = None):
         if os.path.exists(os.path.join(direc, 'subsets', load_subset + '.h5mu')):
             mdata = mu.read_h5mu(os.path.join(direc, 'subsets', load_subset + '.h5mu'))
 
-    # load specification
-    version = load_experiment_specification(direc)
-    
     expr = experiment(
         meta = meta, 
         mudata = mdata, 

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/reader/matcher.py

@@ -310,7 +310,7 @@ def read_mtx_rna(
 
 
 def read_h5_rna(
-    path: str, 
+    src: str, 
     metadata: metadata, sample: str, raw: bool = False,
     default_taxa = 'mmu', eccentric = None, suppress_filter = False,
 ):
@@ -318,7 +318,7 @@ def read_h5_rna(
     warnings.filterwarnings('ignore')
 
     adata = sc.read_10x_h5(
-        path, gex_only = True
+        src, gex_only = True
     )
 
     adata.var_names = adata.var['gene_ids'].tolist()
@@ -346,7 +346,7 @@ def read_h5_rna(
 def read_table_rna(
     src: str, 
     metadata: metadata, sample: str, raw: bool = False,
-    default_taxa = 'mmu', eccentric = None
+    default_taxa = 'mmu', eccentric = None, sep = '\t'
 ):
     '''
     Read from compressed or plain text tables.
@@ -374,7 +374,7 @@ def read_table_rna(
     
     # in csv/tsv texts, genes are rows and cells are columns.
     adata = sc.read_text(
-        src, delimiter = '\t', first_column_names = True, dtype = 'float32'
+        src, delimiter = sep, first_column_names = True, dtype = 'float32'
     ).T
 
     if eccentric is not None:

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/reader/static.py

@@ -182,16 +182,17 @@ def rna_scvi(
     # save the model
     import os
     if sample_name == 'integrated':
-        attempt = os.path.join(savepath, 'scvi')
-    else: attempt = os.path.join(savepath, 'rna', 'scvi', sample_name)
+        attempt = os.path.join(savepath, 'scvi', key_added)
+    else: attempt = os.path.join(savepath, 'rna', 'scvi', sample_name, key_added)
     
     os.makedirs(attempt, exist_ok = True)
     model.save(attempt, overwrite = True)
     adata.obsm[key_added] = latent
 
     adata.uns[key_added] = {
-        'model': savepath,
+        'model': attempt,
         'n_latent': n_comps,
+        'batch_key': batch,
         'type': 'scvi'
     }
     
@@ -232,6 +233,11 @@ def rna_umap(adata, sample_name, **kwargs):
     run_umap(adata, **kwargs)
 
 
+def rna_diffmap(adata, sample_name, **kwargs):
+    from exprmat.reduction.diffmap import run_diffmap
+    run_diffmap(adata, **kwargs)
+
+
 def rna_mde(adata, sample_name, data = 'pca', key_added = 'mde', **kwargs):
     from exprmat.reduction.mde import mde
     emb = mde(adata.obsm[data], **kwargs)

exprmat-0.1.42/exprmat/reader/updater.py

@@ -0,0 +1,111 @@
+
+import os
+import h5py
+from anndata.io import read_elem, write_elem
+
+import exprmat as em
+from exprmat.ansi import error, warning, info
+
+VERSION_CHECKPOINT = [1, em.SPECIFICATION]
+
+
+def update(meta, dump, version):
+
+    # current version
+    if version == em.SPECIFICATION: return version
+
+    # valid version
+    elif version in VERSION_CHECKPOINT:
+        ckpt = VERSION_CHECKPOINT.index(version)
+        for taskid in range(ckpt, len(VERSION_CHECKPOINT) - 1):
+            task = UPDATE_TASK[taskid]
+            info(f'updating experiment dump from {version} to {VERSION_CHECKPOINT[taskid + 1]} ...')
+            
+            # update samples
+            for irow in range(len(meta.dataframe)):
+                metadata = meta.dataframe.iloc[irow, :].copy()
+                if '.' in metadata['modality']: continue
+                info(f'updating sample ./{metadata["modality"]}/{metadata["sample"]} ...')
+                task(metadata['modality'], os.path.join(dump, metadata["modality"], metadata["sample"] + '.h5ad'))
+            
+            # update subsets
+            if os.path.exists(os.path.join(dump, 'subsets')):
+                for subset in os.listdir(os.path.join(dump, 'subsets')):
+                    if not subset.endswith('.h5mu'): continue
+                    if subset.startswith('.'): continue
+                    info(f'updating subset {subset.replace(".h5mu", "")} ...')
+                    task('subset', os.path.join(dump, 'subsets', subset))
+            
+            if os.path.exists(os.path.join(dump, 'integrated.h5mu')):
+                info(f'updating integrated dataset ...')
+                task('integrated', os.path.join(dump, 'integrated.h5mu'))
+
+
+        return VERSION_CHECKPOINT[taskid + 1]
+    
+    # invalid version
+    else: error(f'illegal version specification of experiment dump: [{version}]')
+
+
+def update_39(mod, fpath):
+
+    def update_rna_var(table):
+        if 'ensembl' in table.columns:
+            import pandas as pd
+            obsn = table[['ensembl']].copy()
+            taxa = obsn.index.tolist()[0].split(':')[1]
+            from exprmat.data.finders import get_genome
+            gtable = get_genome(taxa)
+            gtable.index = gtable['id'].tolist()
+            obsn = obsn.join(gtable, on = 'ensembl', how = 'left')
+            assert len(obsn) == len(table)
+            del obsn['ensembl']
+
+            old_columns = [
+                '.seqid', '.source', '.type', '.start', '.end', '.score', '.strand', '.phase',
+                'biotype', 'source', 'gene', 'description', 'ensembl', 'uid', 'version', 'len.mean',
+                'len.median', 'len.cds', '.ucsc'
+            ]
+
+            for o in old_columns:
+                if o in table.columns: del table[o]
+            return pd.concat([obsn, table], axis = 1)
+
+    def update_atac_var(table):
+        return table.rename(columns = {
+            '.seqid': 'chr',
+            '.start': 'start',
+            '.end': 'end',
+        }, inplace = False)
+
+
+    file = h5py.File(fpath, 'r+')
+
+    if mod in ['subset', 'integrated']:
+        for m in list(file['mod'].keys()):
+            if m in ['rna', 'rnasp-b', 'rnasp-c', 'rnasp-s', 'atac-g']:
+                table = read_elem(file['mod'][m]['var'])
+                table = update_rna_var(table)
+                write_elem(file['mod'][m], 'var', table)
+            
+            elif m in ['atac', 'atac-p']:
+                table = read_elem(file['mod'][m]['var'])
+                table = update_atac_var(table)
+                write_elem(file['mod'][m], 'var', table)
+    
+    if mod in ['rna', 'rnasp-b', 'rnasp-c', 'rnasp-s', 'atac-g']:
+        table = read_elem(file['var'])
+        table = update_rna_var(table)
+        write_elem(file, 'var', table)
+    
+    elif mod in ['atac', 'atac-p']:
+        table = read_elem(file['var'])
+        table = update_atac_var(table)
+        write_elem(file, 'var', table)
+    
+    file.close()
+
+
+UPDATE_TASK = [
+    update_39
+]

exprmat-0.1.42/exprmat/reduction/diffmap.py

@@ -0,0 +1,73 @@
+
+
+def run_diffmap(
+    adata, *, neighbors_key = None, key_added = 'diffmap', 
+    n_comps = 3, sort = 'decrease', density_normalize = True,
+    use_gpu = False
+):
+
+    if use_gpu:
+
+        import cupy as cp
+        from cupyx.scipy import sparse
+        from cupyx.scipy.sparse import linalg
+        from scipy.sparse import issparse
+
+        if neighbors_key:
+            connectivities = adata.obsp[adata.uns[neighbors_key]['connectivities_key']]
+        else: connectivities = adata.obsp["connectivities"]
+        
+        if issparse(connectivities):
+            W = sparse.csr_matrix(connectivities, dtype = cp.float32)
+        else: W = cp.asarray(connectivities)
+
+        if density_normalize:
+            # q[i] is an estimate for the sampling density at point i
+            # it's also the degree of the underlying graph
+            q = cp.asarray(W.sum(axis=0))
+            if not sparse.issparse(W): Q = cp.diag(1.0 / q)
+            else: Q = sparse.spdiags(1.0 / q, 0, W.shape[0], W.shape[0])
+            K = Q @ W @ Q
+
+        else: K = W
+
+        # z[i] is the square root of the row sum of K 
+        z = cp.sqrt(cp.asarray(K.sum(axis=0)))
+
+        if not sparse.issparse(K): Z = cp.diag(1.0 / z)
+        else: Z = sparse.spdiags(1.0 / z, 0, K.shape[0], K.shape[0])
+        matrix = Z @ K @ Z
+
+        if n_comps == 0: evals, evecs = linalg.eigsh(matrix)
+        
+        else:
+            n_comps = min(matrix.shape[0] - 1, n_comps)
+            # ncv = max(2 * n_comps + 1, int(np.sqrt(matrix.shape[0])))
+            ncv = None
+            which = "LM" if sort == "decrease" else "SM"
+            # it pays off to increase the stability with a bit more precision
+            matrix = matrix.astype(cp.float64)
+            evals, evecs = linalg.eigsh(matrix, k=n_comps, which=which, ncv=ncv)
+            evals, evecs = evals.astype(cp.float32), evecs.astype(cp.float32)
+        
+        if sort == "decrease":
+            evals = evals[::-1]
+            evecs = evecs[:, ::-1]
+        
+        adata.uns[key_added] = evals.get()
+        adata.obsm[key_added] = evecs.get()
+        del W, Q, Z, K, evals, evecs, matrix, z
+    
+    else:
+
+        import scanpy as sc
+        sc.tl.diffmap(
+            adata, n_comps = n_comps,
+            neighbors_key = neighbors_key
+        )
+
+        adata.obsm[key_added] = adata.obsm['X_diffmap']
+        del adata.obsm['X_diffmap']
+
+        adata.uns[key_added] = adata.uns['diffmap_evals']
+        del adata.uns['diffmap_evals']

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/reduction/plot.py

@@ -58,6 +58,7 @@ class index_object_handler:
 
 def embedding_atlas(
     adata, basis, color,
+    embedding_dims = [0, 1],
     hue_order = None,
     title = None, figsize = (4, 4), ax = None,
     cmap = 'turbo', cmap_reverse = False, cmap_lower = '#000000',
@@ -76,6 +77,10 @@ def embedding_atlas(
 
     cvs = ds.Canvas(plot_width = int(figsize[0] * dpi * res_factor), plot_height = int(figsize[1] * dpi * res_factor))
     embedding = adata.obsm[basis]
+    if isinstance(embedding, pd.DataFrame):
+        embedding = embedding.iloc[:, embedding_dims].copy()
+    else: embedding = embedding[:, embedding_dims].copy()
+
     df = pd.DataFrame(embedding, columns=['x', 'y'])
 
     if color in adata.obs.columns:
@@ -287,7 +292,7 @@ def embedding_atlas(
 
 def embedding(
     adata, basis, color,
-    slot = 'X',
+    slot = 'X', embedding_dims = [0, 1],
     
     # query plotting options
     ptsize = 8,
@@ -343,7 +348,8 @@ def embedding(
         embedding = basis.data 
     elif isinstance(basis, np.matrix) or isinstance(basis, np.ndarray):
         embedding = basis
-
+    
+    embedding = embedding[:, embedding_dims].copy()
     df = pd.DataFrame(embedding, columns = ['x', 'y'])
 
     if color in adata.obs.columns:

{exprmat-0.1.40 → exprmat-0.1.42}/exprmat/reduction/scvi.py

@@ -57,29 +57,27 @@ def scvi(
     )
 
     import warnings
-    import contextlib
     with warnings.catch_warnings():
         warnings.simplefilter('ignore')
-        with contextlib.redirect_stderr(None):
-            model.train(
-                max_epochs = max_epochs, 
-                accelerator = accelerator, 
-                devices = devices, 
-                train_size = train_size, 
-                validation_size = validation_size, 
-                shuffle_set_split = shuffle_set_split, 
-                load_sparse_tensor = load_sparse_tensor, 
-                batch_size = batch_size, 
-                early_stopping = early_stopping, 
-                datasplitter_kwargs = datasplitter_kwargs, 
-                plan_kwargs = plan_kwargs, 
-                datamodule = datamodule,
-                enable_progress_bar = enable_progress_bar, 
-                progress_bar_refresh_rate = progress_bar_refresh_rate, 
-                simple_progress_bar = simple_progress_bar, 
-                logger = logger, 
-                log_every_n_steps = log_every_n_steps,
-            )
+        model.train(
+            max_epochs = max_epochs, 
+            accelerator = accelerator, 
+            devices = devices, 
+            train_size = train_size, 
+            validation_size = validation_size, 
+            shuffle_set_split = shuffle_set_split, 
+            load_sparse_tensor = load_sparse_tensor, 
+            batch_size = batch_size, 
+            early_stopping = early_stopping, 
+            datasplitter_kwargs = datasplitter_kwargs, 
+            plan_kwargs = plan_kwargs, 
+            datamodule = datamodule,
+            enable_progress_bar = enable_progress_bar, 
+            progress_bar_refresh_rate = progress_bar_refresh_rate, 
+            simple_progress_bar = simple_progress_bar, 
+            logger = logger, 
+            log_every_n_steps = log_every_n_steps,
+        )
 
     latent = model.get_latent_representation()
     return model, latent

{exprmat-0.1.40 → exprmat-0.1.42}/pyproject.toml

@@ -20,7 +20,7 @@ description = "exprmat: Routines for expression matrices"
 readme = "readme.md"
 license = {file = "license"}
 requires-python = ">=3.9, <3.13"
-version = "0.1.40"
+version = "0.1.42"
 authors = [
     {name = "Zheng Yang", email = "xornent@outlook.com"}
 ]