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

datastock/_class1_compute.py

@@ -1,9 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Builtin
-import itertools as itt
 import copy
-import warnings
 
 
 # Common
@@ -13,7 +11,6 @@ import numpy as np
 # import scipy.linalg as scplin
 import scipy.stats as scpstats
 import scipy.spatial as scpspace
-import datastock as ds
 
 
 from . import _generic_check
@@ -31,9 +28,19 @@ _LCROSS_OK = ['spearman', 'pearson', 'distance']
 def _get_slice(laxis=None, ndim=None):
 
     nax = len(laxis)
-    assert nax in range(1, ndim + 1)
+    if not (nax >= 0 and nax <= ndim):
+        msg = (
+            "Something wrong with the number of axis provided:\n"
+            f"\t- laxis: {laxis}\n"
+            f"\t- ndim:  {ndim}\n"
+        )
+        raise Exception(msg)
 
-    if ndim == nax:
+    if nax == 0:
+        def fslice(*args):
+            return tuple([slice(None) for ii in laxis])
+
+    elif ndim == nax:
         def fslice(*args):
             return args
 
@@ -206,7 +213,7 @@ def propagate_indices_per_ref(
             ]
             msg = (
                 "Provided ldata are not suitable:\n"
-                 + "\n".join(lstr)
+                + "\n".join(lstr)
             )
             raise Exception(msg)
 
@@ -233,7 +240,6 @@ def propagate_indices_per_ref(
                 raise Exception(msg)
             ref_data = ref_data[0]
 
-
             # For each ref in lref, get list of matching data
             drdata = {
                 rr: [
@@ -705,16 +711,54 @@ def correlations(
 
 def _extract_instance(
     coll=None,
-    lref=None,
-    ldata=None,
+    keys=None,
+    # optional include
+    inc_monot=None,
+    inc_vectors=None,
+    inc_allrefs=None,
+    # output
     coll2=None,
+    inplace=None,
+    return_keys=None,
 ):
 
+    # --------------------
+    # check inputs
+    # --------------------
+
+    (
+        keys,
+        inc_monot, inc_vectors, inc_allrefs,
+        inplace, return_keys,
+    ) = _extract_check(**locals())
+
+    # -----------------
+    # select
+    # -----------------
+
+    ldata, lref = _extract_select(
+        coll=coll,
+        keys=keys,
+        # optional includes
+        inc_monot=inc_monot,
+        inc_vectors=inc_vectors,
+        inc_allrefs=inc_allrefs,
+    )
+
     # -------------------
     # Instanciate
+    # -------------------
 
     if coll2 is None:
-        coll2 = coll.__class__()
+        if inplace is True:
+            coll2 = coll
+        else:
+            coll2 = coll.__class__()
+
+
+    # ------------------------
+    # Populate
+    # ------------------------
 
     # -------------------
     # Populate with ref
@@ -744,57 +788,173 @@ def _extract_instance(
                 **copy.deepcopy({pp: coll._ddata[k0][pp] for pp in lpar}),
             )
 
-    return coll2
-
+    # -------------
+    # return
+    # -------------
 
-def _extract_dataref(coll=None, keys=None, vectors=None):
+    if return_keys is True:
+        return coll2, keys
+    else:
+        return coll2
 
-    # ----------------
-    # check inputs
 
-    # vectors
-    vectors = ds._generic_check._check_var(
-        vectors, 'vectors',
-        types=bool,
-        default=True,
-    )
+def _extract_check(
+    coll=None,
+    keys=None,
+    # optional include
+    inc_monot=None,
+    inc_vectors=None,
+    inc_allrefs=None,
+    vectors=None,
+    # output
+    coll2=None,
+    inplace=None,
+    return_keys=None,
+):
 
+    # --------------
     # keys
-    if keys is None:
-        return
+    # --------------
+
     if isinstance(keys, str):
         keys = [keys]
 
     lokd = list(coll._ddata.keys())
     lokr = list(coll._dref.keys())
-    keys = _generic_check._check_var_iter(
+    keys = list(set(_generic_check._check_var_iter(
         keys, 'keys',
+        default=None,
         types=list,
-        allowed=lokr + lokd,
+        types_iter=str,
+        allowed=lokd+lokr,
+    )))
+
+    # -----------------
+    # optional includes
+    # -----------------
+
+    # monotonous vectors
+    inc_monot = _generic_check._check_var(
+        inc_monot, 'inc_monot',
+        types=bool,
+        default=True,
+    )
+
+    # any vectors
+    inc_vectors = _generic_check._check_var(
+        inc_vectors, 'inc_vectors',
+        types=bool,
+        default=False,
     )
 
-    # -----------------------------
-    # Get corresponding list of ref
+    # any nd array
+    inc_allrefs = _generic_check._check_var(
+        inc_allrefs, 'inc_allrefs',
+        types=bool,
+        default=False,
+    )
 
-    lref = set(
-        [k0 for k0 in keys if k0 in lokr]
-        + [
-            k0 for k0, v0 in coll._dref.items()
-            if any([ss in keys for ss in v0['ldata']])
-        ]
+    # -----------------
+    # output
+    # -----------------
+
+    # return_keys
+    return_keys = _generic_check._check_var(
+        return_keys, 'return_keys',
+        types=bool,
+        default=False,
+    )
+
+    # inplace
+    inplace = _generic_check._check_var(
+        inplace, 'inplace',
+        types=bool,
+        default=False,
     )
 
-    # add vectors
-    if vectors is True:
-        keys = set(
-            [k0 for k0 in keys if k0 in lokd]
-            + list(itt.chain.from_iterable([
-                coll.dref[k0]['ldata_monot']
-                for k0 in lref
-            ]))
+    # coll2
+    if coll2 is not None:
+        c0 = (
+            issubclass(coll2.__class__, coll.__class__)
+            or issubclass(coll.__class__, coll2.__class__)
         )
+        if not c0:
+            msg = "Arg coll2 must be a DataStock subclass instance"
+            raise Exception(msg)
+
+    return (
+        keys,
+        inc_monot, inc_vectors, inc_allrefs,
+        inplace, return_keys,
+    )
+
+
+def _extract_select(
+    coll=None,
+    keys=None,
+    # optional include
+    inc_monot=None,
+    inc_vectors=None,
+    inc_allrefs=None,
+):
+
+    # ----------------------
+    # get all relevant refs
+
+    ldata0 = [k0 for k0 in keys if k0 in coll.ddata.keys()]
+    lref = list(set(
+        [k0 for k0 in keys if k0 in coll.dref.keys()]
+        + [
+            rr for rr in coll.dref.keys()
+            if any([rr in coll.ddata[k0]['ref'] for k0 in ldata0])
+        ]
+    ))
+
+    # ------------------------
+    # loop on refs for vectors
+
+    any_inc = any([inc_monot, inc_vectors, inc_allrefs])
+    if any_inc:
+        ldata = []
+
+    if inc_monot is True or inc_vectors is True:
+
+        for rr in lref:
+            for k0, v0 in coll.ddata.items():
+
+                c0 = (
+                    v0['ref'] == (rr,)
+                    and (
+                        inc_vectors is True
+                        or (
+                            inc_monot is True
+                            and v0['monot'] == (True,)
+                        )
+                    )
+                )
+
+                if c0:
+                    ldata.append(k0)
+
+    # ------------------------
+    # loop on data0 for ndarrays
+
+    if inc_allrefs is True:
+
+        for dd in ldata0:
+            ref = coll.ddata[dd]['ref']
+
+            for k0, v0 in coll.ddata.items():
+                if v0['ref'] == ref:
+                    ldata.append(k0)
+
+    # ----------------------
+    # return
+
+    if any_inc:
+        ldata0 = list(set(ldata0 + ldata))
 
-    return lref, keys
+    return ldata0, lref
 
 
 #############################################
@@ -1073,4 +1233,4 @@ def _extract_dataref(coll=None, keys=None, vectors=None):
             # lkey=[idq2dR],
             # return_all=True,
         # )
-    # return out
+    # return out

datastock/_class1_domain.py

@@ -88,7 +88,7 @@ def _check(
     for k0, v0 in domain.items():
 
         # check ref vector
-        kwd = {'ref': k0} if k0 in lref else {'key': k0}
+        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!"
@@ -244,4 +244,4 @@ def _set_ind_from_domain(
 
     ind = ind_in & (~ind_out)
 
-    return ind
+    return ind

datastock/_class1_interpolate.py

@@ -241,7 +241,7 @@ def _check_keys(
             if rr in lref:
                 kwd = {'ref': rr}
             else:
-                kwd = {'key': rr}
+                kwd = {'key0': rr}
             hasref, hasvect, ref, ref_key[ii] = coll.get_ref_vector(
                 **kwd,
             )[:4]
@@ -1550,7 +1550,7 @@ def _xunique(dout=None):
 
     # ----------
     # safety check
-    
+
     dind = {
         k0: [jj for jj, rr in enumerate(v0['ref']) if rr is None]
         for k0, v0 in dout.items()
@@ -1566,10 +1566,10 @@ def _xunique(dout=None):
             + "\n".join(lstr)
         )
         raise Exception(msg)
-    
+
     # --------------
     # ajusting dout
-    
+
     for k0, v0 in dout.items():
 
         i0 = dind[k0][0]
@@ -1609,12 +1609,12 @@ def _store(
 
     # -------------
     # store_keys
-    
+
     if store_keys is None:
         store_keys = [f"{k0}_interp" for k0 in dout.keys()]
     if isinstance(store_keys, str):
         store_keys = [store_keys]
-    
+
     lout = list(coll.ddata.keys())
     store_keys = _generic_check._check_var_iter(
         store_keys, 'store_keys',
@@ -1622,7 +1622,7 @@ def _store(
         types_iter=str,
         excluded=lout,
     )
-    
+
     assert len(store_keys) == len(dout)
 
     # ---------
@@ -1637,4 +1637,4 @@ def _store(
             units=v0['units'],
         )
 
-    return coll2
+    return coll2