memory-graph 0.3.30__py3-none-any.whl

memory_graph/test.py

@@ -0,0 +1,245 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+""" Some test data to make memory graph of for test purposes. """
+import memory_graph.utils as utils
+import memory_graph.config as config
+
+import numpy as np
+import pandas as pd
+import memory_graph.extension_numpy
+import memory_graph.extension_pandas
+
+from memory_graph.node_table import Node_Table
+
+import random
+
+def test_singular(fun):
+    data = 100
+    fun(data)
+
+def test_linear(fun):
+    data = [None, True, 1, 2.2, complex(3,4), 'hello this is a very long string that should be cut off at some point.']
+    fun(data)
+
+def test_linears(fun):
+    data = [(1,2), [3,4], {5,6}, frozenset((7,8)), {9:'nine', 10:'ten'} , bytes('11', 'utf-8'), bytearray('12', 'utf-8')]
+    data.append( [i for i in range(20)] )
+    fun(data)
+
+def test_colors(fun):
+    data1 = [None, True, 1, 2.2, complex(3,4), 'hello']
+    class My_Class:
+        class_var = 1
+        def __init__(self):
+            self.var=2
+    data2 = [(1,2), [3,4], {5,6}, frozenset((7,8)), {9:'9', 10:'10'} , bytes('11', 'utf-8'), bytearray('12', 'utf-8'), My_Class(), My_Class]
+    restore = config.not_node_types.copy()
+    config.not_node_types.clear()
+    fun([data1, data2])
+    config.not_node_types = restore
+
+def test_empty_linear(fun):
+    data = [tuple(), list(), set(), frozenset(), dict() , bytes(), bytearray()]
+    fun(data)
+
+def test_nested_list(fun):
+    data = utils.nested_list([2,2,2,2,2,2,2])
+    fun(data)
+
+def test_key_value(fun):
+    data1 = {1:'a', 2:'b', 3:'c', 4:'d'}
+    data2 = {10:100, 20:200, 30:300, 40:400}
+    data2[50] = ('c','c')
+    data2[60] = data1
+    data = {'first':data1, 'second':data2}
+    fun(data)
+
+def test_class(fun):
+    class My_Class1:
+        def __init__(self):
+            self.foo1=10
+            self.bar1=20
+    class My_Class2:
+        def __init__(self):
+            self.foo2=10
+            self.bar2=20
+    data = [My_Class1(), My_Class2()]
+    fun(data)
+
+def test_class_vars(fun):
+    class My_Class1:
+        class_var1 = 'a'
+        class_var2 = 'b'
+        def __init__(self):
+            self.var1=10
+            self.var2=20
+        def my_method(self):
+            return 100
+    m = My_Class1()
+    data = locals()
+    fun(data)
+
+def test_share_tuple(fun):
+    class My_Class:
+        def __init__(self):
+            self.a=1
+    data = [('a',1), ('a',1), {'a':1}, {'a':1}, My_Class(),My_Class()]
+    fun(data)
+
+def test_share_children(fun):
+    a=['a']
+    b=['b']
+    c=['c']
+    d=['d']
+    data = [ [a,b,c,], [a,c,d] ]
+    fun(data)
+
+def test_list_split(fun):
+    data = [ list(range(i)) for i in range(50) ]
+    fun(data)
+
+def test_key_value_split(fun):
+    data = { i:i*10 for i in range(1,20)}
+    fun(data)
+
+def test_table(fun):
+    class My_Table:
+        def __init__(self,size):
+            self.size=size
+            self.data = [i for i in range(size[0]*size[1])]
+    data = My_Table((15,15))
+    config.type_to_color[My_Table] = 'plum1'
+    config.type_to_node[My_Table] = lambda data: (
+            Node_Table(data, data.data , data.size[0], 
+                        #column_names = [f'col{i}' for i in range(data.size[1])],
+                        #row_names = [f'row{i}' for i in range(data.size[0])] 
+            )
+    )
+    fun(data)
+
+def test_numpy(fun):
+    a = np.array([1, 2, 3])
+    print(a, type(a))
+    data = [
+            np.array([1, 2, 3]),
+            np.matrix([[i*3+j for j in range(20)] for i in range(3)]), 
+            np.random.rand(20,20)
+            ]
+    #data = np.matrix('1 2; 3 4')
+    fun(data)
+
+def test_pandas(fun):
+    data = [
+            pd.DataFrame({  "calories": [420, 380, 390],
+                            "duration": [50, 40, 45]
+                        }),
+
+            pd.DataFrame({  'Name'   : [ 'Tom', 'Anna', 'Steve', 'Lisa'],
+                            'Age'    : [    28,     34,      29,     42],
+                            'Length' : [  1.70,   1.66,    1.82,   1.73] },
+                            index=['one', 'two', 'three', 'four']),
+
+            pd.Series( [i for i in range(20)] )
+            ]
+    fun(data)
+
+def example_function(a):
+    return a*10
+
+class Example_Class:
+    class_var1 = 100
+    class_var2 = 200
+    def __init__(self):
+        self.a=1
+        self.b=2
+    def example_method(self):
+        return self.a+self.b
+
+def test_function():
+    return 10
+
+def test_different_types(fun):
+    object = Example_Class()
+    object_type = type(object)
+    func = test_function
+    func_type = type(func)
+    method = Example_Class.example_method
+    method_type = type(method)
+    lambda_fun = lambda x: x*10
+    lambda_fun_type = type(lambda_fun)
+    data = memory_graph.stack()
+    fun(data)
+
+
+class Node:
+    shared_data = [1,2,3]
+
+    def __init__(self, value):
+        self.smaller = None
+        self.shared  = Node.shared_data
+        self.value   = value
+        self.larger  = None
+
+class BinTree:
+
+    def __init__(self):
+        self.root = None
+
+    def insert_recursive(self, node, value):
+        nn = None
+        if value < node.value:
+            if node.smaller is None:
+                nn = Node(value)
+                node.smaller = nn
+            else:
+                nn = self.insert_recursive(node.smaller, value)
+        else:
+            if node.larger is None:
+                nn = Node(value)
+                node.larger = nn
+            else:
+                nn = self.insert_recursive(node.larger, value)
+        return nn
+
+    def insert(self, value):
+        nn = None
+        if self.root is None:
+            nn = Node(value)
+            self.root = nn
+        else:
+            nn = self.insert_recursive(self.root, value)
+        return nn
+
+def test_missing_edges(fun):
+    random.seed(0)
+    config.max_graph_depth = 7
+    config.max_missing_edges = 5
+    tree = BinTree()
+    last_node = None
+    n = 200
+    for i in range(n):
+        last_node = tree.insert(random.randint(0,n*10))
+    fun( memory_graph.stack() )
+
+def test_all(fun):
+    pass
+    test_singular(fun)
+    test_linear(fun)
+    test_linears(fun)
+    test_colors(fun)
+    test_empty_linear(fun)
+    test_nested_list(fun)
+    test_key_value(fun)
+    test_class(fun)
+    test_class_vars(fun)
+    test_share_tuple(fun)
+    test_share_children(fun)
+    test_list_split(fun)
+    test_key_value_split(fun)
+    test_table(fun)
+    test_numpy(fun)
+    test_pandas(fun)
+    test_different_types(fun)
+    test_missing_edges(fun)

memory_graph/test_max_graph_depth.py

@@ -0,0 +1,27 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+def build_nested_list(depth = 15):
+    first = [1,2]
+    last = first
+    if depth>0:
+        first2, last = build_nested_list(depth-1)
+        first.append(first2)
+    return first, last
+
+first,last = build_nested_list(15)
+for i in range(20):
+    last.append('X')
+
+child = ('who', 'are', 'my', 'parents?')
+last[4] = child
+last[5] = child
+last[6] = child
+last[7] = child
+last[8] = child
+
+mg.show([first,child])
+#mg.show([first])

memory_graph/test_memory_graph.py

@@ -0,0 +1,15 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph
+
+import memory_graph.test as test
+
+if __name__ == '__main__':
+    test_fun_count = 0
+    def test_fun(data):
+        global test_fun_count
+        memory_graph.render(data, f'test_graph{test_fun_count}.png')
+        test_fun_count += 1
+    test.test_all(test_fun)

memory_graph/test_memory_to_nodes.py

@@ -0,0 +1,15 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+import memory_graph.memory_to_nodes as memory_to_nodes
+import memory_graph.config_helpers as config_helper
+
+config_helper.set_config()
+
+l1 = [1,2]
+l2 = [3,4]
+data = [l1,l2,l1,[5,l2]]
+nodes = memory_to_nodes.memory_to_nodes(data)
+#print(nodes)

memory_graph/test_sequence.py

@@ -0,0 +1,37 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.sequence import Sequence1D, Sequence2D
+from memory_graph.slicer import Slicer
+
+def status(index):
+    if type(index) == tuple:
+        return index[0]
+    return index
+
+def test_slicing(sequence, slicer):
+    print(sequence)
+    print(slicer)
+    for i in sequence.indices_all():
+        print(i, sequence[i])
+    slices = sequence.slice(slicer)
+    print('slices:',slices)
+    for index in slices:
+        print(index, ':', sequence[index])
+    for index in slices.table_iter(sequence.size()):
+        print(f'{index}: {sequence[index] if status(index)>=0 else None}')
+
+def test_sequence():
+    sequence = Sequence1D([i for i in range(8)])
+    slicer = Slicer(2,3)
+    test_slicing(sequence, slicer)
+
+    width = 5
+    height = 6
+    sequence = Sequence2D([[x+y*width for x in range(width)] for y in range(height)])
+    slicer = (Slicer(1,2), Slicer(2,1))
+    test_slicing(sequence, slicer)
+
+if __name__ == '__main__':
+    test_sequence()

memory_graph/test_slicer.py

@@ -0,0 +1,50 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.slicer import Slicer
+
+def test_slicer():
+    slicer = Slicer(0.1, 0.2, 0.3)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10], [40, 60], [70, 100]], "Slicer error"
+
+    slicer = Slicer(10, 20, 30)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10], [40, 60], [70, 100]], "Slicer error"
+
+    slicer = Slicer(0.1, 0.3)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10], [70, 100]], "Slicer error"
+
+    slicer = Slicer(10, 30)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10], [70, 100]], "Slicer error"
+
+    slicer = Slicer(0.1)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10]], "Slicer error"
+
+    slicer = Slicer(10)
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 10]], "Slicer error"
+
+    slicer = Slicer()
+    slices = slicer.get_slices(100)
+    assert slices.get_slices() == [[0, 100]], "Slicer error"
+
+    slicer = Slicer(2,2)
+    slices = slicer.get_slices(0)
+    assert slices.get_slices() == [], "Slicer error"
+
+    slicer = Slicer(2,2)
+    slices = slicer.get_slices(5)
+    assert slices.get_slices() == [[0,5]], "Slicer error"
+
+    slicer = Slicer(2,2)
+    slices = slicer.get_slices(6)
+    assert slices.get_slices() == [[0,2],[4,6]], "Slicer error"
+
+if __name__ == '__main__':
+    test_slicer()
+    print('Slicer test passed')

memory_graph/test_slices.py

@@ -0,0 +1,91 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+from memory_graph.slices import Slices1D, Slices2D
+
+def test_slices1d():
+    test = Slices1D( [[10,20], [30,40], [60,70], [80,90]] )
+    slices = test.copy()
+    slices.add_slice([21,79])
+    assert slices.get_slices() == [[10,90]], "Slice error: merging begin and end"
+
+    slices = test.copy()
+    slices.add_slice([31,39])
+    assert slices.get_slices() == [[10,20], [30,40], [60,70], [80,90]], "Slice error: merging begin and end"
+
+    slices = test.copy()
+    slices.add_slice([15,50])
+    assert slices.get_slices() == [[10,50], [60,70], [80,90]], "Slice error: merging begin"
+
+    slices = test.copy()
+    slices.add_slice([15,65])
+    assert slices.get_slices() == [[10,70], [80,90]], "Slice error: merging begin"
+
+    slices = test.copy()
+    slices.add_slice([35,45])
+    assert slices.get_slices() == [[10,20], [30,45], [60,70], [80,90]], "Slice error: merging begin"
+
+    slices = test.copy()
+    slices.add_slice([25,65])
+    assert slices.get_slices() == [[10,20], [25,70], [80,90]], "Slice error: merging end"
+    
+    slices = test.copy()
+    slices.add_slice([15,65])
+    assert slices.get_slices() == [[10,70], [80,90]], "Slice error: merging end"
+
+    slices = test.copy()
+    slices.add_slice([55,65])
+    assert slices.get_slices() == [[10,20], [30,40], [55,70], [80,90]], "Slice error: merging end"
+
+    slices = test.copy()
+    slices.add_slice([25,75])
+    assert slices.get_slices() == [[10,20], [25,75], [80,90]], "Slice error: merging none"
+
+    slices = test.copy()
+    slices.add_slice([5,6])
+    assert slices.get_slices() == [[5,6], [10,20], [30,40], [60,70], [80,90]], "Slice error: merging none"
+
+    slices = test.copy()
+    slices.add_slice([95,96])
+    assert slices.get_slices() == [[10,20], [30,40], [60,70], [80,90], [95,96]], "Slice error: merging none"
+
+    slices = test.copy()
+    assert not slices.add_slice([10,11])
+    assert not slices.add_slice([19,20])
+    assert not slices.add_slice([30,31])
+    assert not slices.add_slice([39,40])
+    assert not slices.add_slice([65,66])
+    assert slices.add_slice([9,10])
+    assert slices.add_slice([20,21])
+    assert slices.add_slice([28,29])
+    assert slices.add_slice([41,42])
+    assert slices.add_slice([75,76])
+    assert slices.add_slice([100,200])
+    
+    test = Slices1D( [ [i,i+2] for i in range(0,30,4)] )
+    #print('test:',test)
+    for index in range(30):
+        #print('index:',index, 'has_index:',test.has_index(index))
+        assert test.has_index(index) == ((index//2) % 2 == 0), f"Error: {index}"
+
+def test_slices2d():
+    from memory_graph.slices import Slices
+    slices2d = Slices2D( Slices1D([[20,30]]),
+                         Slices1D([[20,30]])
+    )
+    
+    slices2d.add_index((19,19))
+    slices2d.add_index((31,31))
+    print(slices2d)
+    slices2d.add_index((18,19))
+    print(slices2d)
+    slices2d.add_index((19,18))
+    slices2d.add_index((30,30))
+    print(slices2d)
+
+if __name__ == "__main__":
+    test_slices1d()
+    test_slices2d()
+    print("Slices: All tests pass")

memory_graph/test_slices_iterator.py

@@ -0,0 +1,28 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+from memory_graph.slices_iterator import Slices_Iterator1D, Slices_Iterator2D
+from memory_graph.slices import Slices1D, Slices2D
+
+def test_slices_iterator1d():
+    slices1d = Slices1D( [[10,20], [30,40], [60,70], [80,90]] )
+    iter = Slices_Iterator1D(slices1d)
+    for i in iter:
+        print(i)
+    assert list(Slices_Iterator1D(slices1d)) == [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89], "Slices_Iterator: Error in iteration"
+
+def test_slices_iterator2d():
+    slices2d = Slices2D( Slices1D( [[10,12], [20,22]] ),
+                         Slices1D( [[10,12], [30,32]] )  )
+    iter = Slices_Iterator2D(slices2d)
+    for i in iter:
+        print(i)
+    assert list(Slices_Iterator2D(slices2d)) == [(10, 10), (10, 11), (10, 30), (10, 31), (11, 10), (11, 11), (11, 30), (11, 31), (20, 10), (20, 11), (20, 30), (20, 31), (21, 10), (21, 11), (21, 30), (21, 31)]
+
+
+if __name__ == '__main__':
+    test_slices_iterator1d()
+    test_slices_iterator2d()
+    print("Slices_Iterator: All tests pass")

memory_graph/utils.py

@@ -0,0 +1,105 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import math 
+import types
+
+def has_dict_attributes(value):
+    """ Returns 'True' if 'value' has a '__dict__' attribute. """
+    return hasattr(value,"__dict__")
+
+def get_dict_attributes(value):
+    """ Returns the items of the '__dict__' attribute of 'value'."""
+    return getattr(value,"__dict__")
+
+def is_function(obj):
+    if isinstance(obj, types.FunctionType) or isinstance(obj, types.MethodType):
+        return True
+    return type(obj).__name__ in {'method_descriptor', 'builtin_function_or_method', 'getset_descriptor', 'classmethod_descriptor'}
+
+def filter_dict(dictionary):
+    """ Filters out the unwanted dict attributes. """
+    if '__name__' in dictionary: # only filter stack frames, for example locals()
+        return [
+            (k,v) for k, v in dictionary.items() if
+            not (type(k) is str and k.startswith('__')) and
+            not isinstance(v,types.ModuleType) and
+            not is_function(v)
+                ]
+    return  [
+            (k,v) for k, v in dictionary.items() if
+            not (type(k) is str and k.startswith('__'))
+            ]
+
+def filter_type_attributes(tuples):
+    """ Filters out the unwanted type attributes (class/static methods). """
+    return [
+        (k,v) for k, v in tuples if
+        not (type(k) is str and k.startswith('__')) and
+        not type(v) in {classmethod, staticmethod} and
+        not callable(v)
+            ]
+
+def make_sliceable(data):
+    """ Returns a sliceble version of data, convert to list if not yet sliceble. """
+    try:
+        data[0:0]
+        return data
+    except TypeError:
+        return list(data)
+
+def is_finite_iterable(data):
+    """ Returns 'True' if 'data' is finite iterable. """
+    try:
+        iter(data) # iterable
+        len(data)  # and not infinite (not a strong test, but what else?)
+        return True
+    except TypeError:
+        return False
+    
+def get_type_name(data):
+    """ Returns the name of the type of 'data'. """
+    return type(data).__name__
+    
+def nested_list(sizes, i=0, value=[0]):
+    """ Returns a nested list with the given 'sizes' for test purposes. """
+    if i == len(sizes)-1:
+        data = []
+        for _ in range(sizes[i]):
+            data.append( value[0] )
+            value[0]+=1
+    else:
+        data = []
+        for size in range(sizes[i]):
+            data.append( nested_list(sizes,i+1) )
+    return data
+
+def my_round(value):
+    """ Rounds the value to the nearest integer rounding '.5' up consistantly. """
+    return math.floor(value + 0.5)
+
+def generator_has_data(generator):
+    """ Returns 'True' if the generator has data. """
+    try:
+        next(generator)
+        return True
+    except StopIteration:
+        return False
+
+def take_through(condition, iterable):
+    for i in iterable:
+        yield i
+        if condition(i):
+            return
+
+def take_after(condition, iterable):
+    taking = False
+    for i in iterable:
+        if taking:
+            yield i
+        elif condition(i):
+            taking = True
+
+if __name__ == '__main__':
+    print( nested_list([4,3,2]) )