NTV.json_ntv.ntv

   1# -*- coding: utf-8 -*-
   2"""
   3@author: Philippe@loco-labs.io
   4
   5The `ntv` module is part of the `NTV.json_ntv` package ([specification document](
   6https://loco-philippe.github.io/ES/JSON%20semantic%20format%20(JSON-NTV).htm)).
   7
   8It contains the classes `NtvSingle`, `NtvList`, `Ntv`(abstract) for NTV entities.
   9
  10For more information, see the
  11[user guide](https://loco-philippe.github.io/NTV/documentation/user_guide.html)
  12or the [github repository](https://github.com/loco-philippe/NTV).
  13
  14"""
  15import copy
  16from abc import ABC, abstractmethod
  17from numbers import Number
  18import json
  19
  20from json_ntv.namespace import Datatype, Namespace, str_type, relative_type, agreg_type
  21from json_ntv.ntv_util import NtvError, NtvJsonEncoder, NtvConnector, NtvTree, NtvUtil
  22from json_ntv.ntv_patch import NtvPointer
  23
  24NAME = 'N'
  25TYPE = 'T'
  26VALUE = 'V'
  27ENTITY = 'E'
  28NTVSINGLE = 'S'
  29NTVLIST = 'L'
  30
  31
  32class Ntv(ABC, NtvUtil):
  33    ''' The Ntv class is an abstract class used by `NtvSingle`and `NtvList` classes.
  34
  35    *Attributes :*
  36    - **ntv_name** :  String - name of the NTV entity
  37    - **ntv_type**:   Datatype or Namespace - type of the entity
  38    - **ntv_value**:  value of the entity
  39
  40    *Internal attributes :*
  41    - **parent**:     parent NtvList entity
  42    - **is_json**:    True if ntv_value is a json_value
  43
  44    *dynamic values (@property)*
  45    - `code_ntv`
  46    - `json_name_str`
  47    - `json_array` (abstract method)
  48    - `max_len`
  49    - `name`
  50    - `tree`
  51    - `type_str`
  52    - `val`
  53
  54    The methods defined in this class are :
  55
  56    *Ntv constructor (staticmethod)*
  57    - `fast`
  58    - `obj`
  59    - `from_obj`
  60    - `from_att`
  61
  62    *NTV conversion (instance methods)*
  63    - `alike`
  64    - `to_json_ntv`
  65    - `to_obj_ntv`
  66    - `validate` (validation)
  67
  68    *export - conversion (instance methods)*
  69    - `expand`
  70    - `no_type`
  71    - `no_name`
  72    - `reduce`
  73    - `to_fast`
  74    - `to_name`
  75    - `to_obj`
  76    - `to_repr`
  77    - `to_mermaid`
  78    - `to_tuple`
  79    - `to_ntvsingle`
  80    - `to_ntvlist`
  81
  82    *tree methods (instance methods)*
  83    - `childs`
  84    - `pointer`
  85    - `replace`
  86    - `remove`
  87    - `append` (NtvList only)
  88    - `insert` (NtvList only)
  89
  90    *other instance methods*
  91    - `from_value`
  92    - `json_name`
  93    - `set_name`
  94    - `set_type`
  95    - `set_value`
  96    - `obj_value` (abstract method)
  97
  98    *utility methods*
  99    - `decode_json` *(staticmethod)*
 100    - `obj_ntv` *(staticmethod)*
 101    '''
 102
 103    def __init__(self, ntv_value, ntv_name, ntv_type):
 104        '''Ntv constructor.
 105
 106        *Parameters*
 107
 108        - **ntv_value**: Json entity - value of the entity
 109        - **ntv_name** : String (default None) - name of the NTV entity
 110        - **ntv_type**: String or Datatype or Namespace (default None) - type of the entity
 111        '''
 112        if ntv_type.__class__.__name__ in ['Datatype', 'Namespace']:
 113            self.ntv_type = ntv_type
 114        elif ntv_type and ntv_type[-1] != '.':
 115            self.ntv_type = Datatype.add(ntv_type)
 116        elif ntv_type and ntv_type[-1] == '.':
 117            self.ntv_type = Namespace.add(ntv_type)
 118        else:
 119            self.ntv_type = None
 120        if not isinstance(ntv_name, str):
 121            ntv_name = ''
 122        self.ntv_name = ntv_name
 123        self.ntv_value = ntv_value
 124        self.is_json = NtvConnector.is_json(ntv_value)
 125        self.parent = None
 126
 127    @staticmethod
 128    def fast(data, no_typ=False, typ_auto=False):
 129        ''' return an Ntv entity from data without conversion.
 130
 131        *Parameters* : see `obj` method'''
 132        return Ntv.obj(data, no_typ=no_typ, typ_auto=typ_auto, fast=True)
 133
 134    @staticmethod
 135    def obj(data, no_typ=False, decode_str=False, typ_auto=False, fast=False):
 136        ''' return an Ntv entity from data.
 137
 138        *Parameters*
 139
 140        - **Data** can be :
 141            - a tuple with value, name, typ and cat (see `from_att` method)
 142            - a value to decode (see `from_obj`method)
 143        - **no_typ** : boolean (default False) - if True, NtvList is with None type
 144        - **type_auto**: boolean (default False) - if True, default type for NtvList
 145        is the ntv_type of the first Ntv in the ntv_value
 146        - **fast** : boolean (default False) - if True, Ntv entity is created without conversion
 147        - **decode_str**: boolean (default False) - if True, string are loaded in json data'''
 148        #print('obj : ', Namespace.namespaces(), '\n')
 149
 150        if isinstance(data, tuple):
 151            return Ntv.from_att(*data, decode_str=decode_str, fast=fast)
 152        # if isinstance(data, str) and data.lstrip() and data.lstrip()[0] in '{[':
 153        if isinstance(data, str):
 154            try:
 155                data = json.loads(data)
 156            except json.JSONDecodeError:
 157                pass
 158        return Ntv.from_obj(data, no_typ=no_typ, decode_str=decode_str,
 159                            typ_auto=typ_auto, fast=fast)
 160
 161    @staticmethod
 162    def from_att(value, name, typ, cat, decode_str=False, fast=False):
 163        ''' return an Ntv entity.
 164
 165        *Parameters*
 166
 167        - **value**: Ntv entity or value to convert in an Ntv entity
 168        - **name** : string - name of the Ntv entity
 169        - **typ** : string or NtvType - type of the NTV entity
 170        - **cat**: string - NTV category ('single', 'list')
 171        - **fast** : boolean (default False) - if True, Ntv entity is created without conversion
 172        - **decode_str**: boolean (default False) - if True, string are loaded as json data'''
 173
 174        value = Ntv._from_value(value, decode_str)
 175        if value.__class__.__name__ in ['NtvSingle', 'NtvList']:
 176            return value
 177        if isinstance(value, list) and cat == 'list':
 178            return NtvList(value, name, typ, fast=fast)
 179        if cat == 'single':
 180            return NtvSingle(value, name, typ, fast=fast)
 181        return Ntv.from_obj(value, def_type=typ, fast=fast)
 182
 183    @staticmethod
 184    def from_obj(value, def_type=None, def_sep=None, no_typ=False, decode_str=False,
 185                 typ_auto=False, fast=False):
 186        ''' return an Ntv entity from an object value.
 187
 188        *Parameters*
 189
 190        - **value**: Ntv value to convert in an Ntv entity
 191        - **no_typ** : boolean (default None) - if True, NtvList is with None type
 192        - **def_type** : Datatype or Namespace (default None) - default type of the value
 193        - **def_sep**: ':', '::' or None (default None) - default separator of the value
 194        - **decode_str**: boolean (default False) - if True, string are loaded as json data
 195        - **type_auto**: boolean (default False) - if True, default type for NtvList
 196        is the ntv_type of the first Ntv in the ntv_value
 197        - **fast** : boolean (default False) - if True, Ntv entity is created without conversion'''
 198        value = Ntv._from_value(value, decode_str)
 199        if value.__class__.__name__ in ['NtvSingle', 'NtvList']:
 200            return value
 201        ntv_value, ntv_name, str_typ, sep, is_json = Ntv.decode_json(value)
 202        sep = def_sep if not sep else sep
 203        sep = None if str_typ and str_typ[-1] == '.' and sep == ':' else sep
 204        if isinstance(ntv_value, (list, dict)) and sep in (None, '::'):
 205            return Ntv._create_ntvlist(str_typ, def_type, sep, ntv_value,
 206                                       typ_auto, no_typ, ntv_name, fast)
 207        if sep == ':' or (sep is None and isinstance(ntv_value, dict)):
 208            ntv_type = agreg_type(str_typ, def_type, False)
 209            return NtvSingle(ntv_value, ntv_name, ntv_type, fast=fast)
 210        if sep is None and not isinstance(ntv_value, dict):
 211            #is_single_json = isinstance(value, (int, str, float, bool))
 212            is_single_json = isinstance(ntv_value, (int, str, float, bool))
 213            ntv_type = agreg_type(str_typ, def_type, is_single_json)
 214            return NtvSingle(ntv_value, ntv_name, ntv_type, fast=fast)
 215        raise NtvError('separator ":" is not compatible with value')
 216
 217    def __len__(self):
 218        ''' len of ntv_value'''
 219        if isinstance(self.ntv_value, list):
 220            return len(self.ntv_value)
 221        return 1
 222
 223    def __str__(self):
 224        '''return string format'''
 225        return self.to_obj(encoded=True)
 226
 227    def __repr__(self):
 228        '''return classname and code'''
 229        # return json.dumps(self.to_repr(False, False, False, 10), cls=NtvJsonEncoder)
 230        return self.reduce(obj=False, level=3, maxi=6).to_obj(encoded=True)
 231
 232    def __contains__(self, item):
 233        ''' item of Ntv entities'''
 234        if isinstance(self.val, list):
 235            return item in self.ntv_value
 236        return item == self.ntv_value
 237
 238    def __iter__(self):
 239        ''' iterator for Ntv entities'''
 240        if isinstance(self, NtvSingle):
 241            # return iter([self.val])
 242            return iter([self])
 243        return iter(self.val)
 244
 245    def __getitem__(self, selec):
 246        ''' return ntv_value item with selec:
 247            - String beginning with "#" : json-pointer,
 248            - string : name of the ntv,
 249            - list : recursive selector
 250            - tuple : list of name or index '''
 251        if selec is None or selec == '':
 252            return self
 253        if isinstance(selec, NtvPointer) or isinstance(selec, str) and selec[0] == '#':
 254            selec = self._pointer_to_list(selec)
 255        if selec in ([], ()):
 256            return self
 257        if isinstance(selec, (list, tuple)) and len(selec) == 1:
 258            selec = selec[0]
 259        if (selec == 0 or selec == self.ntv_name) and isinstance(self, NtvSingle):
 260            return self.ntv_value
 261        if isinstance(self, NtvSingle):
 262            raise NtvError('item not present')
 263        if isinstance(selec, tuple):
 264            return [self[i] for i in selec]
 265        if isinstance(selec, str):
 266            return self.ntv_value[self._string_to_ind(selec)]
 267        if isinstance(selec, list):
 268            return self[selec[0]][selec[1:]]
 269        return self.ntv_value[selec]
 270
 271    def _pointer_to_list(self, pointer):
 272        '''return a list of child pointers from a string or a NtvPointer'''
 273        if isinstance(pointer, str):
 274            selec = list(NtvPointer(pointer[1:]))
 275        elif isinstance(pointer, NtvPointer):
 276            selec = list(pointer)
 277        else:
 278            raise NtvError('pointer is not a valid pointer')
 279        if not (selec[0] in [self.json_name(string=True), self.ntv_name]
 280                or (isinstance(selec[0], int) and selec[0] == 0)):
 281            raise NtvError(
 282                str(selec[0]) + 'is not the root json_name : ' + self.ntv_name)
 283        return selec[1:]
 284
 285    def _string_to_ind(self, json_name):
 286        '''return the index of a name or a json_name'''
 287        if NtvUtil.from_obj_name(json_name)[1]:
 288            return [ntv.json_name(def_type=self.type_str, string=True)
 289                    for ntv in self.ntv_value].index(json_name)
 290        return [ntv.ntv_name for ntv in self.ntv_value].index(json_name)
 291
 292    def __lt__(self, other):
 293        ''' return a comparison between two ntv_value'''
 294        # order: number > string > None
 295        res = Ntv.lower(self, other)
 296        if res is None:
 297            res = None if len(self) == len(other) else len(self) < len(other)
 298        res = self.to_obj(encoded=True) < other.to_obj(
 299            encoded=True) if res is None else res
 300        return res
 301
 302    @property
 303    def code_ntv(self):
 304        '''return a string with the NTV code composed with 1 to 3 letters:
 305        - 'l' (NtvList), 's' (NtvSingle / json_value) or 'o' (NtvSingle / obj_value)
 306        - 'N' if ntv_name is present else none
 307        - 'T' if ntv_type is present else none'''
 308        dic = {'NtvList': 'l', 'NtvSingle': 's'}
 309        code = dic[self.__class__.__name__]
 310        if isinstance(self, NtvSingle) and not self.is_json:
 311            code = 'o'
 312        if self.ntv_name:
 313            code += 'N'
 314        if self.ntv_type and self.ntv_type.long_name != 'json':
 315            code += 'T'
 316        return code
 317
 318    @property
 319    def json_name_str(self):
 320        '''return the JSON name of the NTV entity'''
 321        return self.json_name(def_type=self.parent.type_str, string=True)
 322
 323    @property
 324    def max_len(self):
 325        '''return the highest len of Ntv entity included'''
 326        maxi = len(self)
 327        if isinstance(self.ntv_value, (list, set)):
 328            maxi = max(maxi, max(ntv.max_len for ntv in self.ntv_value))
 329        return maxi
 330
 331    @property
 332    def name(self):
 333        '''return the ntv_name of the entity'''
 334        return self.ntv_name
 335
 336    @property
 337    def tree(self):
 338        '''return a tree with included entities (NtvTree object)'''
 339        return NtvTree(self)
 340
 341    @property
 342    def type_str(self):
 343        '''return a string with the value of the NtvType of the entity'''
 344        if not self.ntv_type:
 345            return ''
 346        return self.ntv_type.long_name
 347
 348    @property
 349    def val(self):
 350        '''return the ntv_value of the entity'''
 351        return self.ntv_value
 352
 353    def alike(self, ntv_value):
 354        ''' return a Ntv entity with same name and type.
 355
 356        *Parameters*
 357
 358        - **ntv_value**: list of ntv values'''
 359        return self.__class__(ntv_value, self.ntv_name, self.ntv_type)
 360
 361    def childs(self, obj=False, nam=False, typ=False):
 362        ''' return a list of child Ntv entities or child data
 363
 364        *parameters*
 365
 366        - **obj**: boolean (default False) - return json-value
 367        - **nam**: boolean (default False) - return name (with or without type)
 368        - **typ**: boolean (default False) - return type (with or without name)
 369        '''
 370        if isinstance(self, NtvSingle):
 371            return []
 372        if not (obj or nam or typ):
 373            return self.val
 374        if obj:
 375            return [ntv.to_obj() for ntv in self.val]
 376        return [(ntv.name if nam else '') + (' - ' if nam and typ else '') +
 377                (ntv.type_str if typ else '') for ntv in self.val]
 378
 379    def expand(self, full=True, entity=True):
 380        '''return a json representation of the triplet (name, type, value)
 381
 382
 383        *Parameters*
 384
 385        - **full**: Boolean (default True) - If False only members with non empty values are present
 386        - **entity**: Boolean (default True) - If True, member with entity name is added
 387        '''
 388        exp = {ENTITY: self.__class__.__name__} if entity else {}
 389        if isinstance(self, NtvList) and full:
 390            return exp | {NAME: self.name, TYPE: self.type_str,
 391                          VALUE: [ntv.expand(full) for ntv in self.val]}
 392        if isinstance(self, NtvSingle) and full:
 393            return exp | {NAME: self.name, TYPE: self.type_str, VALUE: self.val}
 394        exp |= {} if not self.name else {NAME: self.name}
 395        if not self.type_str in ['json', '']:
 396            exp[TYPE] = self.type_str
 397        if isinstance(self, NtvList):
 398            exp[VALUE] = [ntv.expand(full) for ntv in self.val]
 399        else:
 400            exp[VALUE] = self.val
 401        return exp
 402
 403    def from_value(self):
 404        '''return a Ntv entity from ntv_value'''
 405        if isinstance(self.ntv_value, list):
 406            return NtvList(self.ntv_value)
 407        return Ntv.from_obj(self.ntv_value)
 408
 409    def json_name(self, def_type=None, string=False, explicit=False):
 410        '''return the JSON name of the NTV entity (json-ntv format)
 411
 412        *Parameters*
 413
 414        - **def_typ** : Datatype or Namespace (default None) - type of the parent entity
 415        - **string** : boolean (default False) - If True, return a string else a tuple
 416        - **explicit** : boolean (default False) - If True, type is always included'''
 417        if def_type is None:
 418            def_type = ''
 419        elif isinstance(def_type, (Datatype, Namespace)):
 420            def_type = def_type.long_name
 421        json_name = self.ntv_name if self.ntv_name else ''
 422        json_type = relative_type(
 423            def_type, self.type_str) if self.ntv_type else ''
 424        implicit = isinstance(self, NtvSingle) and (json_type == 'json'
 425                                                    and (not def_type or def_type == 'json' or def_type[-1] == '.')
 426                                                    or not NtvConnector.is_json_class(self.val))
 427        if implicit and not explicit:
 428            json_type = ''
 429        json_sep = self._obj_sep(json_name, json_type, def_type)
 430        if string:
 431            return json_name + json_sep + json_type
 432        return [json_name, json_sep, json_type]
 433
 434    @staticmethod
 435    def lower(val1, val2):
 436        ''' compare two ntv_value and return True if val1 < val2, False if val1 > val2 and
 437        None in the other cases'''
 438        res = None
 439        for v1, v2 in zip(Ntv.obj(val1).tree.leaf_nodes, Ntv.obj(val2).tree.leaf_nodes):
 440            if v1.val is None:
 441                res = True
 442            elif isinstance(v1.val, (dict, list)):
 443                res = Ntv.lower(v1.val, v2)
 444            elif isinstance(v2.val, (dict, list)):
 445                res = Ntv.lower(v1, v2.val)
 446            elif isinstance(v1.val, Number):
 447                if isinstance(v2.val, Number):
 448                    res = None if v1.val == v2.val else v1.val < v2.val
 449                else:
 450                    res = False
 451            elif isinstance(v1.val, str):
 452                if isinstance(v2.val, Number):
 453                    res = True
 454                elif isinstance(v2.val, str):
 455                    res = None if v1.val == v2.val else v1.val < v2.val
 456                else:
 457                    res = False
 458            if not res is None:
 459                break
 460        return res
 461
 462    def no_type(self):
 463        '''convert NTV entity in a NV entity (in which ntv_type is 'json' or None')'''
 464        no_typ = copy.copy(self)
 465        for ntv in NtvTree(no_typ).leaf_nodes:
 466            ntv.set_type('json')
 467        for ntv in NtvTree(no_typ).inner_nodes:
 468            ntv.set_type()
 469        return no_typ
 470
 471    def no_name(self):
 472        '''convert NTV entity in a TV entity (in which ntv_name is None)'''
 473        no_nam = copy.copy(self)
 474        for ntv in NtvTree(no_nam):
 475            ntv.ntv_name = None
 476        return no_nam
 477
 478    def no_value(self):
 479        '''convert NTV entity in a NV entity (in which ntv_value of leaf nodes is ntv_type )'''
 480        no_val = copy.copy(self)
 481        for ntv in NtvTree(no_val).leaf_nodes:
 482            ntv.ntv_value = ntv.type_str
 483            ntv.set_type('json')
 484        return no_val
 485
 486    def only_type(self):
 487        '''convert NTV entity in a V entity (in which ntv_value of leaf nodes
 488        is ntv_type )'''
 489        only_typ = copy.copy(self)
 490        for ntv in NtvTree(only_typ).leaf_nodes:
 491            ntv.ntv_value = ntv.type_str
 492            ntv.set_type('json')
 493            ntv.set_name()
 494        for ntv in NtvTree(only_typ).inner_nodes:
 495            ntv.set_name()
 496            ntv.set_type()
 497        return only_typ
 498
 499    def only_name(self):
 500        '''convert NTV entity in a V entity (in which ntv_value of leaf nodes
 501        is ntv_name )'''
 502        only_nam = copy.copy(self)
 503        for ntv in NtvTree(only_nam).leaf_nodes:
 504            ntv.ntv_value = ntv.name
 505            ntv.set_type('json')
 506            ntv.set_name()
 507        for ntv in NtvTree(only_nam).inner_nodes:
 508            ntv.set_type()
 509        return only_nam
 510
 511    def only_value(self):
 512        '''convert NTV entity in a V entity'''
 513        only_val = copy.copy(self)
 514        for ntv in NtvTree(only_val).leaf_nodes:
 515            ntv.set_type('json')
 516            ntv.set_name()
 517        for ntv in NtvTree(only_val).inner_nodes:
 518            ntv.set_type()
 519            ntv.set_name()
 520        return only_val
 521
 522    @staticmethod
 523    def obj_ntv(value, name='', typ='', single=False):
 524        '''return a json-ntv representation without using Ntv structure.
 525
 526        *Parameters*
 527
 528        - **value** : ntv-value of the json-ntv
 529        - **name** : string (default '') - ntv-name of the json-ntv
 530        - **typ** : string (default '') - ntv_type of the json-ntv
 531        - **single** : boolean (default False) - if True, value is a single object
 532        else value is a set of objetcs.
 533        '''
 534        value = {} if not value else value
 535        name = '' if not name else name
 536        typ = '' if not typ else typ
 537        ntv_list = isinstance(value, (list, dict))
 538        if not single and not ntv_list:
 539            raise NtvError('value is not compatible with not single NTV data')
 540        sep = ':' if single else '::'
 541        sep = '' if not typ and (
 542            not single or single and not ntv_list) else sep
 543        name += sep + typ
 544        value = [value] if not name and isinstance(
 545            value, dict) and len(value) == 1 else value
 546        return {name: value} if name else value
 547
 548    def pointer(self, index=False, item_idx=None):
 549        '''return a nested list of pointer from root
 550
 551        *Parameters*
 552
 553        - **index**: Boolean (default False) - use index instead of name
 554        - **item_idx**: Integer (default None) - index value for the pointer
 555        (useful with duplicate data)'''
 556        if not self.parent:
 557            root_pointer = 0 if index else self.json_name(string=True)
 558            return NtvPointer([root_pointer])
 559        idx = item_idx if item_idx else self.parent.ntv_value.index(self)
 560        num = index or self.parent.json_array
 561        pointer = self.parent.pointer(index)
 562        pointer.append(idx if num else self.json_name_str)
 563        return pointer
 564
 565    def reduce(self, obj=True, maxi=6, level=3):
 566        '''reduce the length and the level of the entity
 567
 568        *Parameters*
 569
 570        - **obj**: boolean (default True) - If True return jsonNTV else NTV entity
 571        - **maxi**: integer (default 6) - Number of returned entities in an NtvList
 572        - **level**: integer (default 6) - returned entities in an NtvList at this level is None
 573
 574        *return*
 575
 576        - **NTV entity** or **jsonNTV**
 577        '''
 578        ntv = copy.copy(self)
 579        cont = Ntv.obj('___') if self.json_array else Ntv.obj({'___': ''})
 580        if isinstance(self, NtvSingle):
 581            return ntv
 582        if level == 0:
 583            ntv.ntv_value = [Ntv.obj('___', no_typ=True)]
 584        if len(self) <= maxi:
 585            ntv.ntv_value = [child.reduce(False, maxi, level-1)
 586                             for child in ntv]
 587            return ntv
 588        mid = maxi // 2
 589        cont.set_type(ntv.type_str)
 590        start = [child.reduce(False, maxi, level-1) for child in ntv[:mid]]
 591        middle = [cont]
 592        end = [child.reduce(False, maxi, level-1) for child in ntv[-mid:]]
 593        ntv.ntv_value = start + middle + end
 594        if obj:
 595            return ntv.to_obj()
 596        return ntv
 597
 598    def remove(self, first=True, index=None):
 599        '''remove self from its parent entity.
 600
 601        *parameters*
 602
 603        - **first** : boolean (default True) - if True only the first instance
 604        else all
 605        - **index** : integer (default None) - index of self in its parent
 606        '''
 607        parent = self.parent
 608        if not parent:
 609            return
 610        idx = parent.ntv_value.index(self) if index is None else index
 611        if not parent[idx] == self:
 612            raise NtvError('the entity is not present at the index')
 613        del parent.ntv_value[idx]
 614        if not first and index is None:
 615            while self in parent:
 616                idx = parent.ntv_value.index(self)
 617                del parent.ntv_value[idx]
 618        if not self in parent:
 619            self.parent = None
 620        return
 621
 622    def replace(self, ntv):
 623        '''replace self by ntv in the tree'''
 624        parent = self.parent
 625        if parent:
 626            idx = parent.ntv_value.index(self)
 627            parent.insert(idx, ntv)
 628            del parent[idx+1]
 629            if not self in parent:
 630                self.parent = None
 631        else:
 632            self = ntv
 633
 634    def set_name(self, name='', nodes='simple'):
 635        '''set new names to the entity
 636
 637        *Parameters*
 638
 639        - **name**: list or string (default '') - New name values
 640        - **nodes**: string (default 'simple') - nodes to be changed
 641            'simple': current entity
 642            'leaves': NtvSingle entities
 643            'inner': NtvList entities
 644            'all': all entities  '''
 645        name = '' if name is None else name
 646        match nodes:
 647            case 'simple':
 648                self.ntv_name = str(name)
 649            case 'leaves':
 650                if not isinstance(name, list):
 651                    name = [str(name)] * NtvTree(self).breadth
 652                for nam, ntv in zip(name, NtvTree(self).leaf_nodes):
 653                    ntv.ntv_name = nam
 654            case 'inner':
 655                if not isinstance(name, list):
 656                    name = [str(name)] * len(NtvTree(self).inner_nodes)
 657                for nam, ntv in zip(name, NtvTree(self).inner_nodes):
 658                    ntv.ntv_name = nam
 659            case 'all':
 660                if not isinstance(name, list):
 661                    name = [str(name)] * NtvTree(self).size
 662                for nam, ntv in zip(name, NtvTree(self).nodes):
 663                    ntv.ntv_name = nam
 664            case _:
 665                raise NtvError('the nodes option is not valid')
 666
 667    def set_type(self, typ=None):
 668        '''set a new type to the entity
 669
 670        *Parameters*
 671
 672        - **typ**: string, Datatype, Namespace (default None)'''
 673        if typ and not isinstance(typ, (str, Datatype, Namespace)):
 674            raise NtvError('the type is not a valid type')
 675        self.ntv_type = str_type(typ, self.__class__.__name__ == 'NtvSingle')
 676
 677    def set_value(self, value=None, fast=False):
 678        '''set new ntv_value of a single entity or of a list of entities included
 679
 680        *Parameters*
 681
 682        - **value**: list or single value
 683        - **fast** : boolean (default False) - if True, value is not converted'''
 684        if isinstance(self, NtvSingle):
 685            self.ntv_value = NtvSingle(value, ntv_type=self.ntv_type,
 686                                       fast=fast).val
 687            return
 688        if not isinstance(value, list):
 689            value = [value] * NtvTree(self).breadth
 690        ntv_val = NtvList(value, fast=fast)
 691        for val, ntv in zip(ntv_val, NtvTree(self).leaf_nodes):
 692            ntv.ntv_value = val.val
 693        return
 694
 695    def to_ntvsingle(self, name=None, typ=None, def_type=None, **kwargs):
 696        '''convert NtvList entity to NtvSingle entity
 697
 698        *Parameters*
 699
 700        - **ntv_name** : String (default None) - name of the NTV entity
 701        - **ntv_type**: String (default None) - type of the entity
 702        - **value**: value of the entity
 703        - **fast**: boolean (default False) - Ntv is created with a list of json values
 704        without control
 705        '''
 706        return NtvSingle(self.obj_value(def_type=def_type, **kwargs),
 707                         self.name if self.name else name,
 708                         self.type_str if self.type_str else typ)
 709
 710    def to_ntvlist(self, def_type=None, def_sep=None, no_typ=False, decode_str=False,
 711                   typ_auto=False, fast=False):
 712        '''convert NtvSingle entity to NtvList entity
 713
 714        *Parameters*
 715
 716        - **value**: Ntv value to convert in an Ntv entity
 717        - **no_typ** : boolean (default None) - if True, NtvList is with 'json' type
 718        - **def_type** : Datatype or Namespace (default None) - default type of the value
 719        - **def_sep**: ':', '::' or None (default None) - default separator of the value
 720        - **decode_str**: boolean (default False) - if True, string are loaded as json data
 721        - **type_auto**: boolean (default False) - if True, default type for NtvList
 722        is the ntv_type of the first Ntv in the ntv_value
 723        - **fast** : boolean (default False) - if True, Ntv entity is created without conversion
 724        '''
 725        ntv = Ntv.from_obj(self.ntv_value, def_type, def_sep, no_typ, decode_str,
 726                           typ_auto, fast)
 727        if ntv.__class__.__name__ == 'NtvSingle':
 728            return NtvList([self])
 729        if self.ntv_name:
 730            ntv.set_name(self.ntv_name)
 731        return ntv
 732
 733    def to_mermaid(self, title='', disp=False, row=False, leaves=False):
 734        '''return a mermaid flowchart.
 735
 736        *Parameters*
 737
 738        - **title**: String (default '') - title of the flowchart
 739        - **disp**: Boolean (default False) - if true, return a display else return
 740        a mermaid text diagram
 741        - **row**: Boolean (default False) - if True, add the node row
 742        - **leaves**: Boolean (default False) - if True, add the leaf row
 743        '''
 744        option = {'title': title, 'disp': disp, 'row': row, 'leaves': leaves}
 745        if disp:
 746            Ntv.obj({':$mermaid': self.to_obj()}).to_obj(
 747                format='obj', **option)
 748            return None
 749        return Ntv.obj({':$mermaid': self.to_obj()}).to_obj(format='obj', **option)
 750
 751    def to_repr(self, nam=True, typ=True, val=True, jsn=False, maxi=10):
 752        '''return a simple json representation of the Ntv entity.
 753
 754        *Parameters*
 755
 756        - **nam**: Boolean(default True) - if true, the names are included
 757        - **typ**: Boolean(default True) - if true, the types are included
 758        - **val**: Boolean(default True) - if true, the values are included
 759        - **jsn**: Boolean(default False) - if false, the 'json' type is not included
 760        - **maxi**: Integer (default 10) - number of values to include for NtvList
 761        entities. If maxi < 1 all the values are included.
 762        '''
 763        ntv = self.code_ntv
 764        if nam and typ:
 765            ntv = ntv[0]
 766        if self.ntv_name and nam:
 767            ntv += '-' + self.ntv_name
 768        if self.ntv_type and typ and (jsn or self.ntv_type.long_name != 'json'):
 769            ntv += '-' + self.ntv_type.long_name
 770        clas = self.__class__.__name__
 771        clas_val = self.ntv_value.__class__.__name__
 772        if clas == 'NtvSingle' and clas_val != 'NtvSingle':
 773            if val:
 774                if ntv:
 775                    ntv += '-'
 776                ntv += json.dumps(self.ntv_value, cls=NtvJsonEncoder)
 777            return ntv
 778        if clas == 'NtvSingle' and clas_val == 'NtvSingle':
 779            return {ntv:  self.ntv_value.to_repr(nam, typ, val, jsn, maxi)}
 780        if clas == 'NtvList':
 781            maxv = len(self.ntv_value) if maxi < 1 else maxi
 782            return {ntv:  [ntvi.to_repr(nam, typ, val, jsn, maxi)
 783                           for ntvi in self.ntv_value[:maxv]]}
 784        raise NtvError('the ntv entity is not consistent')
 785
 786    def to_name(self, default=''):
 787        '''return the name of the NTV entity
 788
 789        *Parameters*
 790
 791        - **default**: string (default ''): returned value if name is not present '''
 792        if self.ntv_name == '':
 793            return default
 794        return self.ntv_name
 795
 796    def to_fast(self, def_type=None, **kwargs):
 797        '''return the JSON representation of the NTV entity (json-ntv format)
 798        without value conversion.
 799
 800        *Parameters*
 801
 802        - **def_type** : Datatype or Namespace (default None) - default type to apply
 803        to the NTV entity
 804        - **encoded** : boolean (default False) - choice for return format
 805        (string/bytes if True, dict/list/tuple else)
 806        - **format**  : string (default 'json')- choice for return format
 807        (json, cbor, obj)
 808        - **simpleval** : boolean (default False) - if True, only value (without
 809        name and type) is included
 810        - **name** : boolean (default true) - if False, name is not included
 811        - **json_array** : boolean (default false) - if True, Json-object is not used for NtvList
 812        - **maxi**: Integer (default -1) - number of values to include for NtvList
 813        entities. If maxi < 1 all the values are included.
 814        '''
 815        option = kwargs | {'fast': True}
 816        return self.to_obj(def_type=def_type, **option)
 817
 818    def to_obj(self, def_type=None, **kwargs):
 819        '''return the JSON representation of the NTV entity (json-ntv format).
 820
 821        *Parameters*
 822
 823        - **def_type** : Datatype or Namespace (default None) - default type to apply
 824        to the NTV entity
 825        - **encoded** : boolean (default False) - choice for return format
 826        (string/bytes if True, dict/list/tuple else)
 827        - **format**  : string (default 'json')- choice for return format
 828        (json, cbor, obj)
 829        - **simpleval** : boolean (default False) - if True, only value (without
 830        name and type) is included
 831        - **name** : boolean (default true) - if False, name is not included
 832        - **json_array** : boolean (default false) - if True, Json-object is not used for NtvList
 833        - **fast** : boolean (default False) - if True, json is created without conversion
 834        - **maxi**: Integer (default -1) - number of values to include for NtvList
 835        entities. If maxi < 1 all the values are included.
 836        '''
 837        option = {'encoded': False, 'format': 'json', 'fast': False, 'maxi': -1,
 838                  'simpleval': False, 'name': True, 'json_array': False} | kwargs
 839        value = self.obj_value(def_type=def_type, **option)
 840        obj_name = self.json_name(def_type)
 841        if not option['name']:
 842            obj_name[0] = ''
 843        if option['simpleval']:
 844            name = ''
 845        elif option['format'] in ('cbor', 'obj') and not NtvConnector.is_json_class(value):
 846            name = obj_name[0]
 847        else:
 848            name = obj_name[0] + obj_name[1] + obj_name[2]
 849        value = [value] if not name and isinstance(
 850            value, dict) and len(value) == 1 else value
 851        json_obj = {name: value} if name else value
 852        if option['encoded'] and option['format'] == 'json':
 853            return json.dumps(json_obj, cls=NtvJsonEncoder)
 854        if option['encoded'] and option['format'] == 'cbor':
 855            return NtvConnector.connector()['CborConnec'].to_obj_ntv(json_obj)
 856        return json_obj
 857
 858    def to_json_ntv(self):
 859        ''' create a copy where ntv-value of the self-tree nodes is converted
 860        in json-value'''
 861        ntv = copy.copy(self)
 862        for leaf in ntv.tree.leaf_nodes:
 863            if isinstance(leaf.ntv_value, (NtvSingle, NtvList)):
 864                leaf.ntv_value = leaf.ntv_value.to_obj()
 865                leaf.ntv_type = Datatype('ntv')
 866            elif not leaf.is_json:
 867                leaf.ntv_value, leaf.ntv_name, type_str = NtvConnector.cast(
 868                    leaf.ntv_value, leaf.ntv_name, leaf.type_str)
 869                leaf.ntv_type = Datatype.add(type_str)
 870                leaf.is_json = True
 871        return ntv
 872
 873    def to_obj_ntv(self, **kwargs):
 874        ''' create a copy where ntv-value of the self-tree nodes is converted
 875        in object-value
 876
 877        *Parameters*
 878
 879        - **kwargs** : parameters used in NtvConnector class (specific for each Connector)'''
 880        ntv = copy.copy(self)
 881        for leaf in ntv.tree.leaf_nodes:
 882            if (leaf.is_json and leaf.type_str in set(NtvConnector.dic_type.values())
 883                    or leaf.ntv_type is None):
 884                leaf.ntv_value, leaf.ntv_name, type_str = NtvConnector.uncast(
 885                    leaf, **kwargs)
 886                leaf.ntv_type = Datatype.add(type_str) if type_str else None
 887                leaf.is_json = NtvConnector.is_json(leaf.ntv_value)
 888        return ntv
 889
 890    def to_tuple(self, maxi=10):
 891        '''return a nested tuple representation of the NTV entity
 892        (NtvList/NtvSingle, ntv_name, ntv_type, ntv_value).
 893
 894        *Parameters*
 895
 896        - **maxi**: Integer (default 10) - number of values to include for NtvList
 897        entities. If maxi < 1 all the values are included.
 898        '''
 899        clas = self.__class__.__name__
 900        val = self.ntv_value
 901        name = self.ntv_name
 902        typ = None
 903        if self.ntv_type:
 904            typ = self.ntv_type.long_name
 905        if isinstance(self, NtvSingle) and not isinstance(val, NtvSingle):
 906            return (clas, name, typ, val)
 907        if isinstance(self, NtvSingle) and isinstance(val, NtvSingle):
 908            return (clas, name, typ, val.to_tuple(maxi=maxi))
 909        if isinstance(self, NtvList):
 910            maxv = len(self.ntv_value) if maxi < 1 else maxi
 911            return (clas, name, typ, [ntv.to_tuple(maxi=maxi) for ntv in val[:maxv]])
 912        raise NtvError('the ntv entity is not consistent')
 913
 914    def validate(self, unique=False):
 915        '''check the ntv_type validity and return a boolean and a list of errors
 916
 917        *Parameters*
 918
 919        - **unique**: boolean (default False) - if True, stop validation at the
 920        first error'''
 921        errors = []
 922        for ntv in self.tree.leaf_nodes:
 923            valid = ntv.ntv_type.validate(ntv.ntv_value)
 924            if not valid:
 925                errors.append(str(ntv.pointer()))
 926                if unique:
 927                    return (False, errors)
 928        return (not errors, errors)
 929
 930    @abstractmethod
 931    def obj_value(self):
 932        '''return the ntv_value with different formats defined by kwargs (abstract method)'''
 933
 934    @property
 935    @abstractmethod
 936    def json_array(self):
 937        ''' return the json_array dynamic attribute (abstract method)'''
 938
 939    @abstractmethod
 940    def _obj_sep(self, json_type, def_type):
 941        ''' return separator to include in json_name (abstract method)'''
 942
 943    @staticmethod
 944    def _from_value(value, decode_str=False):
 945        '''return a decoded value
 946
 947        *Parameters*
 948
 949        - **decode_str**: boolean (default False) - if True, string are loaded as json data
 950        '''
 951        if isinstance(value, bytes):
 952            value = Ntv.from_obj({'$cbor': value}).ntv_value
 953        elif decode_str and isinstance(value, str) and value.lstrip() and\
 954                value.lstrip()[0] in '"-{[0123456789tfn':
 955            try:
 956                value = json.loads(value)
 957            except json.JSONDecodeError:
 958                pass
 959        return value
 960
 961    @staticmethod
 962    def decode_json(json_value):
 963        '''return (value, name, type, separator, isjson) of a json object'''
 964        if isinstance(json_value, dict) and len(json_value) == 1:
 965            json_name = list(json_value.keys())[0]
 966            val = json_value[json_name]
 967            return (val, *NtvUtil.from_obj_name(json_name), NtvConnector.is_json(val))
 968        return (json_value, None, None, None, NtvConnector.is_json(json_value))
 969
 970    @staticmethod
 971    def _create_ntvlist(str_typ, def_type, sep, ntv_value, typ_auto, no_typ, ntv_name, fast):
 972        '''return a NtvList with parameters from Ntv.from_obj method'''
 973        def_type = agreg_type(str_typ, def_type, False)
 974        sep_val = ':' if sep and def_type else None
 975        if isinstance(ntv_value, dict):
 976            keys = list(ntv_value.keys())
 977            values = list(ntv_value.values())
 978            ntv_list = [Ntv.from_obj({key: val}, def_type, sep_val, fast=fast)
 979                        for key, val in zip(keys, values)]
 980        else:
 981            ntv_list = [Ntv.from_obj(val, def_type, sep_val, fast=fast)
 982                        for val in ntv_value]
 983        if typ_auto and not def_type and ntv_list:
 984            def_type = ntv_list[0].ntv_type
 985        def_type = None if no_typ else def_type
 986        return NtvList(ntv_list, ntv_name, def_type, typ_auto, fast=fast)
 987
 988    @staticmethod
 989    def _listed(idx):
 990        '''transform a tuple of tuple object in a list of list object'''
 991        return [val if not isinstance(val, tuple) else Ntv._listed(val) for val in idx]
 992
 993
 994class NtvSingle(Ntv):
 995    ''' A NTV-single entity is a Ntv entity not composed with other entities.
 996
 997    *Attributes :*
 998    - no additional attributes to those of parent class `Ntv`
 999
1000    *dynamic values (@property)*
1001    - `json_array`
1002
1003    The additional methods defined in this class are :
1004
1005    *instance methods*
1006    - `obj_value`
1007    '''
1008
1009    def __init__(self, value, ntv_name=None, ntv_type=None, fast=False):
1010        '''NtvSingle constructor.
1011
1012        *Parameters*
1013
1014        - **ntv_name** : String (default None) - name of the NTV entity
1015        - **ntv_type**: String (default None) - type of the entity
1016        - **value**: value of the entity
1017        - **fast**: boolean (default False) - Ntv is created with a list of json values
1018        without control
1019        '''
1020        if not fast:
1021            value, ntv_name, ntv_type = NtvSingle._decode_s(
1022                value, ntv_name, ntv_type)
1023            if ntv_type and isinstance(ntv_type, str) and ntv_type[-1] == '.':
1024                raise NtvError('the ntv_type is not valid')
1025        super().__init__(value, ntv_name, ntv_type)
1026
1027    def __eq__(self, other):
1028        ''' equal if name type and value are equal'''
1029        return self.__class__.__name__ == other.__class__.__name__ and\
1030            self.ntv_name == other.ntv_name and self.ntv_type == other.ntv_type and\
1031            self.ntv_value == other.ntv_value
1032
1033    def __hash__(self):
1034        '''return hash(name) + hash(type) + hash(value)'''
1035        return hash(self.ntv_name) + hash(self.ntv_type) + \
1036            hash(json.dumps(self.ntv_value, cls=NtvJsonEncoder))
1037
1038    def __copy__(self):
1039        ''' Copy all the Ntv tree '''
1040        return self.__class__(copy.copy(self.ntv_value), self.ntv_name,
1041                              self.ntv_type, fast=True)
1042
1043    @property
1044    def json_array(self):
1045        ''' return the json_array dynamic attribute (always False)'''
1046        return False
1047
1048    def obj_value(self, def_type=None, **kwargs):
1049        '''return the ntv_value with different formats defined by kwargs'''
1050        option = {'encoded': False, 'format': 'json',
1051                  'simpleval': False, 'fast': False} | kwargs
1052        if option['fast'] or option['format'] in ('json', 'tuple'):
1053            return self.ntv_value
1054        if option['format'] == 'obj' and self.ntv_value == 'null':
1055            return None
1056        return NtvConnector.uncast(self, **option)[0]
1057
1058    def _obj_sep(self, json_name, json_type, def_type=None):  # REQ5
1059        ''' return separator to include in json_name'''
1060        if json_type or not def_type and isinstance(self.ntv_value, (list, dict)):
1061            return ':'
1062        return ''
1063
1064    @staticmethod
1065    def _decode_s(ntv_value, ntv_name, ntv_type_str):
1066        '''return adjusted ntv_value, ntv_name, ntv_type(str)'''
1067        is_json = NtvConnector.is_json(ntv_value)
1068        if is_json:
1069            if isinstance(ntv_value, (list)):
1070                ntv_value = [NtvSingle._decode_s(val, '', ntv_type_str)[
1071                    0] for val in ntv_value]
1072            elif isinstance(ntv_value, (dict)):
1073                ntv_value = {key: NtvSingle._decode_s(val, '', ntv_type_str)[
1074                    0] for key, val in ntv_value.items()}
1075        elif isinstance(ntv_value, NtvSingle):
1076            ntv_value = ntv_value.to_obj()
1077            return (ntv_value, ntv_name, 'ntv')
1078        else:
1079            ntv_value, name, typ_str = NtvConnector.cast(ntv_value, ntv_name)
1080            ntv_type_str = Datatype.add(
1081                typ_str).name if typ_str else ntv_type_str
1082        if not ntv_type_str:
1083            if is_json:
1084                ntv_type_str = 'json'
1085            else:
1086                ntv_type_str = typ_str
1087                if not ntv_name:
1088                    ntv_name = name
1089        elif not is_json and ntv_type_str != typ_str:
1090            raise NtvError('ntv_value is not compatible with ntv_type')
1091        return (ntv_value, ntv_name, ntv_type_str)
1092
1093
1094class NtvList(Ntv):
1095    '''A NTV-list entity is a Ntv entity where:
1096
1097    - ntv_value is a list of NTV entities,
1098    - ntv_type is a default type available for included NTV entities
1099
1100    *Attributes :*
1101    - no additional attributes to those of parent class `Ntv`
1102
1103    *dynamic values (@property)*
1104    - `json_array`
1105
1106    The additional methods defined in this class are :
1107
1108    *instance methods*
1109    - `obj_value`
1110    '''
1111
1112    def __init__(self, list_ntv, ntv_name=None, ntv_type=None, typ_auto=False, fast=False):
1113        '''NtvList constructor.
1114
1115        *Parameters*
1116
1117        - **ntv_name** : String (default None) - name of the NTV entity
1118        - **ntv_type**: String (default None) - default type or namespace of
1119        the included entities
1120        - **list_ntv**: list - list of Ntv objects or obj_value of Ntv objects
1121        - **fast**: boolean (default False) - if True, Ntv is created with a list
1122        of json values without control
1123        - **type_auto**: boolean (default False) - if True, default type for NtvList
1124        is the ntv_type of the first Ntv in the ntv_value'''
1125        if isinstance(list_ntv, NtvList):
1126            ntv_value = [copy.copy(ntv) for ntv in list_ntv.ntv_value]
1127            ntv_type = list_ntv.ntv_type
1128            ntv_name = list_ntv.ntv_name
1129        elif isinstance(list_ntv, list):
1130            ntv_value = [Ntv.from_obj(ntv, ntv_type, ':', fast=fast)
1131                         for ntv in list_ntv]
1132        elif isinstance(list_ntv, dict):
1133            ntv_value = [Ntv.from_obj({key: val}, ntv_type, ':', fast=fast)
1134                         for key, val in list_ntv.items()]
1135        else:
1136            raise NtvError('ntv_value is not a list')
1137        if typ_auto and not ntv_type and len(ntv_value) > 0 and ntv_value[0].ntv_type:
1138            ntv_type = ntv_value[0].ntv_type
1139        super().__init__(ntv_value, ntv_name, ntv_type)
1140        for ntv in self:
1141            ntv.parent = self
1142
1143    @property
1144    def json_array(self):
1145        ''' return the json_array dynamic attribute'''
1146        set_name = {ntv.json_name(
1147            def_type=self.type_str, string=True) for ntv in self}
1148        return '' in set_name or len(set_name) != len(self)
1149
1150    def __eq__(self, other):
1151        ''' equal if name and value are equal'''
1152        return self.__class__.__name__ == other.__class__.__name__ and\
1153            self.ntv_name == other.ntv_name and self.ntv_value == other.ntv_value
1154
1155    def __hash__(self):
1156        '''return hash(name) + hash(value)'''
1157        return hash(self.ntv_name) + hash(tuple(self.ntv_value))
1158
1159    def __copy__(self):
1160        ''' Copy all the data '''
1161        cop = self.__class__(self)
1162        cop.parent = None
1163        return cop
1164
1165    def __setitem__(self, ind, value):
1166        ''' replace ntv_value item at the `ind` row with `value`'''
1167        if ind < 0 or ind >= len(self):
1168            raise NtvError("out of bounds")
1169        self.ntv_value[ind] = value
1170        if isinstance(value, (NtvSingle, NtvList)):
1171            value.parent = self
1172
1173    def __delitem__(self, ind):
1174        '''remove ntv_value item at the `ind` row'''
1175        if isinstance(ind, int):
1176            self.ntv_value.pop(ind)
1177        else:
1178            self.ntv_value.pop(self.ntv_value.index(self[ind]))
1179
1180    def append(self, ntv):
1181        ''' add ntv at the end of the list of Ntv entities included'''
1182        old_parent = ntv.parent
1183        if old_parent:
1184            del(old_parent[old_parent.ntv_value.index(ntv)])
1185        self.ntv_value.append(ntv)
1186        ntv.parent = self
1187
1188    def insert(self, idx, ntv):
1189        ''' add ntv at the index idx of the list of Ntv entities included'''
1190        old_parent = ntv.parent
1191        if old_parent:
1192            del(old_parent[old_parent.ntv_value.index(ntv)])
1193        self.ntv_value.insert(idx, ntv)
1194        ntv.parent = self
1195
1196    def _obj_sep(self, json_name, json_type, def_type=None):
1197        ''' return separator to include in json_name'''
1198        sep = ':' if (json_type and json_type[-1] == '.') else '::'
1199        return sep if (json_type and json_type[-1] != '.') or (json_type and json_name) else ''
1200
1201    def obj_value(self, def_type=None, **kwargs):
1202        '''return the ntv_value with different formats defined by kwargs
1203        '''
1204        option = {'encoded': False, 'format': 'json', 'simpleval': False,
1205                  'json_array': False, 'fast': False, 'maxi': -1} | kwargs
1206        opt2 = option | {'encoded': False}
1207        maxv = len(self.ntv_value) if option['maxi'] < 1 else option['maxi']
1208        def_type = self.ntv_type.long_name if self.ntv_type else def_type
1209        values = [ntv.to_obj(def_type=def_type, **opt2)
1210                  for ntv in self.ntv_value[:maxv]]
1211        if len(self) == 1 and isinstance(self[0], NtvSingle) and isinstance(values[0], dict):
1212            return values[0]
1213        if self.json_array or option['simpleval'] or option['json_array']:
1214            return values
1215        return {list(val.items())[0][0]: list(val.items())[0][1] for val in values}