datastock 0.0.43__tar.gz → 0.0.45__tar.gz

{datastock-0.0.43/datastock.egg-info → datastock-0.0.45}/PKG-INFO

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

{datastock-0.0.43 → datastock-0.0.45}/datastock/_class0.py

@@ -65,7 +65,7 @@ class DataStock0(object):
         )
 
     @classmethod
-    def from_dict(cls, din=None, isflat=None, sep=None):
+    def from_dict(cls, din=None, isflat=None, sep=None, obj=None):
         """ Populate the instances attributes using an input dict
 
         The input dict must be properly formatted
@@ -85,7 +85,9 @@ class DataStock0(object):
         # ---------------------
         # Instanciate and populate
 
-        obj = cls()
+        if obj is None:
+            obj = cls()
+
         for k0 in din.keys():
             if k0 == '_ddef':
                 if 'dobj' not in din[k0]['params'].keys():

{datastock-0.0.43 → datastock-0.0.45}/datastock/_class1.py

@@ -369,8 +369,8 @@ class DataStock1(DataStock0):
     ###########
 
     @classmethod
-    def from_dict(cls, din=None, sep=None):
-        obj = super().from_dict(din=din, sep=sep)
+    def from_dict(cls, din=None, sep=None, obj=None):
+        obj = super().from_dict(din=din, sep=sep, obj=obj)
         obj.update()
         return obj
 

{datastock-0.0.43 → datastock-0.0.45}/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-0.0.43 → datastock-0.0.45}/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,17 @@ 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
+    nNone = 1 + len(domain)
+
+    # 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 + {len(domain)}:\n"
             + "\n".join(lstr)
         )
         raise Exception(msg)

{datastock-0.0.43 → datastock-0.0.45}/datastock/_saveload.py

@@ -199,6 +199,7 @@ def save(
 def load(
     pfe=None,
     cls=None,
+    coll=None,
     allow_pickle=None,
     sep=None,
     verb=None,
@@ -206,16 +207,24 @@ def load(
 
     # -------------
     # check inputs
+    # -------------
 
+    # ---------
     # pfe
+
     if not os.path.isfile(pfe):
         msg = f"Arg pfe must be a valid path to a file!\n\t- Provided: {pfe}"
         raise Exception(msg)
 
-    # cls
-    if cls is None:
-        from ._class import DataStock
-        cls = DataStock
+    # --------------
+    # cls vs coll
+
+    if coll is None:
+        if cls is None:
+            from ._class import DataStock
+            cls = DataStock
+    else:
+        cls = coll.__class__
 
     if not (type(cls) is type and hasattr(cls, 'from_dict')):
         msg = (
@@ -224,14 +233,18 @@ def load(
         )
         raise Exception(msg)
 
+    # ------------
     # allow_pickle
+
     allow_pickle = _generic_check._check_var(
         allow_pickle, 'allow_pickle',
         default=True,
         types=bool,
     )
 
+    # -------
     # verb
+
     verb = _generic_check._check_var(
         verb, 'verb',
         default=True,
@@ -240,11 +253,13 @@ def load(
 
     # --------------
     # load flat dict
+    # --------------
 
     dflat = dict(np.load(pfe, allow_pickle=allow_pickle))
 
     # ------------------------------
     # load sep from file if exists
+    # ------------------------------
 
     if _KEY_SEP in dflat.keys():
         # new
@@ -256,6 +271,7 @@ def load(
 
     # ----------
     # reshape
+    # ----------
 
     dout = {}
     for k0, v0 in dflat.items():
@@ -310,14 +326,19 @@ def load(
 
     # -----------
     # Instanciate
+    # -----------
 
-    obj = cls.from_dict(dout)
+    coll = cls.from_dict(dout, obj=coll)
+
+    # -----------
+    # verb
+    # -----------
 
     if verb:
         msg = f"Loaded from\n\t{pfe}"
         print(msg)
 
-    return obj
+    return coll
 
 
 # #################################################################

{datastock-0.0.43 → datastock-0.0.45}/datastock/tests/test_01_DataStock.py

@@ -612,6 +612,16 @@ class Test02_Manipulate():
         st2 = load(pfe, verb=verb)
         # Just to check the loaded version works fine
         msg = st2.__eq__(self.st, returnas=str)
+        if msg is not True:
+            raise Exception(msg)
+        os.remove(pfe)
+
+    def test25_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)
+        # Just to check the loaded version works fine
+        msg = st2.__eq__(self.st, returnas=str)
         if msg is not True:
             raise Exception(msg)
         os.remove(pfe)

{datastock-0.0.43 → datastock-0.0.45}/datastock/version.py

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

{datastock-0.0.43 → datastock-0.0.45/datastock.egg-info}/PKG-INFO

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