exprmat 0.1.36__tar.gz → 0.1.38__tar.gz

{exprmat-0.1.36 → exprmat-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exprmat
-Version: 0.1.36
+Version: 0.1.38
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -55,7 +55,6 @@ Requires-Dist: hdbscan
 Requires-Dist: graphtools
 Requires-Dist: bincsync>=0.3.0
 Requires-Dist: pybigwig
-Requires-Dist: pybedgraph
 Requires-Dist: loompy
 Requires-Dist: squidpy
 Requires-Dist: zarr
@@ -74,6 +73,7 @@ Requires-Dist: pymemesuite
 Requires-Dist: formulaic>=1.0.2
 Requires-Dist: formulaic-contrasts>=0.2.0
 Requires-Dist: cython
+Requires-Dist: pyfastx
 Requires-Dist: sphinx ; extra == 'dev'
 Requires-Dist: twine ; extra == 'dev'
 Requires-Dist: ipykernel ; extra == 'dev'

{exprmat-0.1.36 → exprmat-0.1.38}/exprmat/__init__.py

@@ -128,6 +128,26 @@ if PERFORM_DATABASE_CHECK:
         warning(f'db version: {db_ver}  package version: {importlib.metadata.version("exprmat")}')
 
 
+def cuda():
+
+    import torch
+    info(f'PyTorch version: {torch.__version__}')
+    info(f'GPU acceleration availability: {"YES" if torch.cuda.is_available() else "NO"}')
+    if torch.cuda.is_available():
+        info(f'CUDA version: {torch.version.cuda}')
+        info(f'Number of installed GPUs: {torch.cuda.device_count()}')
+        info(f'Supporting BF16 format: {"YES" if torch.cuda.is_bf16_supported() else "NO"}')
+        info(f'Devices:')
+        for i in range(torch.cuda.device_count()):
+            total_mem = torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024
+            dedicated_mem = torch.cuda.memory_allocated(i) / 1024 / 1024 / 1024
+            info(f'[{i}] {torch.cuda.get_device_name(i)} {"*" if torch.cuda.current_device() == i else ""}')
+            info(f'    CUDA capability: {torch.cuda.get_device_capability(i)}')
+            info(f'    Installed VRAM (GiB): {total_mem:.2f} GiB')
+            info(f'    Supporting TensorCore: {"YES" if torch.cuda.get_device_properties(0).major >= 7 else "NO"}')
+            info(f'    Current dedicated memory: {dedicated_mem:.2f} / {total_mem:.2f} GiB ({100 * dedicated_mem / total_mem:.1f}%)')
+
+
 def version(): 
     import os
     import sys

{exprmat-0.1.36 → exprmat-0.1.38}/exprmat/data/presets.py

@@ -40,5 +40,40 @@ g2m_genesets = {
 
 preset_genesets = {
     's': s_gene_sets,
-    'g2m': g2m_genesets
+    'g2m': g2m_genesets,
+    'custom': {
+        'mmu': {
+            't': [
+                'Cd3d', 'Cd8a', 'Cd4', 'Sell', 
+                'Il7r', 'Tcf7', 'Ifng', 'Gzmb', 
+                'Tox', 'Pdcd1', 'Havcr2', 'Lag3',
+                'Mki67', 'Icos', 'Foxp3', 'Id2',
+                'Id3', 'Gata3', 'Tbx21', 'Cd69',
+                'Cxcr5', 'Bach1', 'Cxcr5', 'Xcl1',
+                'Etv6', 'Ikzf3', 'Zbed2', 'Batf',
+                'Klrb1c', 'Klrg1', 'Prf1'
+            ],
+            'chemokines': {
+                "CCL": [
+                    "Ccl1", "Ccr1l1", "Ccl2", "Ccl3", "Ccl4", "Ccl5", "Ccl6",
+                    "Ccl7", "Ccl17", "Ccl8", "Ccl9", "Ccl11", "Ccl12", "Ccl19",
+                    "Ccl19-ps2", "Ccl20", "Ccl22", "Ccl24", "Ccl25", "Ccl26",
+                    "Ccl27a", "Ccl28",
+                ],
+                "CCR": [
+                    "Ccr1", "Ccr2", "Ccr3", "Ccr4", "Ccr5", "Ccr6",
+                    "Ccr7", "Ccr8", "Ccr9", "Ccr10",
+                ],
+                "CXCL": [
+                    "Cxcl1", "Cxcl2", "Cxcl3", "Cxcl5", "Cxcl9", "Cxcl10", "Cxcl11",
+                    "Cxcl12", "Cxcl13", "Cxcl14", "Cxcl15", "Cxcl16", "Cxcl17",
+                ],
+                "CXCR": ["Cxcr1", "Cxcr2", "Cxcr3", "Cxcr4", "Cxcr5", "Cxcr6"],
+                "XCL": ["Xcl1"],
+                "XCR": ["Xcr1"],
+                "CX3CL": ["Cx3cl1"],
+                "CX3CR": ["Cx3cr1"],
+            }
+        }
+    }
 }

exprmat-0.1.38/exprmat/peaks/linkage.py

@@ -0,0 +1,19 @@
+
+# Peak-to-gene linkage
+# --------------------
+# 
+# We estimated a linkage score for each peak-gene pair using linear regression models, 
+# based on recent work described in the SHARE-seq method [Ma et al., 2020]. For 
+# each gene, we computed the Pearson correlation coefficient r between the gene 
+# expression and the accessibility of each peak within 500 kb of the gene TSS. 
+# For each peak, we then computed a background set of expected correlation coefficients 
+# given properties of the peak by randomly sampling 200 peaks located on a different 
+# chromosome to the gene, matched for GC content, accessibility, and sequence length 
+# (MatchRegionStats function in Signac). We then computed the Pearson correlation 
+# between the expression of the gene and the set of background peaks. A z-score 
+# was computed for each peak as z = (r − µ)/σ, where µ was the background mean 
+# correlation coefficient and σ was the standard deviation of the background 
+# correlation coefficients for the peak. We computed a p-value for each peak using 
+# a one-sided z-test, and retained peak-gene links with a p-value < 0.05 and a 
+# Pearson correlation coefficient > 0.05 or < -0.05. This was performed using the 
+# LinkPeaks function in Signac.

exprmat-0.1.38/exprmat/peaks/motif.py

@@ -0,0 +1,54 @@
+
+# Motif enrichment
+# ----------------
+#
+# A hypergeometric test was used to test for overrepresentation of each DNA 
+# motif in the set of differentially accessible peaks compared to a background 
+# set of peaks. We tested motifs present in the JASPAR database [Fornes et al., 2020] 
+# for human (species code 9606) by first identifying which peaks contained each 
+# motif using the motifmatchr R package [Schep, 2020]. We computed the GC 
+# content (percentage of G and C nucleotides) for each differentially accessible 
+# peak and sampled a background set of 40,000 peaks such that the background set 
+# was matched for overall GC content, accessibility, and peak width. This was 
+# performed using the FindMotifs function in Signac.
+# 
+# Motif footprinting
+# ------------------
+#
+# We performed transcription factor motif footprinting following previously 
+# described methods [Corces et al., 2018]. To account for Tn5 sequence insertion 
+# bias, we first computed the observed Tn5 insertion frequency at each DNA 
+# hexamer using all Tn5 insertions on chromosome 1. This was done by extracting 
+# the base-resolution Tn5 insertion positions for each fragment mapped to 
+# chromosome 1, and extending the insertion coordinate 3 bp upstream and 2 bp 
+# downstream. We then extracted the DNA sequence corresponding to these 
+# coordinates using the getSeq function from the Biostrings R package 
+# [Pagès et al., 2020] and counted the frequency of each hexamer using the table 
+# function in R. We next computed the expected Tn5 hexamer insertion frequencies 
+# based on the frequency of each hexamer on chromosome 1. We counted the 
+# frequency of each hexamer using the oligonucleotideFrequency function in the 
+# Biostrings package with width=6 and names=“chr1”, using the hg38 genome via 
+# the BSgenome R package [Pagès, 2020]. Finally, we computed the Tn5 insertion 
+# bias as the observed Tn5 insertions divided by the expected insertions at each 
+# hexamer. This was performed using the InsertionBias function in Signac.
+# 
+# To perform motif footprinting, we first identified the coordinates of each 
+# instance of the motif to be footprinted using the matchMotifs function from 
+# the motifmatchr package with out=“positions” to return the genomic coordinates 
+# of each motif instance [Schep, 2020]. Motif coordinates were then resized to 
+# include the +/-250 bp sequence. The Tn5 insertion frequency was counted at each 
+# position in the region for each motif instance to produce a matrix containing 
+# the total observed Tn5 insertion events at each position relative to the motif 
+# center for each cell. We then found the expected Tn5 insertion frequency matrix 
+# by computing the hexamer frequency matrix, M. The hexamer frequency matrix M 
+# was defined as a matrix with i rows corresponding to i different DNA hexamers 
+# and j columns corresponding to j positions centered on the motif, and each 
+# entry Mi j corresponded to the hexamer count for hexamer i at position j. To 
+# find the expected Tn5 insertion frequency at each position relative to the motif 
+# given the Tn5 insertion bias (see above), we computed the matrix cross product 
+# between the hexamer frequency matrix M and the Tn5 insertion bias vector. 
+# Finally, the expected Tn5 insertion frequencies were normalized by dividing by 
+# the mean expected frequency in the 50 bp flanking regions (the regions 200 to 
+# 250 bp from the motif). To correct for Tn5 insertion bias we subtracted the 
+# expected Tn5 insertion frequencies from the observed Tn5 insertion frequencies 
+# at each position. This was performed using the Footprint function in Signac.

exprmat-0.1.38/exprmat/peaks/sequence.py

@@ -0,0 +1,29 @@
+
+import os
+from rich.progress import track
+from exprmat.data.finders import basepath
+from exprmat.configuration import default
+
+
+def query_sequence(adata):
+    
+    taxa = default['taxa.reference'][adata.uns['assembly']]
+    assembly = adata.uns['assembly']
+
+    genome = os.path.join(basepath, taxa, 'assemblies', assembly, 'genome.fa.gz')
+    import pyfastx
+    fa = pyfastx.Fasta(genome)
+
+    adata.var['strand.pos'] = 'N'
+    adata.var['strand.neg'] = 'N'
+    segments = adata.var[['chr', 'start', 'end']].copy().sort_values(['chr', 'start'])
+    chromosomes = segments['chr'].value_counts().index.tolist()
+    for chr in track(chromosomes, description = 'fetching chromosome ...'):
+        positions = []
+        subset = segments.loc[segments['chr'] == chr, :].copy()
+        for f, t in zip(subset['start'], subset['end']):
+            positions.append((f, t))
+
+        adata.var.loc[subset.index, 'strand.pos'] = fa.fetch(chr, positions, strand = '+')
+        adata.var.loc[subset.index, 'strand.neg'] = fa.fetch(chr, positions, strand = '-')
+    

{exprmat-0.1.36 → exprmat-0.1.38}/exprmat/plotting/expression.py

@@ -214,7 +214,7 @@ def volcano(
 
     if isinstance(de_slot, str):
         plots = st.rna_get_markers(
-            adata, de_slot = de_slot,
+            adata, None, de_slot = de_slot,
             min_pct = min_pct, max_pct_reference = max_pct_reference, 
             min_lfc = min_lfc, max_lfc = max_lfc, 
             remove_zero_pval = remove_zero_pval
@@ -248,7 +248,7 @@ def volcano(
     for p, f, nm in zip(sig_pvals, sig_fc, sig_names):
         texts += [axes.text(f, p, nm, va = 'top', ha = 'center')]
 
-    adjust_text(texts)
+    # adjust_text(texts)
     axes.scatter(sig_fc, sig_pvals, c = 'r', s = 10)
     axes.grid(False)
 

{exprmat-0.1.36 → exprmat-0.1.38}/exprmat/plotting/palettes.py

@@ -49,7 +49,9 @@ from re import match
 from typing import TYPE_CHECKING, TypeAlias, cast
 from typing import ClassVar, Iterator
 import numpy as np
+
 from exprmat.ansi import error
+from matplotlib.colors import Colormap
 
 rgb_tuple = tuple[int, int, int] | tuple[int, int, int, float]
 
@@ -84,7 +86,7 @@ class color:
     def from_rgb(cls, value: rgb_color):
         raise NotImplementedError
 
-    def lighten(self, amount: float):
+    def lighten(self, amount: float) -> rgb_color:
         rgb = self.to_rgb()
         h, l, s = colorsys.rgb_to_hls(float(rgb.r)/255, float(rgb.g)/255, float(rgb.b)/255)
         new_l = self.clamp(l + amount, 1)
@@ -94,6 +96,16 @@ class color:
         rgb.b = round(b * 255)
         return self.from_rgb(rgb)
 
+    def saturate(self, amount: float):
+        rgb = self.to_rgb()
+        h, l, s = colorsys.rgb_to_hls(float(rgb.r)/255, float(rgb.g)/255, float(rgb.b)/255)
+        new_s = self.clamp(s * amount, 1)
+        r, g, b = colorsys.hls_to_rgb(h, l, new_s)
+        rgb.r = round(r * 255)
+        rgb.g = round(g * 255)
+        rgb.b = round(b * 255)
+        return self.from_rgb(rgb)
+
     @abstractmethod
     def to_css(self) -> str:
         raise NotImplementedError
@@ -1383,96 +1395,102 @@ TolRainbow = { 3:  TolRainbow3,  4:  TolRainbow4,  5:  TolRainbow5,  6:  TolRain
                 18: TolRainbow18, 19: TolRainbow19, 20: TolRainbow20, 21: TolRainbow21, 22: TolRainbow22, 23: TolRainbow23 }
 
 brewer = {
-    'YlGn'     : YlGn,
-    'YlGnBu'   : YlGnBu,
-    'GnBu'     : GnBu,
-    'BuGn'     : BuGn,
-    'PuBuGn'   : PuBuGn,
-    'PuBu'     : PuBu,
-    'BuPu'     : BuPu,
-    'RdPu'     : RdPu,
-    'PuRd'     : PuRd,
-    'OrRd'     : OrRd,
-    'YlOrRd'   : YlOrRd,
-    'YlOrBr'   : YlOrBr,
-    'Purples'  : Purples,
-    'Blues'    : Blues,
-    'Greens'   : Greens,
-    'Oranges'  : Oranges,
-    'Reds'     : Reds,
-    'Greys'    : Greys,
-    'PuOr'     : PuOr,
-    'BrBG'     : BrBG,
-    'PRGn'     : PRGn,
-    'PiYG'     : PiYG,
-    'RdBu'     : RdBu,
-    'RdGy'     : RdGy,
-    'RdYlBu'   : RdYlBu,
-    'Spectral' : Spectral,
-    'RdYlGn'   : RdYlGn,
-    'Accent'   : Accent,
-    'Dark2'    : Dark2,
-    'Paired'   : Paired,
-    'Pastel1'  : Pastel1,
-    'Pastel2'  : Pastel2,
-    'Set1'     : Set1,
-    'Set2'     : Set2,
-    'Set3'     : Set3,
+    'ylgn'     : YlGn,
+    'ylgnbu'   : YlGnBu,
+    'gnbu'     : GnBu,
+    'bugn'     : BuGn,
+    'pubugn'   : PuBuGn,
+    'pubu'     : PuBu,
+    'bupu'     : BuPu,
+    'rdpu'     : RdPu,
+    'purd'     : PuRd,
+    'orrd'     : OrRd,
+    'ylorrd'   : YlOrRd,
+    'ylorbr'   : YlOrBr,
+    'purples'  : Purples,
+    'blues'    : Blues,
+    'greens'   : Greens,
+    'oranges'  : Oranges,
+    'reds'     : Reds,
+    'greys'    : Greys,
+    'puor'     : PuOr,
+    'brbg'     : BrBG,
+    'prgn'     : PRGn,
+    'piyg'     : PiYG,
+    'rdbu'     : RdBu,
+    'rdgy'     : RdGy,
+    'rdylbu'   : RdYlBu,
+    'spectral' : Spectral,
+    'rdylgn'   : RdYlGn,
+    'accent'   : Accent,
+    'dark2'    : Dark2,
+    'paired'   : Paired,
+    'pastel1'  : Pastel1,
+    'pastel2'  : Pastel2,
+    'set1'     : Set1,
+    'set2'     : Set2,
+    'set3'     : Set3,
 }
 
 d3 = {
-    'Category10'  : Category10,
-    'Category20'  : Category20,
-    'Category20b' : Category20b,
-    'Category20c' : Category20c,
+    'category10'  : Category10,
+    'category20'  : Category20,
+    'category20b' : Category20b,
+    'category20c' : Category20c,
 }
 
 mpl = {
-    'Magma'   : Magma,
-    'Inferno' : Inferno,
-    'Plasma'  : Plasma,
-    'Viridis' : Viridis,
-    'Cividis' : Cividis,
+    'magma'   : Magma,
+    'inferno' : Inferno,
+    'plasma'  : Plasma,
+    'viridis' : Viridis,
+    'cividis' : Cividis,
 }
 
 tol = {
-    'Bright': Bright,
-    'HighContrast': HighContrast,
-    'Vibrant': Vibrant,
-    'Muted': Muted,
-    'MediumContrast': MediumContrast,
-    'Light': Light,
-    'Sunset': Sunset,
-    'BuRd': BuRd,
-    'TolPRGn': TolPRGn,
-    'TolYlOrBr': TolYlOrBr,
-    'Iridescent': Iridescent,
-    'TolRainbow': TolRainbow,
+    'bright': Bright,
+    'highcontrast': HighContrast,
+    'vibrant': Vibrant,
+    'muted': Muted,
+    'mediumcontrast': MediumContrast,
+    'light': Light,
+    'sunset': Sunset,
+    'burd': BuRd,
+    'tolprgn': TolPRGn,
+    'tolylorbr': TolYlOrBr,
+    'iridescent': Iridescent,
+    'tolrainbow': TolRainbow,
 }
 
 colorblind = {
-    'Colorblind' : Colorblind,
+    'colorblind' : Colorblind,
 }
 
 all_palettes = deepcopy(brewer)
 all_palettes.update(d3)
 all_palettes.update(tol)
-all_palettes['Colorblind'] = Colorblind
-all_palettes['Magma']      = Magma
-all_palettes['Inferno']    = Inferno
-all_palettes['Plasma']     = Plasma
-all_palettes['Viridis']    = Viridis
-all_palettes['Cividis']    = Cividis
-all_palettes['Turbo']      = Turbo
+all_palettes['colorblind'] = Colorblind
+all_palettes['magma']      = Magma
+all_palettes['inferno']    = Inferno
+all_palettes['plasma']     = Plasma
+all_palettes['viridis']    = Viridis
+all_palettes['cividis']    = Cividis
+all_palettes['turbo']      = Turbo
 
 small_palettes = deepcopy(all_palettes)
-del small_palettes['Greys'][256]
-del small_palettes['Magma'][256]
-del small_palettes['Inferno'][256]
-del small_palettes['Plasma'][256]
-del small_palettes['Viridis'][256]
-del small_palettes['Cividis'][256]
-del small_palettes['Turbo'][256]
+del small_palettes['greys'][256]
+del small_palettes['magma'][256]
+del small_palettes['inferno'][256]
+del small_palettes['plasma'][256]
+del small_palettes['viridis'][256]
+del small_palettes['cividis'][256]
+del small_palettes['turbo'][256]
+
+
+def to_matplotlib(palette: palette) -> Colormap:
+    from matplotlib.colors import ListedColormap
+    return ListedColormap(palette)
+
 
 def linear_palette(palette: palette, n: int) -> palette:
     '''
@@ -1598,6 +1616,7 @@ def varying_alpha_palette(
 
     return palette
 
+
 def interp_palette(palette: palette, n: int) -> palette:
     
     npalette = len(palette)
@@ -1636,6 +1655,31 @@ def cividis(n: int) -> palette:
 def turbo(n: int) -> palette:
     return linear_palette(Turbo256, n)
 
+def cmdiv_wyj(n: int) -> palette:
+    return interp_palette(palette((
+        rgb_color(78, 42, 135).to_hex(),
+        rgb_color(162, 184, 198).to_hex(),
+        rgb_color(176, 114, 103).to_hex(),
+        rgb_color(143, 11, 9).to_hex()
+    )), n = n)
+
+def awared_darken(c: rgb_color, lighten = 0.3, saturate = 0.4):
+    grayscale = 0.30 * c.r + 0.59 + c.g + 0.11 * c.b
+    darken = (max(0, grayscale - 45) / 255.0) * 0.40
+    return c.darken(darken).lighten(lighten).saturate(saturate)
+
+def moddark(n: int) -> palette:
+    return interp_palette(palette([
+        awared_darken(rgb_color.from_hex_string(c), 0.1, 0.9).to_hex() 
+        for c in turbo(n)
+    ]), n = n)
+
+def modlight(n: int) -> palette:
+    return interp_palette(palette([
+        awared_darken(rgb_color.from_hex_string(c), 0.4, 0.5).to_hex() 
+        for c in turbo(n)
+    ]), n = n)
+
 def grey(n: int) -> palette:
     return linear_palette(Greys256, n)
 
@@ -1643,11 +1687,87 @@ def gray(n: int) -> palette:
     return linear_palette(Greys256, n)
 
 
+def plot_colormap(p: palette, ax = None, figsize = (2, 2), dpi = 100, title = None):
+    rgba_array = to_rgba_array(p)
+
+    import matplotlib.pyplot as plt
+    if ax is None: fig, ax = plt.subplots(1, 1, figsize = figsize, dpi = dpi)
+    else: fig = ax.figure
+
+    cs = []; xs = []; ys = []
+    for i, rgb in enumerate(rgba_array):
+        col = rgb_color(rgb[0], rgb[1], rgb[2]).to_hex()
+        cs.append(col)
+        xs.append(i)
+        ys.append(0.3 * rgb[0] / 255 + 0.59 * rgb[1] / 255 + 0.11 * rgb[2] / 255)
+    
+    ax.scatter(xs, ys, c = cs, s = 120)
+    ax.set_ylim((0, 1))
+    ax.set_xlim((-1, len(cs)))
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    if title: ax.set_xlabel(title)
+    return fig
+
+
+def demo_colormap(ncols = 6, dpi = 100):
+
+    import matplotlib.pyplot as plt
+    n_features = len(all_palettes)
+    nrows = n_features // ncols
+    if n_features % ncols != 0: nrows += 1
+    fig, axes = plt.subplots(nrows, ncols, dpi = dpi, figsize = (ncols * 1.45, nrows * 1.6))
+
+    for i, feat in enumerate(list(all_palettes.keys())):
+        if len(axes.shape) == 2:
+            plot_colormap(
+                get_palette(feat, 256), 
+                axes[i // ncols, i % ncols], 
+                title = feat
+            )
+        elif len(axes.shape) == 1:
+            plot_colormap(get_palette(feat, 256), axes[i], title = feat)
+    
+    for icol in range(ncols):
+        for irow in range(nrows):
+            if len(axes.shape) == 2:
+                axes[irow, icol].set_xticks([])
+                axes[irow, icol].set_yticks([])
+            else: 
+                axes[icol].set_xticks([])
+                axes[icol].set_yticks([])
+    
+    fig.tight_layout()
+    return fig
+
+
 def to_rgba_array(palette: palette):
     rgba_array = np.empty((len(palette), 4), dtype=np.uint8)
 
     for i, color in enumerate(palette):
         rgba = named_color.from_string(color)
-        rgba_array[i] = (rgba.r, rgba.g, rgba.b, rgba.a*255)
+        rgba_array[i] = (rgba.r, rgba.g, rgba.b, rgba.a * 255)
 
     return rgba_array
+
+
+def get_palette_tuple(name, n):
+    
+    if name not in all_palettes.keys():
+        error(f'can not find a palette named `{name}`.')
+    
+    if isinstance(all_palettes[name], dict):
+        if n in all_palettes[name].keys():
+            return all_palettes[name][n]
+        else: return interp_palette(all_palettes[name][list(all_palettes[name].keys())[-1]], n)
+    else: return interp_palette(all_palettes[name], n)
+
+
+def get_palette(name, n):
+    return list(get_palette_tuple(name, n))
+
+# custom palettes
+all_palettes['cmdiv_wyj']  = cmdiv_wyj(256)
+all_palettes['modlight']   = modlight(256)
+all_palettes['moddark']    = moddark(256)

{exprmat-0.1.36 → exprmat-0.1.38}/exprmat/plotting/sankey.py

@@ -26,7 +26,7 @@ def check_data_matches_labels(labels, data, side):
 def sankey(
     left, right, left_weights = None, right_weights = None, 
     colors = None, left_labels = None, right_labels = None, 
-    aspect = 4, right_colors = False, cmap = 'Turbo',
+    aspect = 4, right_colors = False, cmap = 'turbo',
     fontsize = 9, figsize = (4, 4), ax = None
 ):