datastock 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

datastock/_class1_show.py

@@ -0,0 +1,406 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Feb  5 15:16:42 2024
+
+@author: dvezinet
+"""
+
+
+import numpy as np
+
+
+from . import _generic_utils
+from . import _generic_check
+
+
+
+#############################################
+#############################################
+#       Main
+#############################################
+
+
+def main(
+    coll=None,
+    # options
+    show_which=None,
+    show=None,
+    # print parameters
+    sep=None,
+    line=None,
+    justify=None,
+    table_sep=None,
+    # bool options
+    verb=True,
+    returnas=False,
+):
+
+    # -------------
+    # check inputs
+    # -------------
+
+    show_which, show = _check_inputs(
+        coll=coll,
+        show_which=show_which,
+        show=show,
+    )
+
+    # intialize
+    lcol, lar = [], []
+
+    # -----------------------
+    # Build for dref
+    # -----------------------
+
+    if 'ref' in show_which and len(coll._dref) > 0:
+        lcol, lar = _show_ref(coll, lcol=lcol, lar=lar, show=show)
+
+    # -----------------------
+    # Build for ddata
+    # -----------------------
+
+    if 'data' in show_which and len(coll._ddata) > 0:
+        lcol, lar = _show_data(coll, lcol=lcol, lar=lar, show=show)
+
+    # -----------------------
+    # Build for dobj
+    # -----------------------
+
+    anyobj = (
+        len(coll._dobj) > 0
+        and any([
+            ss in show_which
+            for ss in ['obj'] + list(coll._dobj.keys())
+        ])
+    )
+    if anyobj:
+        for k0 in coll._dobj.keys():
+            if 'obj' in show_which or k0 in show_which:
+                func = coll._get_show_obj(k0)
+                lcol, lar = func(coll=coll, which=k0, lcol=lcol, lar=lar, show=show)
+
+    return _generic_utils.pretty_print(
+        headers=lcol,
+        content=lar,
+        sep=sep,
+        line=line,
+        table_sep=table_sep,
+        verb=verb,
+        returnas=returnas,
+    )
+
+
+###########################################################
+###########################################################
+#       check
+###########################################################
+
+
+def _check_inputs(
+    coll=None,
+    show_which=None,
+    show=None,
+):
+
+    # -------------
+    # show_which
+    # -------------
+
+    if show_which is None:
+        show_which = ['ref', 'data', 'obj']
+
+    if isinstance(show_which, str):
+        show_which = [show_which]
+
+    lok = ['ref', 'data'] + list(coll._dobj.keys())
+    show_which = _generic_check._check_var_iter(
+        show_which, 'show_which',
+        types=(list, tuple),
+        types_iter=str,
+        allowed=lok + ['obj'],
+    )
+
+    # tuple => exclusion
+    if isinstance(show_which, tuple):
+
+        if 'obj' in show_which:
+            show_which = [
+                k0 for k0 in ['ref', 'data'] if k0 not in show_which
+            ]
+
+        else:
+            show_which = [
+                k0 for k0 in lok
+                if k0 not in show_which
+            ]
+    else:
+        if 'obj' in show_which:
+            show_which = (
+                [k0 for k0 in ['ref', 'data'] if k0 in show_which]
+                + list(coll._dobj.keys())
+            )
+
+    # -------------
+    # show
+    # -------------
+
+    if len(show_which) == 1:
+
+        if isinstance(show, str):
+            show = [show]
+
+        if show_which[0] == 'ref':
+            lok = list(coll.dref.keys())
+        elif show_which[0] == 'data':
+            lok = list(coll.ddata.keys())
+        else:
+            lok = list(coll.dobj.get(show_which[0], {}).keys())
+
+        show = _generic_check._check_var_iter(
+            show, 'show',
+            types=(list, tuple),
+            types_iter=str,
+            allowed=lok,
+        )
+
+    else:
+        show = None
+
+    return show_which, show
+
+
+###########################################################
+###########################################################
+#       specific show
+###########################################################
+
+
+def _show_ref(coll=None, lcol=None, lar=None, show=None):
+
+    # ----------------
+    # column names
+    # ----------------
+
+    lcol.append(['ref key', 'size', 'nb. data', 'nb. data monot.'])
+
+    # ---------------
+    # prepare array
+    # ---------------
+
+    lk0 = [
+        k0 for k0 in coll._dref.keys()
+        if show is None or k0 in show
+    ]
+
+    lar.append([
+        [
+            k0,
+            str(coll._dref[k0]['size']),
+            str(len(coll._dref[k0]['ldata'])),
+            str(len(coll._dref[k0]['ldata_monot'])),
+        ]
+        for k0 in lk0
+    ])
+
+    # ---------------------------
+    # indices (for interactivity)
+    # ---------------------------
+
+    lp = coll.get_lparam(which='ref')
+    if 'indices' in lp:
+        lcol[0].append('indices')
+        for ii, (k0, v0) in enumerate(coll._dref.items()):
+            if coll._dref[k0]['indices'] is None:
+                lar[0][ii].append(str(v0['indices']))
+            else:
+                lar[0][ii].append(str(list(v0['indices'])))
+
+    # ---------------------------
+    # group (for interactivity)
+    # ---------------------------
+
+    if 'group' in lp:
+        lcol[0].append('group')
+        for ii, (k0, v0) in enumerate(coll._dref.items()):
+            lar[0][ii].append(str(coll._dref[k0]['group']))
+
+    # ---------------------------
+    # inc (for interactivity)
+    # ---------------------------
+
+    if 'inc' in lp:
+        lcol[0].append('increment')
+        for ii, (k0, v0) in enumerate(coll._dref.items()):
+            lar[0][ii].append(str(coll._dref[k0]['inc']))
+
+    return lcol, lar
+
+
+def _show_data(coll=None, lcol=None, lar=None, show=None):
+
+    # ----------------
+    # parameters
+    # ----------------
+
+    lk = _show_get_fields(
+        which='data',
+        lparam=coll.get_lparam(which='data', for_show=True),
+        dshow=coll._dshow,
+    )
+
+    # ---------------------------
+    # column names
+    # ---------------------------
+
+    lcol.append(['data'] + [pp.split('.')[-1] for pp in lk])
+
+    # ---------------------------
+    # data
+    # ---------------------------
+
+    lk0 = [
+        k0 for k0 in coll._ddata.keys()
+        if show is None or k0 in show
+    ]
+
+    lar.append([
+        [k0] + _show_extract(dobj=coll._ddata[k0], lk=lk)
+        for k0 in lk0
+    ])
+
+    return lcol, lar
+
+
+def _show_obj_def(coll=None, which=None, lcol=None, lar=None, show=None):
+
+    # ----------------
+    # parameters
+    # ----------------
+
+    lk = _show_get_fields(
+        which=which,
+        lparam=coll.get_lparam(which=which, for_show=True),
+        dshow=coll._dshow,
+    )
+
+    # ---------------------------
+    # column names
+    # ---------------------------
+
+    lcol.append([which] + [pp.split('.')[-1] for pp in lk])
+
+    # ---------------------------
+    # data
+    # ---------------------------
+
+    lkey = [
+        k1 for k1 in coll._dobj.get(which, {}).keys()
+        if show is None or k1 in show
+    ]
+
+    lar.append([
+        [k1] + _show_extract(dobj=coll.dobj[which][k1], lk=lk)
+        for k1 in lkey
+    ])
+
+    return lcol, lar
+
+
+###########################################################
+###########################################################
+#       Utilities
+###########################################################
+
+
+def _get_lparam_show_append(which, key, val, lparam, for_show):
+
+    c0 = (
+        callable(val)
+        or 'class' in key
+        or 'handle' in key
+        or (which == 'axes' and key == 'bck')
+        or isinstance(val, dict)
+    )
+    if key not in lparam and ((not for_show) or (for_show and not c0)):
+        lparam.append(key)
+
+
+def _get_lparam(which=None, dd=None, for_show=None):
+
+    if for_show:
+        lparam = []
+        for k0, v0 in dd.items():
+            for k1, v1 in v0.items():
+                if isinstance(v1, dict):
+                    for k2, v2 in v1.items():
+                        k3 = f'{k1}.{k2}'
+                        _get_lparam_show_append(
+                            which, k3, v2, lparam, for_show,
+                        )
+                else:
+                    _get_lparam_show_append(
+                        which, k1, v1, lparam, for_show,
+                    )
+
+    else:
+        lparam = list(list(dd.values())[0].keys())
+
+    return lparam
+
+
+def _show_get_fields(which=None, lparam=None, dshow=None):
+
+    # show dict
+    if which not in dshow.keys():
+        lk = lparam
+
+    else:
+        lk = dshow[which]
+
+        if isinstance(lk, list):
+            lk = [
+                kk for kk in dshow[which]
+                if kk in lparam
+            ]
+        elif isinstance(lk, tuple):
+            lk = [
+                kk for kk in lparam
+                if kk not in dshow[which]
+            ]
+        else:
+            msg = f"Unreckognized dshow['{which}']"
+            raise Exception(msg)
+
+    return lk
+
+
+def _show_extract(dobj=None, lk=None):
+
+    lv0 = []
+    for k0 in lk:
+
+        lk0 = k0.split('.')
+        for ii in range(len(lk0)):
+            if ii == 0:
+                v0 = dobj[lk0[ii]]
+            elif v0 is not None:
+                v0 = v0[lk0[ii]]
+
+        # formatting
+        if isinstance(v0, float):
+            lv0.append(f'{v0:.2e}')
+
+        elif isinstance(v0, np.ndarray) and v0.size == 3:
+            if v0.dtype == float:
+                lv0.append(
+                    np.array2string(
+                        v0,
+                        formatter={'float': lambda x: f'{x:.3e}'},
+                    ),
+                )
+            else:
+                lv0.append(str(v0))
+        else:
+            lv0.append(str(v0))
+
+    return lv0

datastock/_class1_uniformize.py

@@ -34,6 +34,8 @@ def get_ref_vector(
     # ressources
     ddata=None,
     dref=None,
+    # data to find vector for
+    key0=None,
     # inputs
     key=None,
     ref=None,
@@ -58,13 +60,21 @@ def get_ref_vector(
         default=True,
     )
 
-    # key
+    # key0
     lkok = list(ddata.keys()) + [None]
-    key = _generic_check._check_var(
-        key, 'key',
+    key0 = _generic_check._check_var(
+        key0, 'key0',
         allowed=lkok,
     )
 
+    # key
+    if key is not None:
+        lkok = list(ddata.keys()) + [None]
+        key = _generic_check._check_var(
+            key, 'key',
+            allowed=lkok,
+        )
+
     # ref
     lkok = list(dref.keys()) + [None]
     ref = _generic_check._check_var(
@@ -72,8 +82,8 @@ def get_ref_vector(
         allowed=lkok,
     )
 
-    if key is None and ref is None:
-        msg = "Please provide key or ref at least!"
+    if key0 is None and ref is None:
+        msg = "Please provide key0 or ref at least!"
         raise Exception(msg)
 
     # warn
@@ -87,8 +97,8 @@ def get_ref_vector(
     # hasref, hasvect
 
     hasref = None
-    if ref is not None and key is not None:
-        hasref = ref in ddata[key]['ref']
+    if ref is not None and key0 is not None:
+        hasref = ref in ddata[key0]['ref']
         if not hasref:
             ref = None
     elif ref is not None:
@@ -96,8 +106,8 @@ def get_ref_vector(
 
     if hasref is True:
         refok = (ref,)
-    elif key is not None:
-        refok = ddata[key]['ref']
+    elif key0 is not None:
+        refok = ddata[key0]['ref']
 
     # identify possible vect
     if hasref is not False:
@@ -113,10 +123,14 @@ def get_ref_vector(
             ])
         ]
 
-        # particular case
+        # if key is provided
         if key is not None and key in lk_vect:
             lk_vect = [key]
 
+        # particular case
+        if key0 is not None and key0 in lk_vect:
+            lk_vect = [key0]
+
         # cases
         if len(lk_vect) == 0:
             if warn is True:
@@ -137,7 +151,7 @@ def get_ref_vector(
             if warn is True:
                 msg = (
                     f"Multiple possible vectors found:\n{lk_vect}\n"
-                    f"\t- key: {key}\n"
+                    f"\t- key0: {key0}\n"
                     f"\t- ref: {ref}\n"
                     f"\t- hasref: {hasref}\n"
                     f"\t- refok: {refok}\n"
@@ -397,7 +411,7 @@ def _get_ref_vector_find_identical(
         _, hasvecti, _, key_vecti = get_ref_vector(
             ddata=ddata,
             dref=dref,
-            key=k0,
+            key0=k0,
             ref=ref,
             dim=dim,
             quant=quant,
@@ -437,6 +451,7 @@ def get_ref_vector_common(
     # inputs
     keys=None,
     # for selecting ref vector
+    key=None,
     ref=None,
     dim=None,
     quant=None,
@@ -499,7 +514,9 @@ def get_ref_vector_common(
         hasrefi, hasvecti, refi, key_vecti, vali, dindi = get_ref_vector(
             ddata=ddata,
             dref=dref,
-            key=k0,
+            key0=k0,
+            # select vector
+            key=key,
             ref=ref,
             dim=dim,
             quant=quant,
@@ -732,7 +749,7 @@ def _get_ref_vector_common_values(
             hasrefi, hasvecti, refi, key_vecti, vali, dindi = get_ref_vector(
                 ddata=ddata,
                 dref=dref,
-                key=k0,
+                key0=k0,
                 ref=ref,
                 dim=dim,
                 quant=quant,
@@ -847,7 +864,7 @@ def _uniformize_check(
     param = _generic_check._check_var(
         param, 'param',
         types=str,
-        allowed=['dim', 'quant', 'name', 'units'],
+        allowed=['key', 'dim', 'quant', 'name', 'units'],
         default='dim',
     )
 
@@ -855,10 +872,11 @@ def _uniformize_check(
     # list availabe values for param and associated refs
     dparref = {
         k0: [
-            v1[param] for k1, v1 in coll.ddata.items()
+            (k1 if param == 'key' else v1[param])
+            for k1, v1 in coll.ddata.items()
             if v1['monot'] == (True,)
             and v1['ref'][0] == k0
-            and (lparam is None or v1[param] in lparam)
+            and (lparam is None or (param != 'key' and v1[param] in lparam))
         ]
         for k0 in refs
     }
@@ -898,7 +916,7 @@ def _uniformize_check(
     for k0, v0 in dparam.items():
         lout = [
             k1 for k1 in v0['keys']
-            if coll.get_ref_vector(key=k1, **{param: k0})[3] is None
+            if coll.get_ref_vector(key0=k1, **{param: k0})[3] is None
         ]
         if len(lout) > 0:
             dfails[k0] = lout
@@ -1047,4 +1065,4 @@ def uniformize(
     if returnas == 'dataframe':
         pass
 
-    return stu
+    return stu

datastock/_class2.py

@@ -1374,53 +1374,9 @@ class DataStock2(DataStock1):
     # -------------------
 
     def on_close(self, event):
-        kcan = [
-            k0 for k0, v0 in self._dobj['canvas'].items()
-            if v0['handle'] == event.canvas
-        ]
-        if len(kcan) > 1:
-            raise Exception('Several matching canvas')
-        elif len(kcan) == 1:
-
-            if len(self._dobj['canvas']) == 1:
-                self.close_all()
-
-            else:
-                lax = [
-                    k1 for k1, v1 in self._dobj['axes'].items()
-                    if v1['canvas'] == kcan[0]
-                ]
-                lmob = [
-                    k1 for k1, v1 in self._dobj['mobile'].items()
-                    if v1['axes'] in lax
-                ]
-                for k1 in lax:
-                    del self._dobj['axes'][k1]
-                for k1 in lmob:
-                    del self._dobj['mobile'][k1]
-                del self._dobj['canvas'][kcan[0]]
-
-    def close_all(self):
-
-        # close figures
-        if 'axes' in self._dobj.keys():
-            lfig = set([
-                v0['handle'].figure for v0 in self._dobj['axes'].values()
-            ])
-            for ff in lfig:
-                plt.close(ff)
-
-        # delete obj dict
-        lk = ['interactivity', 'mobile', 'key', 'canvas', 'group', 'axes']
-        for kk in lk:
-            if kk in self._dobj.keys():
-                del self._dobj[kk]
-
-        # remove interactivity-specific param in dref
-        lp = list(set(self.get_lparam(which='ref')).intersection(
-            ['indices', 'group', 'inc']
-        ))
-        self.remove_param(which='ref', param=lp)
+        self.remove_all(excluded=['canvas']) # to avoid crash
+        print("\n---- CLOSING interactive figure ----")
+        print(f"\tleft in dax: {self.get_nbytes()[0]/1000} Ko\n")
 
 
 # #############################################################################
@@ -1431,4 +1387,4 @@ class DataStock2(DataStock1):
 
 __all__ = [
     sorted([k0 for k0 in locals() if k0.startswith('DataStock')])[-1]
-]
+]

datastock/_class3.py

@@ -24,8 +24,8 @@ class DataStock3(DataStock2):
         keyZ=None,
         keyU=None,
         ind=None,
-        vmin=None,
-        vmax=None,
+        dvminmax=None,
+        dscale=None,
         cmap=None,
         aspect=None,
         nmax=None,
@@ -43,13 +43,19 @@ class DataStock3(DataStock2):
         dax=None,
         dmargin=None,
         fs=None,
+        wintit=None,
+        tit=None,
         dcolorbar=None,
         dleg=None,
         label=None,
         connect=None,
         inplace=None,
     ):
-        """ Plot the desired 2d data array as a matrix """
+        """ Plot the desired 1d, 2, 3, or 4d data array as a matrix
+
+        other axes can be plotted using monotonous (optionally uniform) arrays
+
+        """
         return _plot_as_array.plot_as_array(
             # parameters
             coll=self,
@@ -59,8 +65,8 @@ class DataStock3(DataStock2):
             keyZ=keyZ,
             keyU=keyU,
             ind=ind,
-            vmin=vmin,
-            vmax=vmax,
+            dvminmax=dvminmax,
+            dscale=dscale,
             cmap=cmap,
             aspect=aspect,
             nmax=nmax,
@@ -78,6 +84,8 @@ class DataStock3(DataStock2):
             dax=dax,
             dmargin=dmargin,
             fs=fs,
+            wintit=wintit,
+            tit=tit,
             dcolorbar=dcolorbar,
             dleg=dleg,
             label=label,
@@ -416,4 +424,4 @@ class DataStock3(DataStock2):
 
 __all__ = [
     sorted([k0 for k0 in locals() if k0.startswith('DataStock')])[-1]
-]
+]