defl/tests.old/test_table.py

#!/usr/bin/env python


from dataclasses import dataclass, field, KW_ONLY
from typing import ClassVar, Any, Callable, NewType, Container, Mapping, Self, ValuesView, KeysView, ItemsView
import defl
import sys
import pathlib
from operator import itemgetter
from defl import log, cl

from typing import ClassVar
import defl
import json
from defl import log, cl, testing_

tester = testing_.Tester(name=__file__)

listData = [[f'{x1}{x2}' for x2 in [1, 2, 3, 4]] for x1 in ['a', 'b', 'c', 'd']]
dictData = {"a1": ["b1", "c1", "d1"], "a2": ["b2", "c2", "d2"], "a3": ["b3", "c3", "d3"], "a4": ["b4", "c4", "d4"]}
simple = {'a': [1, 2], 'b': [3, 4], 'c': [0, 0]}


@tester.add()
def createTableList():
    jd = defl.Table(listData)
    assert jd.data == dictData, jd.data


@tester.add()
def createTableDict():
    jd = defl.Table(dictData)
    assert jd.data == dictData, jd.data


@tester.add()
def addData():
    jd = defl.Table(listData)
    jd['add'] = [[5, 4, 3]]
    assert jd.data['add'] == [5, 4, 3], jd.data


@tester.add()
def sort():
    jd = defl.Table({
        'a': [0, 0, 1, 0, 0],
        'b': [1, 1, 1, 2, 2],
        'c': [4, 3, 1, 2, 1],
    })

    assert jd.data is not jd.sort().data, 'same dictionary not good'
    assert (t := jd.sort().data) == {'a': [0, 0, 0, 0, 1], 'b': [1, 1, 2, 2, 1], 'c': [3, 4, 1, 2, 1]}, t
    assert (t := jd.sort(['a', 'b', 'c']).data) == {'a': [0, 0, 0, 0, 1], 'b': [1, 1, 2, 2, 1], 'c': [3, 4, 1, 2, 1]}, t
    rev = jd.sort(['a', 'b', 'c'], reverse=[True, False, True]).data
    assert rev == {'a': [1, 0, 0, 0, 0], 'b': [1, 1, 1, 2, 2], 'c': [1, 4, 3, 2, 1]}


@ tester.add()
def add():
    jd = defl.Table(simple)
    jd[['a', 'b']] = jd[['a', 'b']] - 1
    assert jd.data == {'a': [0, 1], 'b': [2, 3], 'c': [0, 0]}, jd.data


@ tester.add()
def opTable():
    jd = defl.Table(simple)
    jd['f'] = jd[['a']] - 1
    assert jd.data['f'] == [0, 1], jd.data


@ tester.add()
def opTable():
    jd = defl.Table(simple)
    jd[['f']] = jd[['a']] - 1
    assert jd.data['f'] == [0, 1], jd.data


@ tester.add()
def differentID():
    jd = defl.Table(simple)
    jd2 = defl.Table(jd.data)
    assert jd.data is not jd2.data, jd.data


@ tester.add()
def differentID():
    jd = defl.Table(simple)
    jdA = defl.Table(simple)['a']
    jd['a'] / 2
    assert jdA is not jd['a']
    jd['a'] = jd['a'] / 2
    assert jdA is not jd['a']


@ tester.add()
def differentID():
    obj = object()
    d = {1: [obj, obj]}
    assert id(d) == id(d)
    assert d is d
    jd = defl.Table(d)
    assert d is not jd.data
    assert d[1] is not jd.data[1]
    assert jd.data[1][0] is obj
    assert jd.data[1][1] is obj


@ tester.add()
def differentID():
    obj = object()
    l = [[0, 1], [obj, obj]]
    jd = defl.Table(l)
    assert jd.data[0][0] == obj
    assert jd.data[1][0] == obj


@ dataclass(slots=True, kw_only=True, frozen=False)
class Ev:
    i: ClassVar = 0
    m: int = 0

    def __post_init__(_):
        _.m = Ev.i
        Ev.i += 1


def ev():
    return Ev()


@ tester.add()
def evaluate():
    l = [[0, 1], [ev, ev]]
    jd = defl.Table(l)
    jde = jd.evaluate()
    assert callable(jd.data[0][0])
    assert callable(jd.data[1][0])
    assert jde.data[0][0].m == 0
    assert jde.data[1][0].m == 1


log.info(tester.run())