ntv-numpy.ntv_numpy

121class XndarrayConnec(NtvConnector):
122    """NTV connector for Xndarray."""
123
124    clas_obj = "Xndarray"
125    clas_typ = "xndarray"
126
127    @staticmethod
128    def to_obj_ntv(ntv_value, **kwargs):
129        """convert json ntv_value into a Xndarray.
130
131        *Parameters*
132
133        - **convert** : boolean (default True) - If True, convert json data with
134        non-umpy ntv_type into Xndarray with python type
135        """
136        print(ntv_value)
137        return Xndarray.read_json(ntv_value, **kwargs)
138
139    @staticmethod
140    def to_json_ntv(value, name=None, typ=None, **kwargs):
141        """convert a Xndarray (value) into NTV json (json-value, name, ntv_type).
142
143        *Parameters*
144
145        - **typ** : string (default None) - not used,
146        - **name** : string (default None) - not used
147        - **value** : Xndarray values
148        - **encoded** : Boolean (default False) - json-value if False else json-text
149        - **header** : Boolean (default True) - including xndarray type
150        - **notype** : Boolean (default False) - including data type if False
151        - **novalue** : Boolean (default False) - including value if False
152        - **noshape** : Boolean (default True) - if True, without shape if dim < 1
153        - **format** : string (default 'full') - representation format of the ndarray,
154        - **extension** : string (default None) - type extension
155        """
156        option = {
157            "notype": False,
158            "extension": None,
159            "format": "full",
160            "noshape": True,
161            "header": True,
162            "encoded": False,
163            "novalue": False,
164            "noname": False,
165        } | kwargs
166        if option["format"] not in ["full", "complete"]:
167            option["noshape"] = False
168        return (value.to_json(**option), name, "xndarray")

 76class NdarrayConnec(NtvConnector):
 77    """NTV connector for Ndarray."""
 78
 79    clas_obj = "Ndarray"
 80    clas_typ = "ndarray"
 81
 82    @staticmethod
 83    def to_obj_ntv(ntv_value, **kwargs):
 84        """convert json ntv_value into a Ndarray.
 85
 86        *Parameters*
 87
 88        - **convert** : boolean (default True) - If True, convert json data with
 89        non-Numpy ntv_type into data with python type"""
 90        return Ndarray.read_json(ntv_value, **kwargs)
 91
 92    @staticmethod
 93    def to_json_ntv(value, name=None, typ=None, **kwargs):
 94        """convert a Ndarray (value, name, type) into NTV json (json-value, name, ntv_type).
 95
 96        *Parameters*
 97
 98        - **typ** : string (default None) - ntv_type of the ndarray object,
 99        - **name** : string (default None) - name of the ndarray object
100        - **value** : Ndarray value (or np.ndarray value)
101        - **noshape** : Boolean (default True) - if True, without shape if dim < 1
102        - **notype** : Boolean (default False) - including data type if False
103        - **novalue** : Boolean (default False) - including value if False
104        - **format** : string (default 'full') - representation format of the ndarray,
105        - **encoded** : Boolean (default False) - json-value if False else json-text
106        - **header** : Boolean (default True) - including ndarray type
107        """
108        option = {
109            "format": "full",
110            "header": True,
111            "encoded": False,
112            "notype": False,
113            "noshape": True,
114            "novalue": False,
115        } | kwargs
116        if option["format"] not in ["full", "complete"]:
117            option["noshape"] = False
118        return (Ndarray(value).to_json(**option), name, "ndarray")

143class Dfull(Darray):
144    """Representation of a one dimensional Array with full representation
145
146    *dynamic values (@property)*
147    - `values`
148
149    *methods*
150    - `read_json` (staticmethod)
151    - `to_json`
152    """
153
154    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
155        """Dfull constructor.
156
157        *Parameters*
158
159        - **data**: list, Darray or np.ndarray - data to represent (after coding)
160        - **ref** : unused
161        - **coding**: unused
162        - **dtype**: string (default None) - numpy.dtype to apply
163        """
164        super().__init__(data, dtype=dtype, unidim=unidim)
165
166    def to_json(self):
167        """return a JsonValue of the Dfull entity."""
168        return Dutil.list_json(self.data)
169
170    @property
171    def values(self):
172        """return the list of values"""
173        return self.data
174
175    @property
176    def _len_val(self):
177        """return the length of the Dfull entity"""
178        return len(self.data) if self.data.ndim > 0 else 0

181class Dcomplete(Darray):
182    """Representation of a one dimensional Array with full representation
183
184    *dynamic values (@property)*
185    - `values`
186
187    *methods*
188    - `read_json` (staticmethod)
189    - `to_json`
190    """
191
192    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
193        """Dcomplete constructor.
194
195        *Parameters*
196
197        - **data**: list, Darray or np.ndarray - data to represent (after coding)
198        - **ref** : unused
199        - **coding**: List of integer (default None) - mapping between data and the list of values
200        - **dtype**: string (default None) - numpy.dtype to apply
201        """
202        if coding is None:
203            try:
204                data, coding = np.unique(data, return_inverse=True)
205            except (TypeError, ValueError):
206                dat, idx, coding = np.unique(
207                    np.frompyfunc(Ntv.from_obj, 1, 1)(data),
208                    return_index=True,
209                    return_inverse=True,
210                )
211                data = data[idx]
212        super().__init__(data, coding=coding, dtype=dtype, unidim=unidim)
213
214    def to_json(self):
215        """return a JsonValue of the Dcomplete entity."""
216        return [Dutil.list_json(self.data), self.coding.tolist()]
217
218    @property
219    def values(self):
220        """return the list of values"""
221        return self.data[self.coding]
222
223    @property
224    def _len_val(self):
225        """return the length of the Dcomplete entity"""
226        return len(self.coding) if self.coding.ndim > 0 else 0

 24class Darray(ABC):
 25    """The Darray class is an abstract class used by `Dfull`and `Dcomplete` classes.
 26
 27    *Attributes :*
 28    - **data** :  np.ndarray - data after coding
 29    - **ref**:  int or string - reference to another Darray data
 30    - **coding**: np.ndarray of int - mapping between data and the values
 31
 32    *dynamic values (@property)*
 33    - `values`
 34
 35    *methods*
 36    - `read_json` (staticmethod)
 37    - `to_json`
 38    """
 39
 40    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
 41        """Darray constructor.
 42
 43        *Parameters*
 44
 45        - **data**: list, Darray or np.ndarray - data to represent (after coding)
 46        - **ref** : String or integer (default None) - name or index of another Darray
 47        - **coding**: List of integer (default None) - mapping between data and the list of values
 48        - **dtype**: string (default None) - numpy.dtype to apply
 49        """
 50        if isinstance(data, Darray):
 51            self.data = data.data
 52            self.ref = data.ref
 53            self.coding = data.coding
 54            return
 55        data = data if isinstance(data, (list, np.ndarray)) else [data]
 56        if (len(data) > 0 and isinstance(data[0], (list, np.ndarray))) or unidim:
 57            dtype = data.dtype if isinstance(data, np.ndarray) else "object"
 58            self.data = np.fromiter(data, dtype=dtype)
 59        else:
 60            self.data = np.array(data, dtype=dtype).reshape(-1)
 61        self.ref = ref
 62        self.coding = np.array(coding)
 63
 64    def __repr__(self):
 65        """return classname and number of value"""
 66        return self.__class__.__name__ + "[" + str(len(self)) + "]"
 67
 68    def __str__(self):
 69        """return json string format"""
 70        return json.dumps(self.to_json())
 71
 72    def __eq__(self, other):
 73        """equal if values are equal"""
 74        return np.array_equal(self.values, other.values, equal_nan=False)
 75
 76    def __len__(self):
 77        """len of values"""
 78        return self._len_val
 79
 80    def __contains__(self, item):
 81        """item of values"""
 82        return item in self.values
 83
 84    def __getitem__(self, ind):
 85        """return value item"""
 86        if isinstance(ind, tuple):
 87            return [self.values[i] for i in ind]
 88            # return [copy(self.values[i]) for i in ind]
 89        return self.values[ind]
 90        # return copy(self.values[ind])
 91
 92    def __copy__(self):
 93        """Copy all the data"""
 94        return self.__class__(self)
 95
 96    @staticmethod
 97    def read_json(val, dtype=None, unidim=False):
 98        """return a Darray entity from a list of data.
 99
100        *Parameters*
101
102        - **val**: list of data
103        - **dtype** : string (default None) - numpy.dtype to apply
104        """
105        val = val if isinstance(val, list) else [val]
106        if not val or not isinstance(val[0], list):
107            return Dfull(val, dtype=dtype, unidim=unidim)
108        match val:
109            case [data, ref, list(coding)] if (
110                isinstance(ref, (int, str))
111                and isinstance(coding[0], int)
112                and max(coding) < len(data)
113            ):
114                return None
115            case [data, ref] if (
116                isinstance(data, list) and isinstance(ref, (int, str))
117            ):
118                return None
119            case [data, list(coef)] if len(coef) == 1:
120                return None
121            case [data, list(coding)] if (
122                isinstance(coding[0], int) and max(coding) < len(data)
123            ):
124                return Dcomplete(data, None, coding, dtype=dtype, unidim=unidim)
125            case _:
126                return Dfull(val, dtype=dtype, unidim=unidim)
127
128    @abstractmethod
129    def to_json(self):
130        """return a JsonValue"""
131
132    @property
133    @abstractmethod
134    def values(self):
135        """return the list of values"""
136
137    @property
138    @abstractmethod
139    def _len_val(self):
140        """return the length of the entity"""

229class Dutil:
230    """np.ndarray utilities.
231
232    *static methods*
233    - `convert`
234    - `is_json`
235    - `ntv_val`
236    - `add_ext`
237    - `split_type`
238    - `ntv_type`
239    - `nda_ntv_type`
240    - `dtype`
241    - `json_ntv`
242    - `split_name`
243    - `split_json_name`
244    """
245
246    @staticmethod
247    def equals(nself, nother):
248        """return True if all elements are equals and dtype are equal"""
249        if not (isinstance(nself, np.ndarray) and isinstance(nother, np.ndarray)):
250            return False
251        if nself.dtype != nother.dtype or nself.shape != nother.shape:
252            return False
253        if len(nself.shape) == 0:
254            return True
255        if len(nself) != len(nother):
256            return False
257        if len(nself) == 0:
258            return True
259        if isinstance(nself[0], (np.ndarray, pd.Series, pd.DataFrame)):
260            SeriesConnec = NtvConnector.connector().get("SeriesConnec")
261            DataFrameConnec = NtvConnector.connector().get("DataFrameConnec")
262            equal = {
263                np.ndarray: Dutil.equals,
264                pd.Series: SeriesConnec.equals,
265                pd.DataFrame: DataFrameConnec.equals,
266            }
267            for nps, npo in zip(nself, nother):
268                if not equal[type(nself[0])](nps, npo):
269                    return False
270            return True
271        return np.array_equal(nself, nother)
272
273    @staticmethod
274    def list_json(nda):
275        """return a JSON representation of a unidimensional np.ndarray"""
276        if len(nda) == 0:
277            return []
278        if isinstance(nda[0], np.ndarray):
279            return [Dutil.list_json(arr) for arr in nda]
280        return nda.tolist()

 29class Ndarray:
 30    """The Ndarray class is the JSON interface of numpy.ndarrays.
 31
 32    *static methods*
 33    - `read_json`
 34    - `to_json`
 35    - `set_shape`
 36    """
 37
 38    def __init__(self, dar, ntv_type=None, shape=None, str_uri=True):
 39        """Ndarray constructor.
 40
 41        *Parameters*
 42
 43        - **dar**: Darray or np.ndarray - data to represent
 44        - **shape** : list of integer (default None) - length of dimensions
 45        - **ntv_type**: string (default None) - NTVtype to apply
 46        - **str_uri**: boolean(default True) - if True and dar is a string,
 47        dar is an uri else a np.array
 48        """
 49        dar = [None] if isinstance(dar, list) and len(dar) == 0 else dar
 50        if isinstance(dar, Ndarray):
 51            self.uri = dar.uri
 52            self.is_json = dar.is_json
 53            self.ntvtype = dar.ntvtype
 54            self.shape = dar.shape
 55            self.darray = dar.darray
 56            return
 57        if isinstance(dar, str) and str_uri:
 58            self.uri = dar
 59            self.is_json = True
 60            self.ntvtype = Ndtype(ntv_type) if ntv_type else None
 61            self.shape = shape
 62            self.darray = None
 63            return
 64        if shape:
 65            dar = Dfull(dar, dtype=Nutil.dtype(ntv_type), unidim=True).data
 66        else:
 67            dar = np.array(dar, dtype=Nutil.dtype(ntv_type))
 68            shape = list(dar.shape)
 69        dar = np.array(dar).reshape(-1)
 70        ntv_type = Nutil.nda_ntv_type(dar, ntv_type)
 71        self.uri = None
 72        self.is_json = Nutil.is_json(dar[0])
 73        self.ntvtype = Ndtype(ntv_type)
 74        self.shape = shape
 75        self.darray = dar.astype(Nutil.dtype(str(self.ntvtype)))
 76
 77    def __repr__(self):
 78        """return classname, the shape and the ntv_type"""
 79        uri = self.uri if self.uri else ""
 80        typ = self.ntv_type if self.ntv_type else ""
 81        sha = str(self.shape) if self.shape else ""
 82        u_t = ", " if uri and typ + sha else ""
 83        t_s = ", " if typ and sha else ""
 84        return self.__class__.__name__ + "(" + uri + u_t + typ + t_s + sha + ")"
 85
 86    def __str__(self):
 87        """return json string format"""
 88        return json.dumps(self.to_json())
 89
 90    def __eq__(self, other):
 91        """equal if attributes are equal"""
 92        if self.ntv_type != other.ntv_type:
 93            return False
 94        if self.uri != other.uri:
 95            return False
 96        if self.shape != other.shape:
 97            return False
 98        if self.darray is None and other.darray is None:
 99            return True
100        if self.darray is None or other.darray is None:
101            return False
102        return Dutil.equals(self.darray, other.darray)
103
104    def __len__(self):
105        """len of ndarray"""
106        return len(self.darray) if self.darray is not None else 0
107
108    def __contains__(self, item):
109        """item of darray values"""
110        return item in self.darray if self.darray is not None else None
111
112    def __getitem__(self, ind):
113        """return darray value item"""
114        if self.darray is None:
115            return None
116        if isinstance(ind, tuple):
117            return [self.darray[i] for i in ind]
118        return self.darray[ind]
119
120    def __copy__(self):
121        """Copy all the data"""
122        return self.__class__(self)
123
124    def __array__(self):
125        """numpy array interface"""
126        return self.ndarray
127
128    @property
129    def ntv_type(self):
130        """string representation of ntvtype"""
131        return str(self.ntvtype) if self.ntvtype else None
132
133    @property
134    def ndarray(self):
135        """representation with a np.ndarray not flattened"""
136        return self.darray.reshape(self.shape) if self.darray is not None else None
137
138    def set_shape(self, shape):
139        """update the shape"""
140        if Ndarray.len_shape(shape) != len(self.darray):
141            raise NdarrayError("shape is not consistent with the ndarray length")
142        self.shape = list(shape)
143
144    def update(self, nda, nda_uri=True):
145        """update uri and darray and return the result (True, False)
146
147        *Parameters*
148
149        - **nda** : string, list, np.ndarray, Ndarray - data to include
150        - **nda_uri** : boolean (default True) - if True, existing shape and
151        ntv_type are not updated (but are created if not existing)"""
152        if (
153            not nda_uri
154            and not (self.shape is None or nda.shape is None)
155            and self.shape != nda.shape
156        ):
157            return False
158        if (
159            not nda_uri
160            and not (self.ntv_type is None or nda.ntv_type is None)
161            and self.ntv_type != nda.ntv_type
162        ):
163            return False
164        if nda_uri:
165            len_s = self.len_shape(self.shape)
166            if len_s and len(nda) and len_s != len(nda):
167                return False
168            self.ntvtype = nda.ntvtype if self.ntv_type is None else self.ntvtype
169            self.shape = nda.shape if self.shape is None else self.shape
170        else:
171            self.ntvtype = nda.ntvtype if nda.ntv_type is not None else self.ntvtype
172            self.shape = nda.shape if nda.shape is not None else self.shape
173        self.uri, self.darray = (nda.uri, None) if nda.uri else (None, nda.darray)
174        return True
175
176    def set_array(self, darray):
177        """set a new darray and remove uri, return the result (True, False)
178
179        *Parameters*
180
181        - **darray** : list, np.ndarray, Ndarray - data to include"""
182        ndarray = Ndarray(darray)
183        darray = ndarray.darray
184        ntv_type = ndarray.ntv_type
185        shape = ndarray.shape
186        new_shape = shape if self.shape is None else self.shape
187        new_ntv_type = ntv_type if self.ntv_type is None else self.ntv_type
188        if (
189            len(darray) != Ndarray.len_shape(new_shape)
190            or new_ntv_type != ntv_type
191            or new_shape != shape
192        ):
193            return False
194        self.uri = None
195        self.darray = darray
196        self.ntvtype = Ndtype(new_ntv_type)
197        self.shape = new_shape
198        return True
199
200    def set_uri(self, uri, no_ntv_type=False, no_shape=False):
201        """set a new uri and remove ndarray and optionaly ntv_type and shape.
202        Return the result (True, False)
203
204        *Parameters*
205
206        - **uri** : string - URI of the Ndarray
207        - **no_ntv_type** : boolean (default False) - If True, ntv_type is None
208        - **no_shape** : boolean (default False) - If True, shape is None
209        """
210        if not isinstance(uri, str) or not uri:
211            return False
212        self.uri = uri
213        self.darray = None
214        self.ntvtype = None if no_ntv_type else self.ntvtype
215        self.shape = None if no_shape else self.shape
216        return True
217
218    def to_ndarray(self):
219        """representation with a np.ndarray not flattened"""
220        return self.ndarray
221
222    @property
223    def mode(self):
224        """representation mode of the darray/uri data (relative, absolute,
225        undefined, inconsistent)"""
226        match [self.darray, self.uri]:
227            case [None, str()]:
228                return "relative"
229            case [None, None]:
230                return "undefined"
231            case [_, None]:
232                return "absolute"
233            case _:
234                return "inconsistent"
235
236    @staticmethod
237    def read_json(jsn, **kwargs):
238        """convert json ntv_value into a ndarray.
239
240        *Parameters*
241
242        - **convert** : boolean (default True) - If True, convert json data with
243        non Numpy ntv_type into data with python type
244        """
245        option = {"convert": True} | kwargs
246        jso = json.loads(jsn) if isinstance(jsn, str) else jsn
247        (ntv_value,) = Ntv.decode_json(jso)[:1]
248
249        ntv_type = None
250        shape = None
251        match ntv_value[:-1]:
252            case []:
253                ...
254            case [ntv_type, shape]:
255                ...
256            case [str(ntv_type)]:
257                ...
258            case [list(shape)]:
259                ...
260        unidim = shape is not None
261        if isinstance(ntv_value[-1], str):
262            return Ndarray(ntv_value[-1], shape=shape, ntv_type=ntv_type)
263        darray = Darray.read_json(
264            ntv_value[-1], dtype=Nutil.dtype(ntv_type), unidim=unidim
265        )
266        darray.data = Nutil.convert(
267            ntv_type, darray.data, tojson=False, convert=option["convert"]
268        )
269        return Ndarray(darray.values, shape=shape, ntv_type=ntv_type)
270
271    def to_json(self, **kwargs):
272        """convert a Ndarray into json-value
273
274        *Parameters*
275
276        - **noshape** : Boolean (default True) - if True, without shape if dim < 1
277        - **notype** : Boolean (default False) - including data type if False
278        - **novalue** : Boolean (default False) - including value if False
279        - **format** : string (default 'full') - representation format of the ndarray,
280        - **encoded** : Boolean (default False) - json-value if False else json-text
281        - **header** : Boolean (default True) - including ndarray type
282        """
283        option = {
284            "format": "full",
285            "header": True,
286            "encoded": False,
287            "notype": False,
288            "noshape": True,
289            "novalue": False,
290        } | kwargs
291        if self.mode in ["undefined", "inconsistent"]:
292            return None
293        if self.mode == "absolute" and len(self.darray) == 0:
294            return [[]]
295
296        shape = (
297            None
298            if not self.shape or (len(self.shape) < 2 and option["noshape"])
299            else self.shape
300        )
301
302        if self.mode == "relative":
303            js_val = self.uri
304        else:
305            js_val = (
306                Nutil.ntv_val(
307                    self.ntv_type, self.darray, option["format"], self.is_json
308                )
309                if not option["novalue"]
310                else ["-"]
311            )
312
313        lis = [self.ntv_type if not option["notype"] else None, shape, js_val]
314        return Nutil.json_ntv(
315            None,
316            "ndarray",
317            [val for val in lis if val is not None],
318            header=option["header"],
319            encoded=option["encoded"],
320        )
321
322    @property
323    def info(self):
324        """infos of the Ndarray"""
325        inf = {"shape": self.shape}
326        inf["length"] = len(self)
327        inf["ntvtype"] = self.ntv_type
328        inf["shape"] = self.shape
329        inf["uri"] = self.uri
330        return {key: val for key, val in inf.items() if val}
331
332    @staticmethod
333    def len_shape(shape):
334        """return a length from a shape (product of dimensions)"""
335        if not shape:
336            return 0
337        prod = 1
338        for dim in shape:
339            prod *= dim
340        return prod