datastock 0.0.44__py3-none-any.whl → 0.0.46__py3-none-any.whl

datastock/_class1.py

@@ -21,6 +21,7 @@ from . import _class1_domain
 from . import _class1_binning
 from . import _class1_interpolate
 from . import _class1_uniformize
+from . import _class1_color_touch as _color_touch
 from . import _export_dataframe
 from . import _find_plateau
 
@@ -923,6 +924,32 @@ class DataStock1(DataStock0):
             inplace=inplace,
         )
 
+    # ---------------------
+    # color touch array
+    # ---------------------
+
+    def get_color_touch(
+        self,
+        data=None,
+        dcolor=None,
+        # options
+        color_default=None,
+        vmin=None,
+        vmax=None,
+        log=None,
+    ):
+
+        return _color_touch.main(
+            coll=self,
+            data=data,
+            dcolor=dcolor,
+            # options
+            color_default=color_default,
+            vmin=vmin,
+            vmax=vmax,
+            log=log,
+        )
+
     # ---------------------
     # Methods computing correlations
     # ---------------------

datastock/_class1_color_touch.py

@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Feb 28 08:53:00 2025
+
+@author: dvezinet
+"""
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import datastock as ds
+
+
+# ###############################################################
+# ###############################################################
+#                  Main
+# ###############################################################
+
+
+def main(
+    coll=None,
+    data=None,
+    dcolor=None,
+    # options
+    color_default=None,
+    vmin=None,
+    vmax=None,
+    log=None,
+):
+
+    # ------------------
+    # check inputs
+    # ------------------
+
+    data, dcolor, color_default, vmin, vmax, log = _check(
+        coll=coll,
+        data=data,
+        dcolor=dcolor,
+        color_default=color_default,
+        vmin=vmin,
+        vmax=vmax,
+        log=log,
+    )
+
+    # ------------------
+    # initialize
+    # ------------------
+
+    shape = data.shape + (4,)
+    color = np.zeros(shape, dtype=float)
+
+    # ------------------
+    # compute - alpha
+    # ------------------
+
+    if log is True:
+        vmin = np.log10(vmin)
+        vmax = np.log10(vmax)
+
+        alpha = (np.log10(data) - vmin) / (vmax - vmin)
+
+    else:
+        alpha = (data - vmin) / (vmax - vmin)
+
+    # ------------------
+    # compute - colors
+    # ------------------
+
+    for k0, v0 in dcolor.items():
+
+        sli = (v0['ind'], slice(0, 3))
+        color[sli] = v0['color']
+
+        sli = tuple([slice(None) for ii in range(data.ndim)] + [-1])
+        color[sli] = alpha
+
+    # ------------------
+    # output
+    # ------------------
+
+    lcol = set([v0['color'] for v0 in dcolor.values()])
+    dcolor = {
+        'color': color,
+        'meaning': {
+            kc: [k0 for k0, v0 in dcolor.items() if v0['color'] == kc]
+            for kc in lcol
+        },
+    }
+
+    return dcolor
+
+
+# ###############################################################
+# ###############################################################
+#                  check
+# ###############################################################
+
+
+def _check(
+    coll=None,
+    data=None,
+    dcolor=None,
+    # options
+    color_default=None,
+    vmin=None,
+    vmax=None,
+    log=None,
+):
+
+    # ------------------
+    # data
+    # ------------------
+
+    lc = [
+        isinstance(data, np.ndarray),
+        isinstance(data, str) and data in coll.ddata.keys(),
+    ]
+    if lc[0]:
+        pass
+    elif lc[1]:
+        data = coll.ddata[data]['data']
+    else:
+        msg = (
+            "Arg data must be a np.ndarray or a key to an existing data!\n"
+            f"Provided: {data}\n"
+        )
+        raise Exception(msg)
+
+
+    # ------------------
+    # dcolor
+    # ------------------
+
+    # --------------------
+    # dcolor format check
+
+    c0 = (
+        isinstance(dcolor, dict)
+        and all([
+            isinstance(k0, str)
+            and isinstance(v0, dict)
+            and sorted(v0.keys()) == ['color', 'ind']
+            for k0, v0 in dcolor.items()
+        ])
+    )
+    if not c0:
+        msg = (
+            "Arg dcolor must be a dict of sub-dicts of shape:\n"
+            "\t- 'key0': {'ind': ..., 'color': ...}\n"
+            "\t-  ...\n"
+            "\t- 'keyN': {'ind': ..., 'color': ...}\n"
+            f"Provided:\n{dcolor}\n"
+        )
+        raise Exception(msg)
+
+    # --------------------
+    # ind and color checks
+
+    dfail = {}
+    shape = data.shape
+    for k0, v0 in dcolor.items():
+
+        c0 = (
+            isinstance(v0['ind'], np.ndarray)
+            and v0['ind'].shape == data.shape
+            and v0['ind'].dtype == bool
+        )
+        if not c0:
+            msg = f"'ind' must be a {shape} bool array, not {v0['ind']}"
+            dfail[k0] = (msg,)
+
+        if not mcolors.is_color_like(v0['color']):
+            msg = f"'color' must be color-like, not {v0['color']}"
+            if k0 in dfail:
+                dfail[k0] = dfail[k0] + (msg,)
+            else:
+                dfail[k0] = (msg,)
+
+    # raise exception
+    if len(dfail) > 0:
+        lmax = np.max([len(f"\t- {k0}: ") for k0 in dfail.keys()])
+        lstr = [
+            f"\t- {k0}:\n".ljust(lmax) + '\n'.join([
+                "".ljust(lmax+4) + f"\t- {v1}".rjust(lmax)
+                for ii, v1 in enumerate(v0)
+            ])
+            for k0, v0 in dfail.items()
+        ]
+        msg = (
+            "Arg dcolor, the following keys have incorrect keys / values:\n"
+            + "\n".join(lstr)
+        )
+        raise Exception(msg)
+
+    # ----------------------
+    # format colors to rgb
+
+    dcol = {}
+    for k0, v0 in dcolor.items():
+        if np.any(v0['ind']):
+            dcol[k0] = {
+                'ind': v0['ind'],
+                'color': mcolors.to_rgb(v0['color']),
+            }
+
+    # ------------------
+    # color_default
+    # ------------------
+
+    if color_default is None:
+        color_default = 'k'
+    if not mcolors.is_color_like(color_default):
+        msg = (
+            "Arg color_default must be color-like!\n"
+            f"Provided: {color_default}\n"
+        )
+        raise Exception(msg)
+
+    color_default = mcolors.to_rgb(color_default)
+
+    # ------------------
+    # vmin, vmax
+    # ------------------
+
+    vmin0 = np.nanmin(data)
+    vmax0 = np.nanmax(data)
+
+    # vmin
+    if vmin is None:
+        vmin = vmin0
+    c0 = (np.isscalar(vmin) and np.isfinite(vmin) and vmin < vmax0)
+    if not c0:
+        msg = (
+            f"Arg vmin must be a finite scalar below max ({vmax0})\n"
+            f"Provided: {vmin}\n"
+        )
+        raise Exception(msg)
+
+    # vmax
+    if vmax is None:
+        vmax = vmax0
+    c0 = (np.isscalar(vmax) and np.isfinite(vmax) and vmax > vmin0)
+    if not c0:
+        msg = (
+            f"Arg vmax must be a finite scalar above min ({vmin0})\n"
+            f"Provided: {vmax}\n"
+        )
+        raise Exception(msg)
+
+    # ordering
+    if vmin >= vmax:
+        msg = (
+            "Arg vmin must be below vmax!\n"
+            f"Provided:\n\t- vmin = {vmin}\n\t- vmax = {vmax}\n"
+        )
+        raise Exception(msg)
+
+    # ------------------
+    # log
+    # ------------------
+
+    log = ds._generic_check._check_var(
+        log, 'log',
+        types=bool,
+        default=False,
+    )
+
+    return data, dcol, color_default, vmin, vmax, log

datastock/_class1_compute.py

@@ -1233,4 +1233,4 @@ def _extract_select(
             # lkey=[idq2dR],
             # return_all=True,
         # )
-    # return out
+    # return out

datastock/_class1_domain.py

@@ -30,11 +30,14 @@ def domain_ref(
     # -----------
     # get indices
 
-    lvectu = sorted({v0['vect'] for v0 in domain.values()})
+    lvectu = sorted({
+        v0['vect'] for v0 in domain.values()
+        if v0.get('vect') is not None
+    })
 
     for vv in lvectu:
 
-        lk0 = [k0 for k0, v0 in domain.items() if v0['vect'] == vv]
+        lk0 = [k0 for k0, v0 in domain.items() if v0.get('vect') == vv]
         for k0 in lk0:
 
             if domain[k0].get('domain') is None:
@@ -61,12 +64,14 @@ def _check(
 
     # ---------
     # prepare
+    # ---------
 
     ldata = list(coll.ddata.keys())
     lref = list(coll.dref.keys())
 
     # ------------
     # domain
+    # ------------
 
     c0 = (
         isinstance(domain, dict)
@@ -80,24 +85,17 @@ def _check(
         )
         raise Exception(msg)
 
-    # ------------
+    # --------------
     # check each key
+    # --------------
 
     dfail = {}
     domain = copy.deepcopy(domain)
     for k0, v0 in domain.items():
 
-        # check ref vector
-        kwd = {'ref': k0} if k0 in lref else {'key0': k0}
-        hasref, hasvect, ref, vect = coll.get_ref_vector(**kwd)[:4]
-        if not (hasref and ref is not None):
-            dfail[k0] = "No associated ref identified!"
-            continue
-        if not (hasvect and vect is not None):
-            dfail[k0] = "No associated ref vector identified!"
-            continue
-
+        # -----------
         # v0 is dict
+
         ltyp = (list, tuple, np.ndarray)
         if isinstance(v0, ltyp):
             domain[k0] = {'domain': v0}
@@ -106,21 +104,42 @@ def _check(
 
         c0 = (
             isinstance(domain[k0], dict)
-            and any(ss in ['ind', 'domain'] for ss in domain[k0].keys())
+            and any([ss in ['ind', 'domain'] for ss in domain[k0].keys()])
             and (
                 isinstance(domain[k0].get('domain'), ltyp)
                 or np.isscalar(domain[k0].get('domain', 0))
             )
-            and isinstance(domain[k0].get('ind', np.r_[0]), np.ndarray)
+            and isinstance(domain[k0].get('ind', np.r_[0]), (np.ndarray, int))
         )
+
         if not c0:
             dfail[k0] = "must be a dict with keys ['ind', 'domain']"
             continue
 
+        # ----------------
+        # check ref vector
+
+        kwd = {'ref': k0} if k0 in lref else {'key0': k0}
+        hasref, hasvect, ref, vect = coll.get_ref_vector(**kwd)[:4]
+
+        if not (hasref and ref is not None):
+            dfail[k0] = "No associated ref identified!"
+            continue
+
         # vect
-        domain[k0]['vect'] = vect
+        domain[k0]['ref'] = ref
 
+        if domain[k0].get('domain') is not None:
+            if not (hasvect and vect is not None):
+                dfail[k0] = "No associated ref vector identified!"
+                continue
+
+            # vect
+            domain[k0]['vect'] = vect
+
+        # -------
         # domain
+
         dom = domain[k0].get('domain')
         if dom is not None:
             dom, err = _check_domain(dom)
@@ -129,10 +148,15 @@ def _check(
                 continue
             domain[k0]['domain'] = dom
 
+        # -----
         # ind
+
         ind = domain[k0].get('ind')
         if ind is not None:
-            vsize = coll.ddata[vect]['data'].size
+            if np.isscalar(ind):
+                ind = np.array([ind], dtype=int)
+
+            vsize = coll.dref[ref]['size']
             if ind.dtype == bool:
                 pass
             elif 'int' in ind.dtype.name:
@@ -151,12 +175,14 @@ def _check(
 
     # -----------
     # errors
+    # -----------
 
     if len(dfail) > 0:
         lstr = [f"\t- '{k0}': {v0}" for k0, v0 in dfail.items()]
         msg = (
             "The following domain keys / values are not conform:\n"
              + "\n".join(lstr)
+             + f"\nProvided:\n{domain}"
         )
         raise Exception(msg)
 

datastock/_class1_interpolate.py

@@ -88,6 +88,7 @@ def interpolate(
         ddata, dout, dsh_other, sli_c, sli_x, sli_v,
         log_log, nan0, grid, ndim, xunique,
         returnas, return_params, store, inplace,
+        domain,
     ) = _check(
         coll=coll,
         # interpolation base
@@ -143,7 +144,7 @@ def interpolate(
     # adjust data and ref if xunique
 
     if xunique:
-        _xunique(dout)
+        _xunique(dout, domain=domain)
 
     # --------
     # store
@@ -392,9 +393,9 @@ def _check(
     )
 
     # ---------------------
-    # get dvect from domain
+    # get dref_dom from domain
 
-    domain, dvect = _get_dvect(
+    domain, dref_dom = _get_drefdom(
         coll=coll,
         domain=domain,
         ref_key=ref_key,
@@ -407,7 +408,7 @@ def _check(
         coll=coll,
         keys=keys,
         ref_key=ref_key,
-        dvect=dvect,
+        dref_dom=dref_dom,
     )
 
     # --------
@@ -422,7 +423,7 @@ def _check(
     )
 
     if ref_com is not None and domain is not None:
-        if ref_com in [coll.ddata[k0]['ref'][0] for k0 in dvect.keys()]:
+        if ref_com in list(dref_dom.keys()):
             msg = (
                 "Arg ref_com and domain cannot be applied to the same ref!\n"
                 f"\t- ref_com: {ref_com}\n"
@@ -440,8 +441,10 @@ def _check(
         x0=x0,
         daxis=daxis,
         dunits=dunits,
+        # ref com
         dref_com=dref_com,
-        dvect=dvect,
+        # domain
+        dref_dom=dref_dom,
     )
 
     # --------------
@@ -488,6 +491,7 @@ def _check(
         ddata, dout, dsh_other, sli_c, sli_x, sli_v,
         log_log, nan0, grid, ndim, xunique,
         returnas, return_params, store, inplace,
+        domain,
     )
 
 
@@ -963,56 +967,59 @@ def _x01_grid(
     return x0, x1, refx, ix, xunique
 
 
-def _get_dvect(
+def _get_drefdom(
     coll=None,
     domain=None,
     ref_key=None,
 ):
     # ----------------
-    # domain => dvect
+    # domain => dref_dom
+
+    lr_ref_key = [coll.ddata[kk]['ref'][0] for kk in ref_key]
 
     if domain is not None:
 
         # get domain
         domain = coll.get_domain_ref(domain)
 
-        # derive dvect
-        lvectu = sorted({
-            v0['vect'] for v0 in domain.values() if v0['vect'] not in ref_key
+        # derive lrefu
+        lrefu = sorted({
+            v0['ref'] for v0 in domain.values() if v0['ref'] not in lr_ref_key
         })
 
-        dvect = {
-            k0: [k1 for k1, v1 in domain.items() if v1['vect'] == k0]
-            for k0 in lvectu
+        # derive dref_dom
+        dref_dom = {
+            rr: [k1 for k1, v1 in domain.items() if v1['ref'] == rr]
+            for rr in lrefu
         }
 
         # check unicity of vect
-        dfail = {k0: v0 for k0, v0 in dvect.items() if len(v0) > 1}
+        dfail = {k0: v0 for k0, v0 in dref_dom.items() if len(v0) > 1}
         if len(dfail) > 0:
             lstr = [f"\t- '{k0}': {v0}" for k0, v0 in dfail.items()]
             msg = (
-                "Some ref vector have been specified with multiple domains!\n"
+                "Some ref have been specified with multiple domains!\n"
                 + "\n".join(lstr)
             )
             raise Exception(msg)
 
-        # build final dvect
-        dvect = {
+        # build final dref_dom
+        dref_dom = {
             k0: domain[v0[0]]['ind']
-            for k0, v0 in dvect.items()
+            for k0, v0 in dref_dom.items()
         }
 
     else:
-        dvect = None
+        dref_dom = None
 
-    return domain, dvect
+    return domain, dref_dom
 
 
 def _get_ddata(
     coll=None,
     keys=None,
     ref_key=None,
-    dvect=None,
+    dref_dom=None,
 ):
 
     # --------
@@ -1024,13 +1031,12 @@ def _get_ddata(
         data = coll.ddata[k0]['data']
 
         # apply domain
-        if dvect is not None:
-            for k1, v1 in dvect.items():
-                ref = coll.ddata[k1]['ref'][0]
-                if ref in coll.ddata[k0]['ref']:
-                    ax = coll.ddata[k0]['ref'].index(ref)
+        if dref_dom is not None:
+            for rr, vr in dref_dom.items():
+                if rr in coll.ddata[k0]['ref']:
+                    ax = coll.ddata[k0]['ref'].index(rr)
                     sli = tuple([
-                        v1 if ii == ax else slice(None)
+                        vr if ii == ax else slice(None)
                         for ii in range(data.ndim)
                     ])
                     data = data[sli]
@@ -1050,7 +1056,7 @@ def _get_dout(
     # common refs
     dref_com=None,
     # domain
-    dvect=None,
+    dref_dom=None,
 ):
 
     # -------------
@@ -1069,11 +1075,11 @@ def _get_dout(
         rd = list(coll.ddata[k0]['ref'])
 
         # apply domain
-        if dvect is not None:
-            for k1, v1 in dvect.items():
-                if coll.ddata[k1]['ref'][0] in rd:
-                    ax = rd.index(coll.ddata[k1]['ref'][0])
-                    sh[ax] = len(v1) if v1.dtype == int else v1.sum()
+        if dref_dom is not None:
+            for rr, vr in dref_dom.items():
+                if rr in rd:
+                    ax = rd.index(rr)
+                    sh[ax] = len(vr) if vr.dtype == int else vr.sum()
                     rd[ax] = None
 
         # ------------------------
@@ -1556,7 +1562,7 @@ def _interp2d(
 # ###############################################################
 
 
-def _xunique(dout=None):
+def _xunique(dout=None, domain=None):
     """ interpolation on a single point => eliminates a ref  """
 
     # ----------
@@ -1567,13 +1573,18 @@ def _xunique(dout=None):
         for k0, v0 in dout.items()
     }
 
-    dwrong = {k0: v0 for k0, v0 in dind.items() if len(v0) != 1}
+    # Number of Nones expected
+    ndom = 0 if domain is None else len(domain)
+    nNone = 1 + ndom
+
+    # check
+    dwrong = {k0: v0 for k0, v0 in dind.items() if len(v0) != nNone}
     if len(dwrong) > 0:
         lstr = [
             f"\t- {k0}: {dout[k0]['ref']} => {v0}" for k0, v0 in dwrong.items()
         ]
         msg = (
-            "Interpolation at unique point => ref should have one None:\n"
+            "Interpolate unique pt => ref should have nNone = 1 + {ndom}:\n"
             + "\n".join(lstr)
         )
         raise Exception(msg)
@@ -1616,7 +1627,12 @@ def _store(
         ldata = list(set(itt.chain.from_iterable([
             v0['ref'] for v0 in dout.values()
         ])))
-        coll2 = coll.extract(keys=ldata, vectors=True)
+
+        coll2 = coll.extract(
+            keys=ldata,
+            inc_vectors=True,
+            return_keys=False,
+        )
 
     # -------------
     # store_keys
@@ -1634,7 +1650,13 @@ def _store(
         excluded=lout,
     )
 
-    assert len(store_keys) == len(dout)
+    if len(store_keys) != len(dout):
+        msg = (
+            "Nb of store_keys != nb of keys in dout!\n"
+            f"\t- store_keys:\n{store_keys}\n "
+            f"\t- dout.keys():\n{sorted(dout.keys())}\n "
+        )
+        raise Exception(msg)
 
     # ---------
     # add data
@@ -1648,4 +1670,4 @@ def _store(
             units=v0['units'],
         )
 
-    return coll2
+    return coll2

datastock/tests/test_01_DataStock.py

@@ -306,11 +306,26 @@ class Test02_Manipulate():
         self.st.show_data()
         self.st.show_obj()
 
+    # ------------------------
+    #   dcolor
+    # ------------------------
+
+    def test06_get_dcolor_touch(self):
+        xx = np.arange(50)
+        aa = np.exp(-(xx[:, None]-25)**2/10**2 - (xx[None, :]-25)**2/10**2)
+        ind = (aa>0.3) & (np.arange(50)[None, :] > 25)
+        dcolor = self.st.get_color_touch(
+            aa,
+            dcolor={'foo': {'ind': ind, 'color': 'r'}}
+        )
+        assert dcolor['color'].shape == aa.shape + (4,)
+        assert dcolor['meaning'][(1.0, 0.0, 0.0)] == ['foo']
+
     # ------------------------
     #   Interpolate
     # ------------------------
 
-    def test06_get_ref_vector(self):
+    def test07_get_ref_vector(self):
         (
             hasref, hasvector,
             ref, key_vector,
@@ -325,13 +340,13 @@ class Test02_Manipulate():
         assert values.size == dind['ind'].size == 4
         assert dind['indr'].shape == (2, 4)
 
-    def test07_get_ref_vector_common(self):
+    def test08_get_ref_vector_common(self):
         hasref, ref, key, val, dout = self.st.get_ref_vector_common(
             keys=['t0', 'prof0', 'prof1', 't3'],
             dim='time',
         )
 
-    def test08_domain_ref(self):
+    def test09_domain_ref(self):
 
         domain = {
             'nx': [1.5, 2],
@@ -347,7 +362,7 @@ class Test02_Manipulate():
         lk = list(domain.keys())
         assert all([isinstance(dout[k0]['ind'], np.ndarray) for k0 in lk])
 
-    def test09_binning(self):
+    def test10_binning(self):
 
         bins = np.linspace(1, 5, 8)
         lk = [
@@ -399,7 +414,7 @@ class Test02_Manipulate():
                 )
                 raise Exception(msg)
 
-    def test10_interpolate(self):
+    def test11_interpolate(self):
 
         lk = ['y', 'y', 'prof0', 'prof0', 'prof0', '3d']
         lref = [None, 'nx', 't0', ['nt0', 'nx'], ['t0', 'x'], ['t0', 'x']]
@@ -443,7 +458,7 @@ class Test02_Manipulate():
                 msg = str(dout[kk]['data'].shape, shape, kk, rr)
                 raise Exception(msg)
 
-    def test11_interpolate_common_refs(self):
+    def test12_interpolate_common_refs(self):
         lk = ['3d', '3d', '3d']
         lref = ['t0', ['nt0', 'nx'], ['nx']]
         lrefc = ['nc', 'nc', 'nt0']
@@ -519,17 +534,17 @@ class Test02_Manipulate():
     #   Plotting
     # ------------------------
 
-    def test12_plot_as_array_1d(self):
+    def test13_plot_as_array_1d(self):
         dax = self.st.plot_as_array(key='t0')
         plt.close('all')
         del dax
 
-    def test13_plot_as_array_2d(self):
+    def test14_plot_as_array_2d(self):
         dax = self.st.plot_as_array(key='prof0')
         plt.close('all')
         del dax
 
-    def test14_plot_as_array_2d_log(self):
+    def test15_plot_as_array_2d_log(self):
         dax = self.st.plot_as_array(
             key='pec', keyX='ne', keyY='Te',
             dscale={'data': 'log'},
@@ -537,17 +552,17 @@ class Test02_Manipulate():
         plt.close('all')
         del dax
 
-    def test15_plot_as_array_3d(self):
+    def test16_plot_as_array_3d(self):
         dax = self.st.plot_as_array(key='3d', dvminmax={'keyX': {'min': 0}})
         plt.close('all')
         del dax
 
-    def test16_plot_as_array_3d_ZNonMonot(self):
+    def test17_plot_as_array_3d_ZNonMonot(self):
         dax = self.st.plot_as_array(key='3d', keyZ='y')
         plt.close('all')
         del dax
 
-    def test17_plot_as_array_4d(self):
+    def test18_plot_as_array_4d(self):
         dax = self.st.plot_as_array(key='4d', dscale={'keyU': 'linear'})
         plt.close('all')
         del dax
@@ -557,7 +572,7 @@ class Test02_Manipulate():
     #     plt.close('all')
     #     del dax
 
-    def test19_plot_as_profile1d(self):
+    def test20_plot_as_profile1d(self):
         dax = self.st.plot_as_profile1d(
             key='prof0',
             key_time='t0',
@@ -591,7 +606,7 @@ class Test02_Manipulate():
     #   File handling
     # ------------------------
 
-    def test21_copy_equal(self):
+    def test22_copy_equal(self):
         st2 = self.st.copy()
         assert st2 is not self.st
 
@@ -599,15 +614,15 @@ class Test02_Manipulate():
         if msg is not True:
             raise Exception(msg)
 
-    def test22_get_nbytes(self):
+    def test23_get_nbytes(self):
         nb, dnb = self.st.get_nbytes()
 
-    def test23_save_pfe(self, verb=False):
+    def test24_save_pfe(self, verb=False):
         pfe = os.path.join(_PATH_OUTPUT, 'testsave.npz')
         self.st.save(pfe=pfe, return_pfe=False)
         os.remove(pfe)
 
-    def test24_saveload(self, verb=False):
+    def test25_saveload(self, verb=False):
         pfe = self.st.save(path=_PATH_OUTPUT, verb=verb, return_pfe=True)
         st2 = load(pfe, verb=verb)
         # Just to check the loaded version works fine
@@ -616,7 +631,7 @@ class Test02_Manipulate():
             raise Exception(msg)
         os.remove(pfe)
 
-    def test25_saveload_coll(self, verb=False):
+    def test26_saveload_coll(self, verb=False):
         pfe = self.st.save(path=_PATH_OUTPUT, verb=verb, return_pfe=True)
         st = DataStock()
         st2 = load(pfe, coll=st, verb=verb)

datastock/version.py

@@ -1,2 +1,2 @@
 # Do not edit, pipeline versioning governed by git tags!
-__version__ = '0.0.44'
+__version__ = '0.0.46'

{datastock-0.0.44.dist-info → datastock-0.0.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datastock
-Version: 0.0.44
+Version: 0.0.46
 Summary: A python library for generic class and data handling
 Home-page: https://github.com/ToFuProject/datastock
 Author: Didier VEZINET

{datastock-0.0.44.dist-info → datastock-0.0.46.dist-info}/RECORD

@@ -3,12 +3,13 @@ datastock/_DataCollection_utils.py,sha256=hHf6HvGKMmM-psx3fj9QcY1TEmKrAtTdkRokH7
 datastock/__init__.py,sha256=i_Ijl-AM07n4zN52frWfbeGN1iB6v4e5oLzTuVIh_oM,217
 datastock/_class.py,sha256=Az9PS3aSskiPMb1ekt78Y2ynBujYVc_cDjJxW9xH9g4,47
 datastock/_class0.py,sha256=je4ckTynK8lEGBa7OSURYZZ_-3XjzAtf6SazN3b-f5k,6028
-datastock/_class1.py,sha256=WlI666OOG8x-qtfNRcwP7aoCs7TDfvk3yKzVsHShO7c,28745
+datastock/_class1.py,sha256=2PrIT26yRfNrP6YmZMpvb0_b0v_397Y9tOjzeVOxK_I,29313
 datastock/_class1_binning.py,sha256=LWHv2LIfgZfSFWYwqdcN0DKpNe6q7Go3sxfcJqmzTrI,28085
 datastock/_class1_check.py,sha256=0azV7ftoAWsqTMEYbGQ_luJi95Px-pBif_vOug3W8Zg,50978
-datastock/_class1_compute.py,sha256=yHdG0afYc_YtjpR6RvMh7SeRtWEyuHZ5y9VOPRIYVDo,31671
-datastock/_class1_domain.py,sha256=bkuCl29QO7C3RchC8qZyreU90QxmdDYNVYDmzuCLCUY,6252
-datastock/_class1_interpolate.py,sha256=3LRKK6aOepJLSnRoRpsS8RAnobqTdE-QZrkdQrnIaqc,37825
+datastock/_class1_color_touch.py,sha256=KoIFCVkJJnGrEChbvDSkgs-KZeRpFyCIA-fE7mrYrLs,6294
+datastock/_class1_compute.py,sha256=yZfj-Fy4wlEyWotWqNwtNtpjF6mak5nMu2ut2OBpzTY,31672
+datastock/_class1_domain.py,sha256=_xUCnwWJX5wPPYrpiGGrRwrPLmiO5BMm3nmYvn_YEOg,6716
+datastock/_class1_interpolate.py,sha256=3VKGMDsiWFQUguMHxMaTQTyMhcN8Ikg1PmaH6TjIeLg,38348
 datastock/_class1_show.py,sha256=hqd-FeJ1NqiOzbrHzGMrwIo8_lLsjC199Zmw68NqkDQ,11745
 datastock/_class1_uniformize.py,sha256=dEJime_0SqmW8hX8ooZpHsPI_d8CIE9U9Yz9GhqsEUY,28433
 datastock/_class2.py,sha256=FG-ZGPVdZEdkRc_3Z9LRzYdRm9Xat7HI06E3-hI5rCk,45422
@@ -31,12 +32,12 @@ datastock/_plot_correlations.py,sha256=ITOypu_AEoKl0ihxocV-JVTXIHqut6p9TfG-xZmQy
 datastock/_plot_old_backup.py,sha256=XixTi2CiihKjtQP0TRycH0b25caWN1m35DgpsDeiWZE,21729
 datastock/_plot_text.py,sha256=wQPqjfpLyIioS2JeOt3E9C9HgYUJ49YEoOgRuKYvAR8,3143
 datastock/_saveload.py,sha256=1vAMp27KfqXbo5b_Pi8hJux0stsHq6dO5vy8k1d4_iA,14141
-datastock/version.py,sha256=EX8urNJ1ILJpXuRtvcV0i0MWqPQj1IxD_snvo_plkfg,80
+datastock/version.py,sha256=TTZXyi6fkfPDWOJIxiEa00X66SrcWUHC11j32Bjcyh0,80
 datastock/tests/__init__.py,sha256=teOo2xP0IO7PQMuMDmum61XVHe2TuxW3BiHiL73X8jQ,35
-datastock/tests/test_01_DataStock.py,sha256=tGVJiCVjWT5oR4DlFopbcKMxi2cpCbBvdBDRc0WV1KU,17532
+datastock/tests/test_01_DataStock.py,sha256=Ngz0nbb7Qj3Sr0c4TV2OlK_v4R6aMBrQYXr8BWaYAnw,18048
 datastock/tests/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datastock-0.0.44.dist-info/LICENSE,sha256=V1uXqi3vxR0QhB4QdFyjkynl6jpN4wZmlB5EMYJk0NM,1068
-datastock-0.0.44.dist-info/METADATA,sha256=XTfrvF04pd1W2uJ7lOUhlFWpvL7pQBWxwa7Updlhazc,8660
-datastock-0.0.44.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-datastock-0.0.44.dist-info/top_level.txt,sha256=BzJsLLK_zZw13WQCoMhC74qWVKalnVCjBxdPXvJn7HQ,25
-datastock-0.0.44.dist-info/RECORD,,
+datastock-0.0.46.dist-info/LICENSE,sha256=V1uXqi3vxR0QhB4QdFyjkynl6jpN4wZmlB5EMYJk0NM,1068
+datastock-0.0.46.dist-info/METADATA,sha256=rs7ozSmlV2xJ4_yOJIwDrDj3brqxOHxqZRlG7W2hLqA,8660
+datastock-0.0.46.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+datastock-0.0.46.dist-info/top_level.txt,sha256=BzJsLLK_zZw13WQCoMhC74qWVKalnVCjBxdPXvJn7HQ,25
+datastock-0.0.46.dist-info/RECORD,,