py2ls 0.1.6.1__py3-none-any.whl → 0.1.6.2__py3-none-any.whl

py2ls/ips.py

@@ -879,8 +879,9 @@ def fload(fpath, kind=None, **kwargs):
         root = tree.getroot()
         return etree.tostring(root, pretty_print=True).decode()
 
-    def load_csv(fpath, **kwargs):
-        df = pd.read_csv(fpath, **kwargs)
+    def load_csv(fpath, engine='pyarrow',**kwargs):
+        print(f"engine={engine}")
+        df = pd.read_csv(fpath, engine=engine, **kwargs)
         return df
 
     def load_xlsx(fpath, **kwargs):
@@ -2169,9 +2170,22 @@ def figsets(*args,**kwargs):
         # rotation
         if "angle" in key.lower() or ("rot" in key.lower()):
             if "x" in key.lower():
-                ax.tick_params(axis="x", rotation=value)
+                if value in [0,90,180,270]:
+                    ax.tick_params(axis="x", rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('center')
+                elif value >0:
+                    ax.tick_params(axis="x", rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('right')
+                elif value <0:
+                    ax.tick_params(axis='x', rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('left')
             if "y" in key.lower():
                 ax.tick_params(axis="y", rotation=value)
+                for tick in ax.get_yticklabels():
+                    tick.set_horizontalalignment('right')
 
         if "bo" in key in key:  # box setting, and ("p" in key or "l" in key):
             if isinstance(value, (str, list)):

py2ls/plot/catplot.py

@@ -0,0 +1,437 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import to_rgba
+from scipy.stats import gaussian_kde
+
+def catplot(data, *args, **kwargs):
+    """
+    catplot(data, opt=None, ax=None)
+
+    Args:
+        data (array): data matrix
+    """
+    def plot_bars(data_m, opt_b, xloc, ax):
+        bar_positions = get_positions(xloc, opt_b['loc'], opt_b['x_width'], data.shape[0])
+        bar_positions=np.nanmean(bar_positions,axis=0)
+        for i, (x, y) in enumerate(zip(bar_positions, data_m)):
+            color = to_rgba(opt_b['FaceColor'][i % len(opt_b['FaceColor'])])
+            ax.bar(x, y, 
+                    width=opt_b['x_width'], 
+                    color=color,
+                    edgecolor=opt_b['EdgeColor'], 
+                    alpha=opt_b['FaceAlpha'])
+
+    def plot_errors(data, data_m, opt_e, xloc, ax):
+        error_positions = get_positions(xloc, opt_e['loc'], opt_e['x_width'], data.shape[0])
+        error_positions=np.nanmean(error_positions,axis=0)
+        errors = np.nanstd(data, axis=0)
+        if opt_e['error'] == 'sem':
+            errors /= np.sqrt(np.sum(~np.isnan(data),axis=0))
+
+        if not isinstance(opt_e['FaceColor'],list):
+            opt_e['FaceColor']=[opt_e['FaceColor']]
+        if not isinstance(opt_e['MarkerEdgeColor'],list):
+            opt_e['MarkerEdgeColor']=[opt_e['MarkerEdgeColor']]  
+        for i, (x, y, err) in enumerate(zip(error_positions, data_m, errors)):
+            ax.errorbar(x, y, yerr=err, 
+                        fmt=opt_e['Marker'], 
+                        ecolor=opt_e['LineColor'], 
+                        elinewidth=opt_e['LineWidth'], 
+                        lw=opt_e['LineWidth'], 
+                        ls=opt_e['LineStyle'], 
+                        capsize=opt_e['CapSize'],
+                        capthick=opt_e['CapLineWidth'], 
+                        markersize=opt_e['MarkerSize'],
+                        mec=opt_e['MarkerEdgeColor'][i % len(opt_e['MarkerEdgeColor'])],
+                        mfc=opt_e['FaceColor'][i % len(opt_e['FaceColor'])],
+                        visible=opt_e['Visible']
+                        )
+
+    def plot_scatter(data, opt_s, xloc, ax):
+        scatter_positions = get_positions(xloc, opt_s['loc'], opt_s['x_width'], data.shape[0])
+        for i, (x, y) in enumerate(zip(scatter_positions.T, data.T)):
+            color = to_rgba(opt_s['FaceColor'][i % len(opt_s['FaceColor'])])
+            ax.scatter(x, y, 
+                        color=color, 
+                        alpha=opt_s['FaceAlpha'], 
+                        edgecolor=opt_s['MarkerEdgeColor'], 
+                        s=opt_s['MarkerSize'],
+                        marker=opt_s['Marker']
+                        )
+
+    def plot_boxplot(data, bx_opt, xloc,ax):
+        if 'l' in bx_opt['loc']:
+            X_bx = xloc - bx_opt['x_width']
+        elif 'r' in bx_opt['loc']:
+            X_bx = xloc + bx_opt['x_width']
+        elif 'i' in bx_opt['loc']:
+            X_bx = xloc
+            X_bx[:, 0] += bx_opt['x_width']
+            X_bx[:, -1] -= bx_opt['x_width']
+        elif 'o' in bx_opt['loc']:
+            X_bx = xloc
+            X_bx[:, 0] -= bx_opt['x_width']
+            X_bx[:, -1] += bx_opt['x_width']
+        elif 'c' in bx_opt['loc'] or 'm' in bx_opt['loc']:
+            X_bx = xloc
+        else:
+            X_bx = xloc
+ 
+
+        boxprops = dict(color=bx_opt['EdgeColor'], 
+                        linewidth=bx_opt['BoxLineWidth'])
+        flierprops = dict(marker=bx_opt['OutlierMarker'], 
+                        markerfacecolor=bx_opt['OutlierColor'],
+                        markersize=bx_opt['OutlierSize'])
+        whiskerprops = dict(linestyle=bx_opt['WhiskerLineStyle'], 
+                            color=bx_opt['WhiskerLineColor'], 
+                            linewidth=bx_opt['WhiskerLineWidth'])
+        capprops = dict(color=bx_opt['CapLineColor'], 
+                        linewidth=bx_opt['CapLineWidth'],)
+        medianprops = dict(linestyle=bx_opt['MedianLineStyle'], 
+                        color=bx_opt['MedianLineColor'], 
+                        linewidth=bx_opt['MedianLineWidth'])
+        meanprops = dict(linestyle=bx_opt['MeanLineStyle'], 
+                color=bx_opt['MeanLineColor'], 
+                linewidth=bx_opt['MeanLineWidth'])
+        bxp = ax.boxplot(data, 
+                        positions=X_bx, 
+                        notch=bx_opt['Notch'], 
+                        patch_artist=True, 
+                        boxprops=boxprops, 
+                        flierprops=flierprops, 
+                        whiskerprops=whiskerprops, 
+                        capwidths=bx_opt['CapSize'],
+                        showfliers = bx_opt['Outliers'],
+                        showcaps = bx_opt['Caps'],
+                        capprops=capprops, 
+                        medianprops=medianprops, 
+                        meanline=bx_opt['MeanLine'],
+                        showmeans=bx_opt['MeanLine'],
+                        meanprops =meanprops,
+                        widths=bx_opt['x_width'])
+
+        if bx_opt['BoxLineWidth'] < 0.1:
+            bx_opt['EdgeColor'] = 'none'
+        else:
+            bx_opt['EdgeColor'] = bx_opt['EdgeColor']
+
+        for patch, color in zip(bxp['boxes'], bx_opt['FaceColor']):
+            patch.set_facecolor(to_rgba(color, bx_opt['FaceAlpha']))
+
+        if bx_opt['MedianLineTop']:
+            ax.set_children(ax.get_children()[::-1])  # move median line forward
+
+    def plot_violin(data, opt_v, xloc, ax):
+        violin_positions = get_positions(xloc, opt_v['loc'], opt_v['x_width'], data.shape[0])
+        violin_positions = np.nanmean(violin_positions, axis=0)
+        for i, (x, ys) in enumerate(zip(violin_positions, data.T)):
+            ys = ys[~np.isnan(ys)]
+            if len(ys) > 1:
+                kde = gaussian_kde(ys, bw_method=opt_v['BandWidth'])
+                min_val, max_val = ys.min(), ys.max()
+                y_vals = np.linspace(min_val, max_val, opt_v['NumPoints'])
+                kde_vals = kde(y_vals)
+                kde_vals = kde_vals / kde_vals.max() * opt_v['x_width']
+                if 'r' in opt_v['loc'].lower():
+                    ax.fill_betweenx(y_vals, x, x + kde_vals,
+                                    color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                    alpha=opt_v['FaceAlpha'],
+                                    edgecolor=opt_v['EdgeColor'])
+                elif 'l' in opt_v['loc'].lower() and not 'f' in opt_v['loc'].lower() :
+                    ax.fill_betweenx(y_vals, x - kde_vals, x,
+                                    color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                    alpha=opt_v['FaceAlpha'],
+                                    edgecolor=opt_v['EdgeColor'])
+                elif 'o' in opt_v['loc'].lower() or 'both' in opt_v['loc'].lower() :
+                    ax.fill_betweenx(y_vals, x - kde_vals, x + kde_vals,
+                                    color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                    alpha=opt_v['FaceAlpha'],
+                                    edgecolor=opt_v['EdgeColor'])
+                elif 'i' in opt_v['loc'].lower():
+                    if i % 2 == 1:  # odd number
+                        ax.fill_betweenx(y_vals, x -kde_vals, x,
+                                        color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                        alpha=opt_v['FaceAlpha'],
+                                        edgecolor=opt_v['EdgeColor'])
+                    else:
+                        ax.fill_betweenx(y_vals, x, x+kde_vals,
+                                        color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                        alpha=opt_v['FaceAlpha'],
+                                        edgecolor=opt_v['EdgeColor'])
+                elif 'f' in opt_v['loc'].lower():
+                    ax.fill_betweenx(y_vals, x - kde_vals, x + kde_vals,
+                                    color=opt_v['FaceColor'][i % len(opt_v['FaceColor'])], 
+                                    alpha=opt_v['FaceAlpha'],
+                                    edgecolor=opt_v['EdgeColor'])
+                    
+    def plot_lines(data, opt_l, opt_s, ax): 
+        scatter_positions = get_positions(xloc, opt_s['loc'], opt_s['x_width'], data.shape[0])
+        for incol in range(data.shape[1]-1):
+            for irow in range(data.shape[0]):
+                if not np.isnan(data[irow, incol]):
+                    if opt_l['LineStyle'] is not None and not opt_l['LineStyle'] =='none':
+                        x_data = [scatter_positions[irow, incol], scatter_positions[irow, incol + 1]]
+                        y_data = [data[irow, incol], data[irow, incol + 1]]
+            
+
+                        ax.plot(x_data, y_data,
+                                color=opt_l['LineColor'],
+                                linestyle=opt_l['LineStyle'],
+                                linewidth=opt_l['LineWidth'],
+                                alpha=opt_l['LineAlpha'])
+                            
+    def get_positions(xloc, loc_type, x_width, n_row=None):
+        if 'rand' in loc_type:
+            scatter_positions = np.zeros((n_row, len(xloc)))
+            np.random.seed(111)
+            for i, x in enumerate(xloc):
+                scatter_positions[:, i] = np.random.uniform(x - x_width, x + x_width, n_row)
+            return scatter_positions
+        elif 'l' in loc_type:
+            return np.tile(xloc - x_width,(n_row,1))
+        elif 'r' in loc_type and not 'd' in loc_type:
+            return np.tile(xloc + x_width,(n_row,1))
+        elif 'i' in loc_type:
+            return np.tile(np.concatenate([xloc[:1] + x_width, xloc[1:-1], xloc[-1:] - x_width]),(n_row,1))
+        elif 'o' in loc_type:
+            return np.tile(np.concatenate([xloc[:1] - x_width, xloc[1:-1], xloc[-1:] + x_width]),(n_row,1))
+        else:
+            return np.tile(xloc,(n_row,1))
+    
+    opt = kwargs.get('opt',{}) 
+    ax = kwargs.get('ax',None)
+    if 'ax' not in locals() or ax is None:
+        ax=plt.gca()
+
+    default_colors = np.array([
+        [0, 0, 0],
+        [234, 37, 46],
+        [0, 154, 222],
+        [175, 89, 186],
+        [255, 198, 37],
+        [242, 133, 34]
+    ]) / 255.0
+
+    opt.setdefault('c', default_colors)
+    if len(opt['c']) < data.shape[1]:
+        additional_colors = plt.cm.winter(np.linspace(0, 1, data.shape[1] - len(opt['c'])))
+        opt['c'] = np.vstack([opt['c'], additional_colors[:, :3]])
+
+    opt.setdefault('loc', {})
+    opt['loc'].setdefault('go', 0)
+    opt['loc'].setdefault('xloc', np.arange(1, data.shape[1] + 1))
+
+    # export setting
+    opt.setdefault('export', False)
+    opt['export'].setdefault('path', None)
+    print(opt['export'])
+
+    opt.setdefault('b', {})
+    opt['b'].setdefault('go', 0) 
+    opt['b'].setdefault('EdgeColor', 'k')
+    opt['b'].setdefault('FaceAlpha', 1)
+    opt['b'].setdefault('EdgeAlpha', 1)
+    opt['b'].setdefault('LineStyle', '-')
+    opt['b'].setdefault('x_width', 0.5)
+    opt['b'].setdefault('ShowBaseLine', 'off')
+    opt['b'].setdefault('loc', 'c')
+    opt['b'].setdefault('FaceColor', opt['c'])
+
+    opt.setdefault('e', {})
+    opt['e'].setdefault('go', 1) 
+    opt['e'].setdefault('LineWidth', 1)
+    opt['e'].setdefault('CapLineWidth', 1)
+    opt['e'].setdefault('CapSize', opt['b']['x_width'] * 100 * 0.1)
+    opt['e'].setdefault('Marker', 'none')
+    opt['e'].setdefault('LineStyle', 'none')
+    opt['e'].setdefault('LineColor', 'k')
+    opt['e'].setdefault('LineJoin', 'round')
+    opt['e'].setdefault('MarkerSize', 'auto')
+    opt['e'].setdefault('FaceColor', opt['c'])
+    opt['e'].setdefault('MarkerEdgeColor', 'none')
+    opt['e'].setdefault('Visible', True)
+    opt['e'].setdefault('Orientation', 'vertical')
+    opt['e'].setdefault('error', 'sem')
+    opt['e'].setdefault('loc', 'c')
+    opt['e'].setdefault('x_width', opt['b']['x_width'] / 5)
+    opt['e'].setdefault('cap_dir', 'b')
+
+    opt.setdefault('s', {})
+    opt['s'].setdefault('go', 1) 
+    opt['s'].setdefault('x_width', opt['b']['x_width'] / 5)
+    opt['s'].setdefault('Marker', 'o')
+    opt['s'].setdefault('MarkerSize', 6)  # Set default size for markers
+    opt['s'].setdefault('LineWidth', 1)
+    opt['s'].setdefault('FaceColor', opt['c'])
+    opt['s'].setdefault('FaceAlpha', 0.6)
+    opt['s'].setdefault('loc', 'random')
+    opt['s'].setdefault('MarkerEdgeColor', None)
+
+    opt.setdefault('bx', {})
+    opt['bx'].setdefault('go', 0)
+    opt['bx'].setdefault('EdgeColor', 'k')
+    opt['bx'].setdefault('FaceAlpha', 1)
+    opt['bx'].setdefault('EdgeAlpha', 1)
+    opt['bx'].setdefault('LineStyle', '-')
+    opt['bx'].setdefault('x_width', 0.5)
+    opt['bx'].setdefault('ShowBaseLine', 'off')
+    opt['bx'].setdefault('loc', 'c')
+    opt['bx'].setdefault('FaceColor', opt['c'])
+    opt['bx'].setdefault('Notch', False)
+    opt['bx'].setdefault('MedianStyle', 'line')
+    opt['bx'].setdefault('Outliers', 'on')
+    opt['bx'].setdefault('OutlierMarker', '+')
+    opt['bx'].setdefault('OutlierColor', 'r')
+    opt['bx'].setdefault('OutlierSize', 6)
+    opt['bx'].setdefault('PlotStyle', 'traditional')
+    opt['bx'].setdefault('FactorDirection', 'auto')
+    opt['bx'].setdefault('Whisker', 1.5)
+    opt['bx'].setdefault('Orientation', 'vertical')
+    opt['bx'].setdefault('BoxLineWidth', 1.5)
+    opt['bx'].setdefault('FaceColor', 'k')
+    opt['bx'].setdefault('WhiskerLineStyle', '-')
+    opt['bx'].setdefault('WhiskerLineColor', 'k')
+    opt['bx'].setdefault('WhiskerLineWidth', 1.5)
+    opt['bx'].setdefault('Caps', True)
+    opt['bx'].setdefault('CapLineColor', 'k')
+    opt['bx'].setdefault('CapLineWidth', 1.5)
+    opt['bx'].setdefault('CapSize', 0.35)
+    opt['bx'].setdefault('MedianLineStyle', '-')
+    opt['bx'].setdefault('MedianLineColor', 'k')
+    opt['bx'].setdefault('MedianLineWidth', 1.5)
+    opt['bx'].setdefault('MedianLineTop', False)
+    opt['bx'].setdefault('MeanLine', False)
+    opt['bx'].setdefault('showmeans', opt['bx']['MeanLine'])
+    opt['bx'].setdefault('MeanLineStyle', '-')
+    opt['bx'].setdefault('MeanLineColor', 'b')
+    opt['bx'].setdefault('MeanLineWidth', 1.5)
+    
+    # Violin plot options
+    opt.setdefault('v', {})
+    opt['v'].setdefault('go', 1)
+    opt['v'].setdefault('x_width', 0.3)
+    opt['v'].setdefault('loc', 'r')
+    opt['v'].setdefault('EdgeColor', 'none')
+    opt['v'].setdefault('FaceColor', opt['c'])
+    opt['v'].setdefault('FaceAlpha', 0.3)
+    opt['v'].setdefault('BandWidth', 'scott')
+    opt['v'].setdefault('Function', 'pdf')
+    opt['v'].setdefault('Kernel', 'gau')
+    opt['v'].setdefault('NumPoints', 500)
+    opt['v'].setdefault('BoundaryCorrection', 'reflection')
+    
+    # line plot options
+    opt.setdefault('l', {})
+    opt['l'].setdefault('go', 0)
+    opt['l'].setdefault('LineStyle', '-')
+    opt['l'].setdefault('LineColor', 'k')
+    opt['l'].setdefault('LineWidth', 0.5)
+    opt['l'].setdefault('LineAlpha', 0.5) 
+
+    data_m = np.nanmean(data, axis=0)
+    nr, nc = data.shape
+
+    xloc = opt['loc']['xloc']
+
+    if opt['b']['go']:
+        plot_bars(data_m, opt['b'], xloc, ax)
+
+    if opt['e']['go']:
+        plot_errors(data, data_m, opt['e'], xloc, ax)
+
+    if opt['s']['go']:
+        plot_scatter(data, opt['s'], xloc, ax)
+        
+    if opt['bx']['go']:
+        plot_boxplot(data, opt['bx'], xloc, ax)
+    if opt['v']['go']:
+        plot_violin(data, opt['v'], xloc, ax) 
+    if opt['l']['go'] and opt['s']['go']:
+        plot_lines(data, opt['l'], opt['s'], ax)
+
+    return ax
+
+# from py2ls.ips import get_color,figsets
+# opt={}
+# opt = {
+#     'export':{'path':get_cwd()},
+#     'c': get_color(5,cmap='jet',by='linspace'),  # Custom colors for 3 categories
+#     'b': {
+#         'go': 0,  
+#         'x_width': 0.85,
+#         'FaceAlpha': 0.7,
+#         'EdgeColor':'none'
+#     },
+#     'e': {
+#         'loc':'r',
+#         'go': 1,
+#         'error': 'sem',
+#         'Marker':'d',
+#         'CapSize': 1,
+#         'LineWidth':1,
+#         'CapLineWidth':8,
+#         'LineStyle':'--',
+#         'MarkerSize':6,
+#         'LineColor':'k',
+#         'FaceColor':get_color(10),
+#         'MarkerEdgeColor':'none',
+#         'Visible':True
+#     },
+#     's': {
+#         'go': 1,
+#         'x_width':0.2,
+#         'loc':'random',
+#         'Marker': 'o',
+#         # 'MarkerSize': 20,
+#         'FaceAlpha': 1,
+#         'FaceColor':'k',
+#         'LineWidth':1
+        
+#     },
+#     'bx':{
+#         'go':1,
+#         'FaceAlpha':0.8,
+#         'EdgeColor':'none',
+#         'loc':'c',
+#         'x_width':0.2,
+#         'WhiskerLineWidth':1,
+#         'MedianLineWidth':2,
+#         # 'MedianLineColor':'r',
+#         'OutlierMarker':'+',
+#         'OutlierColor':'r',
+#         'CapSize':.2,
+#         # 'Caps':False,
+#         # 'CapLineColor':'r',
+#         # 'CapLineWidth':8,
+#         # 'MeanLine':True,
+#         # 'FaceColor':['r','g','b','m','c']
+#         },
+#     'v':{
+#         'go':0,
+#         'loc':'r',
+#         'x_width':0.2,
+#         'FaceAlpha':0.51,
+#          },
+#     'l':{
+#         'go':1,
+#         'LineColor':'k'
+#         }
+# }
+# data1 = np.random.rand(10, 5)
+# data2 = np.random.rand(10, 5)
+# fig, axs=plt.subplots(1,2,figsize=(6,2.5))
+# catplot(data1, opt=opt,ax=axs[0])
+# catplot(data2, opt=opt,ax=axs[1])
+# figsets(sp=5,
+#         ax=axs[0],
+#         xticks=np.arange(1,6,1),
+#         xtickslabel=['glua1','glua2','a','b','c'],
+#         xlabel='proteins',
+#         xangle=90,
+#         yticks=np.arange(0,2,0.5),
+#         xlim=[0.75, 5.1],
+#         ticks=dict(pad=1,c='k'))
+
+# figsave("/Users/macjianfeng/Dropbox/Downloads/",'test.pdf')
+

py2ls/{plot.py → plot/figsets.py}

@@ -1,4 +1,4 @@
-from scipy.signal import savgol_filter
+
 import numpy as np
 import matplotlib
 import matplotlib.pyplot as plt
@@ -7,6 +7,9 @@ import seaborn as sns
 from cycler import cycler
 
 
+def get_cmap():
+    return plt.colormaps()
+
 def read_mplstyle(style_file):
     # Load the style file
     plt.style.use(style_file)
@@ -24,317 +27,6 @@ def read_mplstyle(style_file):
 # style_file = "/ std-colors.mplstyle"
 # style_dict = read_mplstyle(style_file)
 
-
-# set up the colorlist, give the number, or the colormap's name
-def get_color(n=1, cmap="auto", by="start"):
-    # Extract the colormap as a list
-    def cmap2hex(cmap_name):
-        cmap_ = matplotlib.pyplot.get_cmap(cmap_name)
-        colors = [cmap_(i) for i in range(cmap_.N)]
-        return [matplotlib.colors.rgb2hex(color) for color in colors]
-        # usage: clist = cmap2hex("viridis")
-    # cycle times, total number is n (defaultn=10)
-    def cycle2list(colorlist, n=10):
-        cycler_ = cycler(tmp=colorlist)
-        clist = []
-        for i, c_ in zip(range(n), cycler_()):
-            clist.append(c_["tmp"])
-            if i > n:
-                break
-        return clist
-    def hue2rgb(hex_colors):
-        def hex_to_rgb(hex_color):
-            """Converts a hexadecimal color code to RGB values."""
-            if hex_colors.startswith("#"):
-                hex_color = hex_color.lstrip("#")
-            return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
-        if isinstance(hex_colors, str):
-            return hex_to_rgb(hex_colors)
-        elif isinstance(hex_colors, (list)):
-            """Converts a list of hexadecimal color codes to a list of RGB values."""
-            rgb_values = [hex_to_rgb(hex_color) for hex_color in hex_colors]
-            return rgb_values
-    if "aut" in cmap:
-        colorlist = [
-            "#474747",
-            "#FF2C00",
-            "#0C5DA5",
-            "#845B97",
-            "#58BBCC",
-            "#FF9500",
-            "#D57DBE",
-        ]
-    else:
-        colorlist = cmap2hex(cmap)
-    if "st" in by.lower() or "be" in by.lower(): 
-        # cycle it
-        clist = cycle2list(colorlist, n=n)
-    if "l" in by.lower() or "p" in by.lower():
-        clist = []
-        [
-            clist.append(colorlist[i])
-            for i in [int(i) for i in np.linspace(0, len(colorlist) - 1, n)]
-        ]
-
-    return clist  # a color list
-    # example usage: clist = get_color(4,cmap="auto", by="start") # get_color(4, cmap="hot", by="linspace")
-
-""" 
-    # n = 7
-    # clist = get_color(n, cmap="auto", by="linspace")  # get_color(100)
-    # plt.figure(figsize=[8, 5], dpi=100)
-    # x = np.linspace(0, 2 * np.pi, 50) * 100
-    # y = np.sin(x)
-    # for i in range(1, n + 1):
-    #     plt.plot(x, y + i, c=clist[i - 1], lw=5, label=str(i))
-    # plt.legend()
-    # plt.ylim(-2, 20)
-    # figsets(plt.gca(), {"style": "whitegrid"}) """
-
-def stdshade(ax=None,*args, **kwargs):
-    # Separate kws_line and kws_fill if necessary
-    kws_line = kwargs.pop('kws_line', {})
-    kws_fill = kwargs.pop('kws_fill', {})
-
-    # Merge kws_line and kws_fill into kwargs
-    kwargs.update(kws_line)
-    kwargs.update(kws_fill)
-    def str2list(str_):
-        l = []
-        [l.append(x) for x in str_]
-        return l
-    def hue2rgb(hex_colors):
-        def hex_to_rgb(hex_color):
-            """Converts a hexadecimal color code to RGB values."""
-            if hex_colors.startswith("#"):
-                hex_color = hex_color.lstrip("#")
-            return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
-        if isinstance(hex_colors, str):
-            return hex_to_rgb(hex_colors)
-        elif isinstance(hex_colors, (list)):
-            """Converts a list of hexadecimal color codes to a list of RGB values."""
-            rgb_values = [hex_to_rgb(hex_color) for hex_color in hex_colors]
-            return rgb_values
-    if (
-        isinstance(ax, np.ndarray)
-        and ax.ndim == 2
-        and min(ax.shape) > 1
-        and max(ax.shape) > 1
-    ):
-        y = ax
-        ax = plt.gca()
-    if ax is None:
-        ax = plt.gca()
-    alpha = 0.5
-    acolor = "k"
-    paraStdSem = "sem"
-    plotStyle = "-"
-    plotMarker = "none"
-    smth = 1
-    l_c_one = ["r", "g", "b", "m", "c", "y", "k", "w"]
-    l_style2 = ["--", "-."]
-    l_style1 = ["-", ":"]
-    l_mark = ["o", "+", "*", ".", "x", "_", "|", "s", "d", "^", "v", ">", "<", "p", "h"]
-    # Check each argument
-    for iarg in range(len(args)):
-        if (
-            isinstance(args[iarg], np.ndarray)
-            and args[iarg].ndim == 2
-            and min(args[iarg].shape) > 1
-            and max(args[iarg].shape) > 1
-        ):
-            y = args[iarg]
-        # Except y, continuous data is 'F'
-        if (isinstance(args[iarg], np.ndarray) and args[iarg].ndim == 1) or isinstance(
-            args[iarg], range
-        ):
-            x = args[iarg]
-            if isinstance(x, range):
-                x = np.arange(start=x.start, stop=x.stop, step=x.step)
-        # Only one number( 0~1), 'alpha' / color
-        if isinstance(args[iarg], (int, float)):
-            if np.size(args[iarg]) == 1 and 0 <= args[iarg] <= 1:
-                alpha = args[iarg]
-        if isinstance(args[iarg], (list, tuple)) and np.size(args[iarg]) == 3:
-            acolor = args[iarg]
-            acolor = tuple(acolor) if isinstance(acolor, list) else acolor
-        # Color / plotStyle /
-        if (
-            isinstance(args[iarg], str)
-            and len(args[iarg]) == 1
-            and args[iarg] in l_c_one
-        ):
-            acolor = args[iarg]
-        else:
-            if isinstance(args[iarg], str):
-                if args[iarg] in ["sem", "std"]:
-                    paraStdSem = args[iarg]
-                if args[iarg].startswith("#"):
-                    acolor=hue2rgb(args[iarg])
-                if str2list(args[iarg])[0] in l_c_one:
-                    if len(args[iarg]) == 3:
-                        k = [i for i in str2list(args[iarg]) if i in l_c_one]
-                        if k != []:
-                            acolor = k[0] 
-                        st = [i for i in l_style2 if i in args[iarg]]
-                        if st != []:
-                            plotStyle = st[0] 
-                    elif len(args[iarg]) == 2:
-                        k = [i for i in str2list(args[iarg]) if i in l_c_one]
-                        if k != []:
-                            acolor = k[0] 
-                        mk = [i for i in str2list(args[iarg]) if i in l_mark]
-                        if mk != []:
-                            plotMarker = mk[0] 
-                        st = [i for i in l_style1 if i in args[iarg]]
-                        if st != []:
-                            plotStyle = st[0] 
-                if len(args[iarg]) == 1:
-                    k = [i for i in str2list(args[iarg]) if i in l_c_one]
-                    if k != []:
-                        acolor = k[0] 
-                    mk = [i for i in str2list(args[iarg]) if i in l_mark]
-                    if mk != []:
-                        plotMarker = mk[0] 
-                    st = [i for i in l_style1 if i in args[iarg]]
-                    if st != []:
-                        plotStyle = st[0] 
-                if len(args[iarg]) == 2:
-                    st = [i for i in l_style2 if i in args[iarg]]
-                    if st != []:
-                        plotStyle = st[0]
-        # smth
-        if (
-            isinstance(args[iarg], (int, float))
-            and np.size(args[iarg]) == 1
-            and args[iarg] >= 1
-        ):
-            smth = args[iarg]
-    smth = kwargs.get('smth', smth)
-    if "x" not in locals() or x is None:
-        x = np.arange(1, y.shape[1] + 1)
-    elif len(x) < y.shape[1]:
-        y = y[:, x]
-        nRow = y.shape[0]
-        nCol = y.shape[1]
-        print(f"y was corrected, please confirm that {nRow} row, {nCol} col")
-    else:
-        x = np.arange(1, y.shape[1] + 1)
-
-    if x.shape[0] != 1:
-        x = x.T
-    yMean = np.nanmean(y, axis=0)
-    if smth > 1:
-        yMean = savgol_filter(np.nanmean(y, axis=0), smth, 1)
-    else:
-        yMean = np.nanmean(y, axis=0)
-    if paraStdSem == "sem":
-        if smth > 1:
-            wings = savgol_filter(np.nanstd(y, axis=0) / np.sqrt(y.shape[0]), smth, 1)
-        else:
-            wings = np.nanstd(y, axis=0) / np.sqrt(y.shape[0])
-    elif paraStdSem == "std":
-        if smth > 1:
-            wings = savgol_filter(np.nanstd(y, axis=0), smth, 1)
-        else:
-            wings = np.nanstd(y, axis=0)
-
-    # fill_kws = kwargs.get('fill_kws', {})
-    # line_kws = kwargs.get('line_kws', {})
-
-    # setting form kwargs
-    lw = kwargs.get('lw', 1.5)
-    ls= kwargs.get('ls', plotStyle)
-    marker=kwargs.get("marker",plotMarker)
-    label=kwargs.get("label",None)
-    label_line = kwargs.get("label_line",None)
-    label_fill = kwargs.get('label_fill',None)
-    alpha=kwargs.get('alpha',alpha)
-    color=kwargs.get('color', acolor)
-    if not label_line and label:
-        label_line = label
-    kwargs['lw'] = lw
-    kwargs['ls'] = ls
-    kwargs['label_line'] = label_line
-    kwargs['label_fill'] = label_fill
-
-    # set kws_line
-    if 'color' not in kws_line:
-        kws_line['color']=color
-    if 'lw' not in kws_line:
-        kws_line['lw']=lw
-    if 'ls' not in kws_line:
-        kws_line['ls']=ls
-    if 'marker' not in kws_line:
-        kws_line['marker']=marker
-    if 'label' not in kws_line:
-        kws_line['label']=label_line
-
-    # set kws_line
-    if 'color' not in kws_fill:
-        kws_fill['color']=color
-    if 'alpha' not in kws_fill:
-        kws_fill['alpha']=alpha
-    if 'lw' not in kws_fill:
-        kws_fill['lw']=0
-    if 'label' not in kws_fill:
-        kws_fill['label']=label_fill
-
-    fill = ax.fill_between(x, yMean + wings, yMean - wings, **kws_fill)
-    line = ax.plot(x, yMean, **kws_line)
-    return line[0], fill
-
-
-"""
-########## Usage 1 ##########
-plot.stdshade(data,
-              'b',
-              ':',
-              'd',
-              0.1,
-              4,
-              label='ddd',
-              label_line='label_line',
-              label_fill="label-fill")
-plt.legend()
-
-########## Usage 2 ##########
-plot.stdshade(data,
-              'm-',
-              alpha=0.1,
-              lw=2,
-              ls=':',
-              marker='d',
-              color='b',
-              smth=4,
-              label='ddd',
-              label_line='label_line',
-              label_fill="label-fill")
-plt.legend()
-
-"""
-
-def adjust_spines(ax=None, spines=['left', 'bottom'],distance=2):
-    if ax is None:
-        ax = plt.gca()
-    for loc, spine in ax.spines.items():
-        if loc in spines:
-            spine.set_position(('outward', distance))  # outward by 2 points
-            # spine.set_smart_bounds(True)
-        else:
-            spine.set_color('none')  # don't draw spine
-    # turn off ticks where there is no spine
-    if 'left' in spines:
-        ax.yaxis.set_ticks_position('left')
-    else:
-        ax.yaxis.set_ticks([])
-    if 'bottom' in spines:
-        ax.xaxis.set_ticks_position('bottom')
-    else:
-        # no xaxis ticks
-        ax.xaxis.set_ticks([])
-
-
 def figsets(*args,**kwargs):
     """
     usage:
@@ -367,7 +59,17 @@ def figsets(*args,**kwargs):
             box=['right','bottom'],
             xrot=-45,
             yangle=20,
-            font_sz = 2
+            font_sz = 2,
+            legend=dict(labels=['group_a','group_b'],
+                        loc='upper left',
+                        edgecolor='k',
+                        facecolor='r',
+                        title='title',
+                        fancybox=1,
+                        shadow=1,
+                        ncols=4,
+                        bbox_to_anchor=[-0.5,0.7],
+                        alignment='left')
         )
     """
     fig = plt.gcf()
@@ -431,6 +133,10 @@ def figsets(*args,**kwargs):
                 "tic" not in key.lower() and "tk" not in key.lower()
             ):
                 ax.set_zlabel(value, fontname=fontname)
+        if key=='xlabel' and isinstance(value,dict):
+            ax.set_xlabel(**value)
+        if key=='ylabel' and isinstance(value,dict):
+            ax.set_ylabel(**value)
         # tick location
         if "tic" in key.lower() or "tk" in key.lower():
             if ("loc" in key.lower()) or ("po" in key.lower()):
@@ -479,9 +185,22 @@ def figsets(*args,**kwargs):
         # rotation
         if "angle" in key.lower() or ("rot" in key.lower()):
             if "x" in key.lower():
-                ax.tick_params(axis="x", rotation=value)
+                if value in [0,90,180,270]:
+                    ax.tick_params(axis="x", rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('center')
+                elif value >0:
+                    ax.tick_params(axis="x", rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('right')
+                elif value <0:
+                    ax.tick_params(axis='x', rotation=value)
+                    for tick in ax.get_xticklabels():
+                        tick.set_horizontalalignment('left')
             if "y" in key.lower():
                 ax.tick_params(axis="y", rotation=value)
+                for tick in ax.get_yticklabels():
+                    tick.set_horizontalalignment('right')
 
         if "bo" in key in key:  # box setting, and ("p" in key or "l" in key):
             if isinstance(value, (str, list)):
@@ -602,7 +321,12 @@ def figsets(*args,**kwargs):
         if "c" in key.lower() and ("sp" in key.lower() or "ax" in key.lower()):# spine color
             for loc, spi in ax.spines.items():
                 spi.set_color(value)
-            
+        if 'leg' in key.lower(): # legend
+            legend_kws = kwargs.get('legend', None)
+            if legend_kws:
+                # https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html
+                ax.legend(**legend_kws) 
+    
     for arg in args:
         if isinstance(arg,matplotlib.axes._axes.Axes):
             ax=arg
@@ -646,7 +370,3 @@ def figsets(*args,**kwargs):
     if len(fig.get_axes()) > 1:
         plt.tight_layout()
         plt.gcf().align_labels()
-
-
-def get_cmap():
-    return plt.colormaps()

py2ls/plot/get_color.py

@@ -0,0 +1,68 @@
+
+from cycler import cycler 
+
+# set up the colorlist, give the number, or the colormap's name
+def get_color(n=1, cmap="auto", by="start"):
+    # Extract the colormap as a list
+    def cmap2hex(cmap_name):
+        cmap_ = matplotlib.pyplot.get_cmap(cmap_name)
+        colors = [cmap_(i) for i in range(cmap_.N)]
+        return [matplotlib.colors.rgb2hex(color) for color in colors]
+        # usage: clist = cmap2hex("viridis")
+    # cycle times, total number is n (defaultn=10)
+    def cycle2list(colorlist, n=10):
+        cycler_ = cycler(tmp=colorlist)
+        clist = []
+        for i, c_ in zip(range(n), cycler_()):
+            clist.append(c_["tmp"])
+            if i > n:
+                break
+        return clist
+    def hue2rgb(hex_colors):
+        def hex_to_rgb(hex_color):
+            """Converts a hexadecimal color code to RGB values."""
+            if hex_colors.startswith("#"):
+                hex_color = hex_color.lstrip("#")
+            return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
+        if isinstance(hex_colors, str):
+            return hex_to_rgb(hex_colors)
+        elif isinstance(hex_colors, (list)):
+            """Converts a list of hexadecimal color codes to a list of RGB values."""
+            rgb_values = [hex_to_rgb(hex_color) for hex_color in hex_colors]
+            return rgb_values
+    if "aut" in cmap:
+        colorlist = [
+            "#474747",
+            "#FF2C00",
+            "#0C5DA5",
+            "#845B97",
+            "#58BBCC",
+            "#FF9500",
+            "#D57DBE",
+        ]
+    else:
+        colorlist = cmap2hex(cmap)
+    if "st" in by.lower() or "be" in by.lower(): 
+        # cycle it
+        clist = cycle2list(colorlist, n=n)
+    if "l" in by.lower() or "p" in by.lower():
+        clist = []
+        [
+            clist.append(colorlist[i])
+            for i in [int(i) for i in np.linspace(0, len(colorlist) - 1, n)]
+        ]
+
+    return clist  # a color list
+    # example usage: clist = get_color(4,cmap="auto", by="start") # get_color(4, cmap="hot", by="linspace")
+
+""" 
+    # n = 7
+    # clist = get_color(n, cmap="auto", by="linspace")  # get_color(100)
+    # plt.figure(figsize=[8, 5], dpi=100)
+    # x = np.linspace(0, 2 * np.pi, 50) * 100
+    # y = np.sin(x)
+    # for i in range(1, n + 1):
+    #     plt.plot(x, y + i, c=clist[i - 1], lw=5, label=str(i))
+    # plt.legend()
+    # plt.ylim(-2, 20)
+    # figsets(plt.gca(), {"style": "whitegrid"}) """

py2ls/plot/stdshade.py

@@ -0,0 +1,227 @@
+from scipy.signal import savgol_filter
+import numpy as np 
+import matplotlib.pyplot as plt 
+
+def stdshade(ax=None,*args, **kwargs):
+    # Separate kws_line and kws_fill if necessary
+    kws_line = kwargs.pop('kws_line', {})
+    kws_fill = kwargs.pop('kws_fill', {})
+
+    # Merge kws_line and kws_fill into kwargs
+    kwargs.update(kws_line)
+    kwargs.update(kws_fill)
+    def str2list(str_):
+        l = []
+        [l.append(x) for x in str_]
+        return l
+    def hue2rgb(hex_colors):
+        def hex_to_rgb(hex_color):
+            """Converts a hexadecimal color code to RGB values."""
+            if hex_colors.startswith("#"):
+                hex_color = hex_color.lstrip("#")
+            return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
+        if isinstance(hex_colors, str):
+            return hex_to_rgb(hex_colors)
+        elif isinstance(hex_colors, (list)):
+            """Converts a list of hexadecimal color codes to a list of RGB values."""
+            rgb_values = [hex_to_rgb(hex_color) for hex_color in hex_colors]
+            return rgb_values
+    if (
+        isinstance(ax, np.ndarray)
+        and ax.ndim == 2
+        and min(ax.shape) > 1
+        and max(ax.shape) > 1
+    ):
+        y = ax
+        ax = plt.gca()
+    if ax is None:
+        ax = plt.gca()
+    alpha = 0.5
+    acolor = "k"
+    paraStdSem = "sem"
+    plotStyle = "-"
+    plotMarker = "none"
+    smth = 1
+    l_c_one = ["r", "g", "b", "m", "c", "y", "k", "w"]
+    l_style2 = ["--", "-."]
+    l_style1 = ["-", ":"]
+    l_mark = ["o", "+", "*", ".", "x", "_", "|", "s", "d", "^", "v", ">", "<", "p", "h"]
+    # Check each argument
+    for iarg in range(len(args)):
+        if (
+            isinstance(args[iarg], np.ndarray)
+            and args[iarg].ndim == 2
+            and min(args[iarg].shape) > 1
+            and max(args[iarg].shape) > 1
+        ):
+            y = args[iarg]
+        # Except y, continuous data is 'F'
+        if (isinstance(args[iarg], np.ndarray) and args[iarg].ndim == 1) or isinstance(
+            args[iarg], range
+        ):
+            x = args[iarg]
+            if isinstance(x, range):
+                x = np.arange(start=x.start, stop=x.stop, step=x.step)
+        # Only one number( 0~1), 'alpha' / color
+        if isinstance(args[iarg], (int, float)):
+            if np.size(args[iarg]) == 1 and 0 <= args[iarg] <= 1:
+                alpha = args[iarg]
+        if isinstance(args[iarg], (list, tuple)) and np.size(args[iarg]) == 3:
+            acolor = args[iarg]
+            acolor = tuple(acolor) if isinstance(acolor, list) else acolor
+        # Color / plotStyle /
+        if (
+            isinstance(args[iarg], str)
+            and len(args[iarg]) == 1
+            and args[iarg] in l_c_one
+        ):
+            acolor = args[iarg]
+        else:
+            if isinstance(args[iarg], str):
+                if args[iarg] in ["sem", "std"]:
+                    paraStdSem = args[iarg]
+                if args[iarg].startswith("#"):
+                    acolor=hue2rgb(args[iarg])
+                if str2list(args[iarg])[0] in l_c_one:
+                    if len(args[iarg]) == 3:
+                        k = [i for i in str2list(args[iarg]) if i in l_c_one]
+                        if k != []:
+                            acolor = k[0] 
+                        st = [i for i in l_style2 if i in args[iarg]]
+                        if st != []:
+                            plotStyle = st[0] 
+                    elif len(args[iarg]) == 2:
+                        k = [i for i in str2list(args[iarg]) if i in l_c_one]
+                        if k != []:
+                            acolor = k[0] 
+                        mk = [i for i in str2list(args[iarg]) if i in l_mark]
+                        if mk != []:
+                            plotMarker = mk[0] 
+                        st = [i for i in l_style1 if i in args[iarg]]
+                        if st != []:
+                            plotStyle = st[0] 
+                if len(args[iarg]) == 1:
+                    k = [i for i in str2list(args[iarg]) if i in l_c_one]
+                    if k != []:
+                        acolor = k[0] 
+                    mk = [i for i in str2list(args[iarg]) if i in l_mark]
+                    if mk != []:
+                        plotMarker = mk[0] 
+                    st = [i for i in l_style1 if i in args[iarg]]
+                    if st != []:
+                        plotStyle = st[0] 
+                if len(args[iarg]) == 2:
+                    st = [i for i in l_style2 if i in args[iarg]]
+                    if st != []:
+                        plotStyle = st[0]
+        # smth
+        if (
+            isinstance(args[iarg], (int, float))
+            and np.size(args[iarg]) == 1
+            and args[iarg] >= 1
+        ):
+            smth = args[iarg]
+    smth = kwargs.get('smth', smth)
+    if "x" not in locals() or x is None:
+        x = np.arange(1, y.shape[1] + 1)
+    elif len(x) < y.shape[1]:
+        y = y[:, x]
+        nRow = y.shape[0]
+        nCol = y.shape[1]
+        print(f"y was corrected, please confirm that {nRow} row, {nCol} col")
+    else:
+        x = np.arange(1, y.shape[1] + 1)
+
+    if x.shape[0] != 1:
+        x = x.T
+    yMean = np.nanmean(y, axis=0)
+    if smth > 1:
+        yMean = savgol_filter(np.nanmean(y, axis=0), smth, 1)
+    else:
+        yMean = np.nanmean(y, axis=0)
+    if paraStdSem == "sem":
+        if smth > 1:
+            wings = savgol_filter(np.nanstd(y, axis=0) / np.sqrt(y.shape[0]), smth, 1)
+        else:
+            wings = np.nanstd(y, axis=0) / np.sqrt(y.shape[0])
+    elif paraStdSem == "std":
+        if smth > 1:
+            wings = savgol_filter(np.nanstd(y, axis=0), smth, 1)
+        else:
+            wings = np.nanstd(y, axis=0)
+
+    # fill_kws = kwargs.get('fill_kws', {})
+    # line_kws = kwargs.get('line_kws', {})
+
+    # setting form kwargs
+    lw = kwargs.get('lw', 1.5)
+    ls= kwargs.get('ls', plotStyle)
+    marker=kwargs.get("marker",plotMarker)
+    label=kwargs.get("label",None)
+    label_line = kwargs.get("label_line",None)
+    label_fill = kwargs.get('label_fill',None)
+    alpha=kwargs.get('alpha',alpha)
+    color=kwargs.get('color', acolor)
+    if not label_line and label:
+        label_line = label
+    kwargs['lw'] = lw
+    kwargs['ls'] = ls
+    kwargs['label_line'] = label_line
+    kwargs['label_fill'] = label_fill
+
+    # set kws_line
+    if 'color' not in kws_line:
+        kws_line['color']=color
+    if 'lw' not in kws_line:
+        kws_line['lw']=lw
+    if 'ls' not in kws_line:
+        kws_line['ls']=ls
+    if 'marker' not in kws_line:
+        kws_line['marker']=marker
+    if 'label' not in kws_line:
+        kws_line['label']=label_line
+
+    # set kws_line
+    if 'color' not in kws_fill:
+        kws_fill['color']=color
+    if 'alpha' not in kws_fill:
+        kws_fill['alpha']=alpha
+    if 'lw' not in kws_fill:
+        kws_fill['lw']=0
+    if 'label' not in kws_fill:
+        kws_fill['label']=label_fill
+
+    fill = ax.fill_between(x, yMean + wings, yMean - wings, **kws_fill)
+    line = ax.plot(x, yMean, **kws_line)
+    return line[0], fill
+
+
+"""
+########## Usage 1 ##########
+plot.stdshade(data,
+              'b',
+              ':',
+              'd',
+              0.1,
+              4,
+              label='ddd',
+              label_line='label_line',
+              label_fill="label-fill")
+plt.legend()
+
+########## Usage 2 ##########
+plot.stdshade(data,
+              'm-',
+              alpha=0.1,
+              lw=2,
+              ls=':',
+              marker='d',
+              color='b',
+              smth=4,
+              label='ddd',
+              label_line='label_line',
+              label_fill="label-fill")
+plt.legend()
+
+"""
+ 

{py2ls-0.1.6.1.dist-info → py2ls-0.1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.1.6.1
+Version: 0.1.6.2
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com

{py2ls-0.1.6.1.dist-info → py2ls-0.1.6.2.dist-info}/RECORD

@@ -133,14 +133,17 @@ py2ls/data/lang_code_iso639.json,sha256=qZiU7H2RLJjDMXK22C-jhwzLJCI5vKmampjB1ys4
 py2ls/db2ls.py,sha256=MMfFX47aIPIyu7fU9aPvX9lbPRPYOpJ_VXwlnWk-8qo,13615
 py2ls/doc.py,sha256=xN3g1OWfoaGUhikbJ0NqbN5eKy1VZVvWwRlhHMgyVEc,4243
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
-py2ls/ips.py,sha256=AaB2GGZmEG_jY3zqZ1qIIdUYSmwWB5pxrISm9HdcCTE,100423
+py2ls/ips.py,sha256=9BV26m0rnk25auM25dUIUKbKRYy6NFzpCYkOqRuUV-I,101177
 py2ls/netfinder.py,sha256=ZsLWGYMeRuGvxj2nqE0Z8ANoaVl18Necfw0HQfh2q7I,45548
-py2ls/plot.py,sha256=jEPy4G-8H9H4kV2bPUpHE2kdS5E0QHu8ruWwEPCVxOU,24876
+py2ls/plot/catplot.py,sha256=fJDMd_LCknWwl-UHrbYEV6h6XBS6pA3_IOoQbnhvbM8,17697
+py2ls/plot/figsets.py,sha256=Oavp-biIuzLy8eWkDYQIMWihe56bLEbfMoPKFY_HWUo,15659
+py2ls/plot/get_color.py,sha256=TBZG8DPCjT9ut24FlxO60bhOeov1iWqkWC7AzP5xQ6Y,2454
+py2ls/plot/stdshade.py,sha256=0Znt14wjpO3zr33Sg44fNTlVsJ4yOrnF7QGt18FNPCE,7702
 py2ls/setuptools-70.1.0-py3-none-any.whl,sha256=2bi3cUVal8ip86s0SOvgspteEF8SKLukECi-EWmFomc,882588
 py2ls/sleep_events_detectors.py,sha256=36MCuRrpurn0Uvzpo3p3b3_JlVsRNHSWCXbJxCGM3mg,51546
 py2ls/stats.py,sha256=Wd9yCKQ_61QD29WMEgMuEcreFxF91NmlPW65iWT2B5w,39041
 py2ls/translator.py,sha256=6S7MmTZmjj8NljVmj0W5uEauu4ePxso3AMf2LvGVRQA,30516
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.1.6.1.dist-info/METADATA,sha256=q3UMQWGGRezjD_20oGOajmiKe5t1qzePfICwPaGe1rQ,17943
-py2ls-0.1.6.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-py2ls-0.1.6.1.dist-info/RECORD,,
+py2ls-0.1.6.2.dist-info/METADATA,sha256=pVPM5bEveg0pnlE82nrKzU_t-HBsRX8ovQprVLESjw4,17943
+py2ls-0.1.6.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py2ls-0.1.6.2.dist-info/RECORD,,

{py2ls-0.1.6.1.dist-info → py2ls-0.1.6.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any