ntv-numpy.ntv_numpy.data_array

  1# -*- coding: utf-8 -*-
  2"""
  3@author: Philippe@loco-labs.io
  4
  5The `data_array` module is part of the `ntv-numpy.ntv_numpy` package ([specification document](
  6https://loco-philippe.github.io/ES/JSON%20semantic%20format%20(JSON-NTV).htm)).
  7
  8It contains the classes `Darray` (abstract), `Dfull`, `Dcomplete` for the
  9representation of unidimensional arrays.
 10
 11For more information, see the
 12[user guide](https://loco-philippe.github.io/ntv-numpy/docs/user_guide.html)
 13 or the [github repository](https://github.com/loco-philippe/ntv-numpy).
 14"""
 15from abc import ABC, abstractmethod
 16import json
 17import numpy as np
 18import pandas as pd
 19from json_ntv import Ntv, NtvConnector
 20
 21
 22class Darray(ABC):
 23    ''' The Darray class is an abstract class used by `Dfull`and `Dcomplete` classes.
 24
 25    *Attributes :*
 26    - **data** :  np.ndarray - data after coding
 27    - **ref**:  int or string - reference to another Darray data
 28    - **coding**: np.ndarray of int - mapping between data and the values
 29
 30    *dynamic values (@property)*
 31    - `values`
 32
 33    *methods*
 34    - `read_json` (staticmethod)
 35    - `to_json`
 36    '''
 37
 38    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
 39        '''Darray constructor.
 40
 41        *Parameters*
 42
 43        - **data**: list, Darray or np.ndarray - data to represent (after coding)
 44        - **ref** : String or integer (default None) - name or index of another Darray
 45        - **coding**: List of integer (default None) - mapping between data and the list of values
 46        - **dtype**: string (default None) - numpy.dtype to apply
 47        '''
 48        if isinstance(data, Darray):
 49            self.data = data.data
 50            self.ref = data.ref
 51            self.coding = data.coding
 52            return
 53        data = data if isinstance(data, (list, np.ndarray)) else [data]
 54        if (len(data) > 0 and isinstance(data[0], (list, np.ndarray))) or unidim:
 55            dtype = data.dtype if isinstance(data, np.ndarray) else 'object'
 56            self.data = np.fromiter(data, dtype=dtype)
 57        else:
 58            self.data = np.array(data, dtype=dtype).reshape(-1)
 59        self.ref = ref
 60        self.coding = np.array(coding)
 61
 62    def __repr__(self):
 63        '''return classname and number of value'''
 64        return self.__class__.__name__ + '[' + str(len(self)) + ']'
 65
 66    def __str__(self):
 67        '''return json string format'''
 68        return json.dumps(self.to_json())
 69
 70    def __eq__(self, other):
 71        ''' equal if values are equal'''
 72        return np.array_equal(self.values, other.values, equal_nan=False)
 73
 74    def __len__(self):
 75        ''' len of values'''
 76        return self._len_val
 77
 78    def __contains__(self, item):
 79        ''' item of values'''
 80        return item in self.values
 81
 82    def __getitem__(self, ind):
 83        ''' return value item'''
 84        if isinstance(ind, tuple):
 85            return [self.values[i] for i in ind]
 86            # return [copy(self.values[i]) for i in ind]
 87        return self.values[ind]
 88        # return copy(self.values[ind])
 89
 90    def __copy__(self):
 91        ''' Copy all the data '''
 92        return self.__class__(self)
 93
 94    @staticmethod
 95    def read_json(val, dtype=None, unidim=False):
 96        ''' return a Darray entity from a list of data.
 97
 98        *Parameters*
 99
100        - **val**: list of data
101        - **dtype** : string (default None) - numpy.dtype to apply
102        '''
103        val = val if isinstance(val, list) else [val]
104        if not val or not isinstance(val[0], list):
105            return Dfull(val, dtype=dtype, unidim=unidim)
106        match val:
107            case [data, ref, list(coding)] if (isinstance(ref, (int, str)) and
108                                               isinstance(coding[0], int) and
109                                               max(coding) < len(data)):
110                return None
111            case [data, ref] if (isinstance(data, list) and
112                                 isinstance(ref, (int, str))):
113                return None
114            case [data, list(coef)] if len(coef) == 1:
115                return None
116            case [data, list(coding)] if (isinstance(coding[0], int) and
117                                          max(coding) < len(data)):
118                return Dcomplete(data, None, coding, dtype=dtype, unidim=unidim)
119            case _:
120                return Dfull(val, dtype=dtype, unidim=unidim)
121
122    @abstractmethod
123    def to_json(self):
124        ''' return a JsonValue'''
125
126    @property
127    @abstractmethod
128    def values(self):
129        ''' return the list of values'''
130
131    @property
132    @abstractmethod
133    def _len_val(self):
134        '''return the length of the entity'''
135
136
137class Dfull(Darray):
138    ''' Representation of a one dimensional Array with full representation
139
140    *dynamic values (@property)*
141    - `values`
142
143    *methods*
144    - `read_json` (staticmethod)
145    - `to_json`
146    '''
147
148    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
149        '''Dfull constructor.
150
151        *Parameters*
152
153        - **data**: list, Darray or np.ndarray - data to represent (after coding)
154        - **ref** : unused
155        - **coding**: unused
156        - **dtype**: string (default None) - numpy.dtype to apply
157        '''
158        super().__init__(data, dtype=dtype, unidim=unidim)
159
160    def to_json(self):
161        ''' return a JsonValue of the Dfull entity.'''
162        return Dutil.list_json(self.data)
163
164    @property
165    def values(self):
166        ''' return the list of values'''
167        return self.data
168
169    @property
170    def _len_val(self):
171        '''return the length of the Dfull entity'''
172        return len(self.data) if self.data.ndim > 0 else 0
173
174
175class Dcomplete(Darray):
176    ''' Representation of a one dimensional Array with full representation
177
178    *dynamic values (@property)*
179    - `values`
180
181    *methods*
182    - `read_json` (staticmethod)
183    - `to_json`
184    '''
185
186    def __init__(self, data, ref=None, coding=None, dtype=None, unidim=False):
187        '''Dcomplete constructor.
188
189        *Parameters*
190
191        - **data**: list, Darray or np.ndarray - data to represent (after coding)
192        - **ref** : unused
193        - **coding**: List of integer (default None) - mapping between data and the list of values
194        - **dtype**: string (default None) - numpy.dtype to apply
195        '''
196        if coding is None:
197            try:
198                data, coding = np.unique(data, return_inverse=True)
199            except (TypeError, ValueError):
200                dat, idx, coding = np.unique(np.frompyfunc(Ntv.from_obj, 1, 1)(data),
201                                             return_index=True, return_inverse=True)
202                data = data[idx]
203        super().__init__(data, coding=coding, dtype=dtype, unidim=unidim)
204
205    def to_json(self):
206        ''' return a JsonValue of the Dcomplete entity.'''
207        return [Dutil.list_json(self.data), self.coding.tolist()]
208
209    @property
210    def values(self):
211        ''' return the list of values'''
212        return self.data[self.coding]
213
214    @property
215    def _len_val(self):
216        '''return the length of the Dcomplete entity'''
217        return len(self.coding) if self.coding.ndim > 0 else 0
218
219
220class Dutil:
221    '''np.ndarray utilities.
222
223    *static methods*
224    - `convert`
225    - `is_json`
226    - `ntv_val`
227    - `add_ext`
228    - `split_type`
229    - `ntv_type`
230    - `nda_ntv_type`
231    - `dtype`
232    - `json_ntv`
233    - `split_name`
234    - `split_json_name`
235    '''
236
237    @staticmethod
238    def equals(nself, nother):
239        '''return True if all elements are equals and dtype are equal'''
240        if not (isinstance(nself, np.ndarray) and isinstance(nother, np.ndarray)):
241            return False
242        if nself.dtype != nother.dtype or nself.shape != nother.shape:
243            return False
244        if len(nself.shape) == 0:
245            return True
246        if len(nself) != len(nother):
247            return False
248        if len(nself) == 0:
249            return True
250        if isinstance(nself[0], (np.ndarray, pd.Series, pd.DataFrame)):
251            SeriesConnec = NtvConnector.connector().get('SeriesConnec')
252            DataFrameConnec = NtvConnector.connector().get('DataFrameConnec')
253            equal = {np.ndarray: Dutil.equals,
254                     pd.Series: SeriesConnec.equals,
255                     pd.DataFrame: DataFrameConnec.equals}
256            for nps, npo in zip(nself, nother):
257                if not equal[type(nself[0])](nps, npo):
258                    return False
259            return True
260        return np.array_equal(nself, nother)
261
262    @staticmethod
263    def list_json(nda):
264        '''return a JSON representation of a unidimensional np.ndarray'''
265        if len(nda) == 0:
266            return []
267        if isinstance(nda[0], np.ndarray):
268            return [Dutil.list_json(arr) for arr in nda]
269        return nda.tolist()