memory-graph 0.3.30__py3-none-any.whl

memory_graph/node_linear.py

@@ -0,0 +1,100 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.node_base import Node_Base
+from memory_graph.sequence import Sequence1D
+
+import memory_graph.config_helpers as config_helpers
+
+class Node_Linear(Node_Base):
+    """
+    Node_Linear (subclass of Node_Base) is a node that represents a linear sequence 
+    of data used for most iterable type like list, tuple, set, etc.
+    """
+
+    def __init__(self, data, children=None):
+        """
+        Create a Node_Linear object. Use a Slicer to slice the children so the 
+        Node_Base will not get to big or have too many childeren in the graph.
+        """
+        super().__init__(data, Sequence1D(children))
+    
+    def has_references(self, nodes, slices):
+        """
+        Return if the node has references to other nodes.
+        """
+        for index in slices:
+            child_id = id(self.children[index])
+            if child_id in nodes:
+                child = nodes[child_id]
+                if not child.is_hidden_node():
+                    return True
+        return False
+
+    def is_vertical(self, nodes, slices, id_to_slices):
+        """
+        Return if the node is vertical or horizontal based on the orientation of the children.
+        """
+        vertical = config_helpers.get_vertical_orientation(self, None)
+        if vertical is None:
+            vertical = not self.has_references(nodes, slices)
+        return vertical
+
+    def fill_html_table(self, nodes, html_table, slices, id_to_slices):
+        """
+        Fill the html_table with the children of the Node_Base.
+        """
+        if slices is None:
+            return
+        if self.is_vertical(nodes, slices, id_to_slices):
+            self.fill_html_table_vertical(html_table, nodes, slices, id_to_slices)
+        else:
+            self.fill_html_table_horizontal(html_table, nodes, slices, id_to_slices)
+
+    def fill_html_table_vertical(self, html_table, nodes, slices, id_to_slices):
+        """
+        Helper function to fill the html_table with the children of the Node_Base in vertical orientation.
+        """
+        for index in slices.table_iter(self.children.size()):
+            if index>=0:
+                html_table.add_index(index)
+                child = self.children[index]
+                html_table.add_entry(self, nodes, child, id_to_slices, dashed=slices.is_dashed(index))
+                html_table.add_new_line()
+            else:
+                html_table.add_value('', border=0)
+                html_table.add_dots()
+                html_table.add_new_line()
+
+    def fill_html_table_horizontal(self, html_table, nodes, slices, id_to_slices):
+        """
+        Helper function to fill the html_table with the children of the Node_Base in horizontal orientation.
+        """
+        for index in slices.table_iter(self.children.size()):
+            if index>=0:
+                html_table.add_index(index)
+            else:
+                html_table.add_value('', border=0)
+        html_table.add_new_line()
+        for index in slices.table_iter(self.children.size()):
+            if index>=0:
+                child = self.children[index]
+                html_table.add_entry(self, nodes, child, id_to_slices, dashed=slices.is_dashed(index))
+            else:
+                html_table.add_dots()
+
+    def get_label(self, slices):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        type_name = self.get_type_name()
+        if slices is None:
+            return f'{type_name}'
+        size = self.get_children().size()
+        s = slices.get_slices()
+        if len(s) == 1:
+            if s[0][1] - s[0][0] == size:
+                return f'{type_name}'
+        return f'{type_name} {size}'
+        

memory_graph/node_table.py

@@ -0,0 +1,83 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.node_base import Node_Base
+from memory_graph.sequence import Sequence2D
+from memory_graph.list_view import List_View
+
+class Node_Table(Node_Base):
+    """
+    Node_Table (subclass of Node_Base) is a node that represents a 2D table of data used for 
+    example for Numpy arrays and Pandas DataFrames.
+    """
+
+    def __init__(self, data, children, data_width=None, row_names=None, col_names=None):
+        """
+        Create a Node_Table object. Use a Slicer to slice the children so the Node_Base 
+        will not get to big or have too many childeren in the graph.
+        """
+        self.row_names = row_names
+        self.col_names = col_names
+        if data_width is None:
+            super().__init__(data, Sequence2D(children))
+        else:
+            list_views = [List_View(children, i, i+data_width) for i in range(0,len(children),data_width)]
+            super().__init__(data, Sequence2D(list_views))
+
+    def add_index_or_name(self, html_table, index, names):
+        if not names is None and index < len(names):
+            html_table.add_value(names[index], rounded=1, border=1)
+        else:
+            html_table.add_index(index)
+
+    def fill_html_table(self, nodes, html_table, slices, id_to_slices):
+        """
+        Fill the html_table with the children of the Node_Base.
+        """
+        if slices is None or slices.is_empty():
+            return
+        children = self.children
+        children_size = children.size()
+        children_width = children_size[1]
+        col_slices = slices.get_col_slices()
+
+        # use column indices for header row
+        html_table.add_value('', border=0)
+        for coli in col_slices.table_iter(children_width):
+            if coli == -1:
+                html_table.add_value('', border=0)
+            else:
+                self.add_index_or_name(html_table, coli, self.col_names)
+        html_table.add_new_line()
+
+        # add remaing rows
+        first_col = True
+        for index in slices.table_iter(children_size):
+            rowi, coli = index
+            if first_col and not coli==-3:
+                first_col = False
+                self.add_index_or_name(html_table, rowi, self.row_names)
+            if coli == -1:
+                html_table.add_dots()
+            elif coli == -2:
+                html_table.add_new_line()
+                first_col = True
+            elif coli == -3:
+                html_table.add_new_line()
+                html_table.add_value('', border=0)
+                for _ in range (html_table.get_max_column()-1):
+                    html_table.add_dots()
+                html_table.add_new_line()
+                first_col = True
+            else:
+                child = children[index]
+                html_table.add_entry(self, nodes, child, id_to_slices, dashed=slices.is_dashed(index))
+
+    def get_label(self, slices):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        size = self.get_children().size()
+        return f'{self.get_type_name()} {size[0]}⨯{size[1]}'
+    

memory_graph/sequence.py

@@ -0,0 +1,111 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from abc import ABC, abstractmethod
+
+from memory_graph.slices import Slices1D, Slices2D
+import memory_graph.utils as utils
+
+class Sequence(ABC):
+
+    @abstractmethod
+    def is_empty(self):
+        pass
+
+    @abstractmethod
+    def size(self):
+        pass
+
+    @abstractmethod
+    def empty_slices(self):
+        pass
+
+    @abstractmethod
+    def slice(self, slicer):
+        pass
+
+    @abstractmethod
+    def indices_all(self):
+        pass
+
+    @abstractmethod
+    def __getitem__(self, index):
+        pass
+
+    @abstractmethod
+    def __setitem__(self, index, value):
+        pass
+
+class Sequence1D(Sequence):
+
+    def __init__(self, data):
+        self.data = utils.make_sliceable(data)
+
+    def __repr__(self):
+        return f'Sequence1D: {self.data}'
+    
+    def is_empty(self):
+        return len(self.data) == 0
+    
+    def size(self):
+        return len(self.data)
+    
+    def empty_slices(self):
+        return Slices1D()
+
+    def slice(self, slicer):
+        return slicer.get_slices( len(self.data) )
+
+    def indices_all(self):
+        for i in range(len(self.data)):
+            yield i
+
+    def __getitem__(self, index):
+        return self.data[index]
+    
+    def __setitem__(self, index, value):
+        self.data[index] = value
+
+class Sequence2D(Sequence):
+
+    def __init__(self, data):
+        self.data = utils.make_sliceable(data)
+
+    def __repr__(self):
+        return f'Sequence2D: {self.data}'
+    
+    def is_empty(self):
+        return len(self.data) == 0
+
+    def size(self):
+        l1, l2 = len(self.data), 0
+        if l1 > 0:
+            l2 = len(self.data[0])
+        return l1, l2
+    
+    def empty_slices(self):
+        return Slices2D()
+
+    def slice(self, slicer0):
+        if type(slicer0) is tuple:
+            slicer0, slicer1 = slicer0
+        else:
+            slicer1 = slicer0
+        slices0 = slicer0.get_slices( len(self.data) )
+        slices1 = slicer1.get_slices( len(self.data[0]) )
+        return Slices2D(slices0, slices1)
+
+    def indices_all(self):
+        len0 = len(self.data) 
+        if len0 > 0:
+            len1 = len(self.data[0])
+            for y in range(len0):
+                for x in range(len1):
+                    yield (y,x)
+
+    def __getitem__(self, index):
+        return self.data[index[0]][index[1]]
+
+    def __setitem__(self, index, value):
+        self.data[index[0]][index[1]] = value

memory_graph/slicer.py

@@ -0,0 +1,46 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.slices import Slices1D
+import memory_graph.utils as utils
+
+class Slicer:
+
+    def __init__(self, begin=None, end=None, middle=None, /) -> None:
+        self.begin = begin
+        self.end = end
+        self.middle = middle
+        if not self.middle is None:
+            self.end, self.middle = self.middle, self.end
+
+    def __repr__(self) -> str:
+        return f"Slicer({self.begin},{self.middle},{self.end})"
+
+    def get_slices(self, length):
+        slices1d = Slices1D()
+        if self.begin is None:
+            slices1d.add_slice([0, length])
+        else:
+            if isinstance(self.begin, float):
+                slices1d.add_slice([0, 
+                                  min(length,utils.my_round(length*self.begin))]) 
+            else:
+                slices1d.add_slice([0, 
+                                  min(length,self.begin)])
+            if not self.middle is None:
+                mid = length/2
+                if isinstance(self.middle, float):
+                    half = length*self.middle/2
+                else:
+                    half = self.middle/2
+                slices1d.add_slice([max(0,utils.my_round(mid-half)), 
+                                  min(length,utils.my_round(mid+half))])
+            if not self.end is None:
+                if isinstance(self.end, float):
+                    slices1d.add_slice([max(0,utils.my_round(length-length*self.end)),
+                                      length])
+                else:
+                    slices1d.add_slice([max(0,length-self.end),
+                                      length])
+        return slices1d

memory_graph/slices.py

@@ -0,0 +1,163 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from abc import ABC, abstractmethod
+
+import bisect
+import copy
+
+from memory_graph.slices_iterator import Slices_Iterator1D, Slices_Iterator2D
+from memory_graph.slices_table_iterator import Slices_Table_Iterator1D, Slices_Table_Iterator2D
+
+class Slices(ABC):
+
+    def __init__(self):
+        self.dashed = set()
+
+    def __repr__(self) -> str:
+        return f"dashed: {self.dashed}"
+
+    def is_dashed(self, index):
+        return index in self.dashed
+
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def has_index(self, index):
+        pass
+
+    @abstractmethod
+    def add_index(self, index):
+        pass
+
+    @abstractmethod
+    def table_iter(self, size):
+        pass
+
+    @abstractmethod
+    def is_empty(self):
+        pass
+
+class Slices1D(Slices):
+
+    def __init__(self, slices=None) -> None:
+        super().__init__()
+        self.slices = []
+        if not slices is None:
+            for i in slices:
+                self.add_slice(i)
+
+    def __repr__(self) -> str:
+        return f"Slices1D({self.slices}) "+super().__repr__()
+    
+    def get_iter(self,length):
+        return Slices_Iterator(self.slices,length)
+
+    def copy(self):
+        s = Slices1D()
+        s.slices = copy.deepcopy(self.slices)
+        s.dashed = copy.deepcopy(self.dashed)
+        return s
+
+    def get_slices(self):
+        return self.slices
+
+    def has_index(self, index):
+        for i in self.slices:
+            if i[0] <= index and index < i[1]:
+                return True
+        return False
+
+    def add_slice(self, begin_end, remove_interposed_dots=1):
+        i0, i1 = begin_end
+        if i1 <= i0:
+            return False
+        insert0 = bisect.bisect_right(self.slices, i0, key=lambda x: x[0])
+        insert1 = bisect.bisect_left (self.slices, i1, key=lambda x: x[1])
+        merge_begin, merge_end = False, False
+        if insert0 > 0:
+            if self.slices[insert0-1][1] >= (i0 - remove_interposed_dots):
+                merge_begin = True
+        if insert1 < len(self.slices):
+            if self.slices[insert1][0] <= (i1 + remove_interposed_dots):
+                merge_end = True
+        if merge_begin and merge_end:
+            if insert0 - insert1 == 1: # no slices changed
+                return False
+            self.slices[insert0-1][1] = self.slices[insert1][1]
+            del self.slices[insert0:insert1+1]
+        elif merge_begin:
+            self.slices[insert0-1][1] = max(self.slices[insert1-1][1], begin_end[1])
+            del self.slices[insert0:insert1]
+        elif merge_end:
+            self.slices[insert1][0] = min(self.slices[insert0][0], begin_end[0])
+            del self.slices[insert0:insert1]
+        else:
+            del self.slices[insert0:insert1]
+            self.slices.insert(insert0, begin_end)
+        return True
+    
+    def __iter__(self):
+        return Slices_Iterator1D(self)
+    
+    def has_index(self, index):
+        insert = bisect.bisect_right(self.slices, index, key=lambda x: x[0])
+        #print('insert:',insert,'index:',index,'slices:',self.slices)
+        if insert==0:
+            return False
+        i0, i1 = self.slices[insert-1]
+        return i0 <= index and index < i1
+
+    def add_index(self, index, dashed=False):
+        self.add_slice([index,index+1], 0)
+        if dashed:
+            self.dashed.add(index)
+    
+    def table_iter(self, size):
+        return Slices_Table_Iterator1D(self, size)
+    
+    def is_empty(self):
+        return len(self.slices) == 0
+
+class Slices2D(Slices):
+
+    def __init__(self, row_slices = None, col_slices= None) -> None:
+        super().__init__()
+        self.row_slices = Slices1D() if row_slices is None else row_slices
+        self.col_slices = Slices1D() if col_slices is None else col_slices
+
+    def __repr__(self):
+        s='Sices2D:\n'
+        s += 'row_slices:' + str(self.row_slices) + '\n'
+        s += 'col_slices:' + str(self.col_slices) + '\n'
+        s += super().__repr__() + '\n'
+        return s
+    
+    def get_row_slices(self):
+        return self.row_slices
+    
+    def get_col_slices(self):
+        return self.col_slices
+
+    def __iter__(self):
+        return Slices_Iterator2D(self)
+
+    def has_index(self, index):
+        i0,i1 = index
+        return self.row_slices.has_index(i0) and self.col_slices.has_index(i1)
+
+    def add_index(self, index, dashed=False):
+        i0,i1 = index
+        self.row_slices.add_slice([i0,i0+1], 0)
+        self.col_slices.add_slice([i1,i1+1], 0)
+        if dashed:
+            self.dashed.add((i0,i1))
+
+    def table_iter(self, size):
+        return Slices_Table_Iterator2D(self, size)
+
+    def is_empty(self):
+        return len(self.row_slices.slices) == 0

memory_graph/slices_iterator.py

@@ -0,0 +1,55 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+from abc import ABC, abstractmethod
+
+class Slices_Iterator(ABC):
+    
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def __next__(self):
+        pass
+
+class Slices_Iterator1D(Slices_Iterator):
+
+    def __init__(self, slices1d):
+        self.slices = slices1d
+        self.gen = self.generate()
+
+    def __iter__(self):
+        return self
+
+    def generate(self):
+        slices = self.slices.get_slices()
+        for si in range(len(slices)):
+            for i in range(slices[si][0], slices[si][1]):
+                yield i
+
+    def __next__(self):
+        return next(self.gen)
+    
+class Slices_Iterator2D(Slices_Iterator):
+
+    def __init__(self, slices2d):
+        self.slices = slices2d
+        self.gen = self.generate()
+
+    def __iter__(self):
+        return self
+
+    def generate(self):
+        row_slices = self.slices.get_row_slices().get_slices()
+        col_slices = self.slices.get_col_slices().get_slices()
+        for row_slice in row_slices:
+            for row_i in range(row_slice[0], row_slice[1]):
+                for col_slice in col_slices:
+                    for col_i in range(col_slice[0], col_slice[1]):
+                        yield (row_i, col_i)
+
+    def __next__(self):
+        return next(self.gen)

memory_graph/slices_table_iterator.py

@@ -0,0 +1,79 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from abc import ABC, abstractmethod
+
+class Slices_Table_Iterator(ABC):
+    
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def __next__(self):
+        pass
+
+class Slices_Table_Iterator1D(Slices_Table_Iterator):
+
+    def __init__(self, slices1d, size):
+        self.slices = slices1d
+        self.size = size
+        self.gen = self.generate()
+
+    def __iter__(self):
+        return self
+
+    def generate(self):
+        slices = self.slices.get_slices()
+        if len(slices) > 0 and slices[0][0] > 0:
+            yield -1
+        for slice in slices:
+            for i in range(slice[0], slice[1]):
+                yield i
+            if i < self.size-1:
+                yield -1
+
+    def __next__(self):
+        return next(self.gen)
+    
+class Slices_Table_Iterator2D(Slices_Table_Iterator):
+
+    def __init__(self, slices2d, size):
+        self.slices = slices2d
+        self.size = size
+        self.gen = self.generate()
+
+    def __iter__(self):
+        return self
+
+    def generate(self):
+        row_slices = self.slices.get_row_slices().get_slices()
+        col_slices = self.slices.get_col_slices().get_slices()
+        first_row_slice = True
+        for row_slice in row_slices:
+            if first_row_slice:
+                if len(row_slices) > 0 and row_slice[0] > 0:
+                    yield (-3, -3)
+                first_col_slice = False
+            else:
+                yield (-3, -3)
+            for row_i in range(row_slice[0], row_slice[1]):
+                first_col_slice = True
+                for col_slice in col_slices:
+                    if first_col_slice:
+                        if len(col_slices) > 0 and col_slice[0] > 0:
+                            yield (row_i, -1)
+                        first_col_slice = False
+                    else:
+                        yield (row_i, -1)  
+                    for col_i in range(col_slice[0], col_slice[1]):
+                        yield (row_i, col_i)
+                if col_i < self.size[1]-1:
+                    yield (row_i, -1)
+                yield (row_i, -2)
+        if len(row_slices)>0 and row_i < self.size[0]-1:
+            yield (row_i, -3)
+
+    def __next__(self):
+        return next(self.gen)