memory-graph 0.3.30__py3-none-any.whl

memory_graph/html_table.py

@@ -0,0 +1,137 @@
+# 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 
+import memory_graph.node_base
+import memory_graph.config as config
+import html
+
+def html_table_frame(s, border, color, spacing=5):
+    """ Helper function to add the HTML table frame to the string s setting the 'border' and 'color'. """
+    return (f'<\n<TABLE BORDER="{border}" CELLBORDER="1" CELLSPACING="{spacing}" CELLPADDING="0" BGCOLOR="{color}" PORT="table">\n    <TR>' +
+            s + '</TR>\n</TABLE>\n>')
+
+def format_string(s):
+    """ Helper function to format the string s to be shown in the graph. Setting the max_string_length and escaping html characters. """
+    s = config.to_string(s)
+    s = (s[:config.max_string_length] + '...') if len(s) > config.max_string_length else s
+    return html.escape(s)
+
+class HTML_Table:
+    """
+    The HTML_Table class is used to create a table of data that can be visualized in the graph.
+    """
+    
+    def __init__(self):
+        """
+        Create an HTML_Table object.
+        """
+        self.html = ''
+        self.add_new_line_flag = False
+        self.is_empty = True
+        self.col_count = 0
+        self.row_count = 0
+        self.ref_count = 0
+        self.max_col_count = 0
+        self.edges = []
+
+    def __repr__(self):
+        """ Get the string representation of the HTML_Table object. """
+        return self.html
+
+    def add_new_line(self):
+        """ Set the 'add_new_line_flag' to add a new line to the table when adding the next table element. """
+        self.add_new_line_flag = True
+        self.row_count += 1
+        if self.col_count > self.max_col_count:
+            self.max_col_count = self.col_count
+        self.col_count = 0
+
+    def check_add_new_line(self):
+        """ Check if a new line should be added to the table, and if so add it and sets the 'add_new_line_flag' to False."""
+        if self.add_new_line_flag:
+            self.html += '</TR>\n    <TR>'
+            self.add_new_line_flag = False
+
+    def add_string(self, s, border=0):
+        """ Add a string s to the table. """
+        self.html += f'<TD BORDER="{border}">'+format_string(s)+'</TD>'
+        self.is_empty = False
+
+    def add_index(self, s):
+        """ Add an index s to the table. """
+        self.check_add_new_line()
+        self.html += f'<TD BORDER="0"><font color="#505050">{str(s)}</font></TD>'
+        self.col_count += 1
+
+    def add_entry(self, node, nodes, child, id_to_slices, rounded=False, border=1, dashed=False):
+        """ Add child to the table either as reference if it is a Node_Base or as a value otherwise. """
+        #print('child:', child)
+        child_id = id(child)
+        if child_id in nodes:
+            child = nodes[child_id] 
+            if child_id in id_to_slices:
+                self.add_reference(node, child, rounded, border, dashed)
+            else:
+                self.add_value(config.graph_cut_symbol, rounded, border)
+        else:
+            self.add_value(child, rounded, border)
+
+    def add_value(self, s, rounded=False, border=1):
+        """ Helper function to add a value s to the table. """
+        self.check_add_new_line()
+        r = ' STYLE="ROUNDED"' if rounded else ''
+        self.html += f'<TD BORDER="{border}"{r}> {format_string(s)} </TD>'
+        self.col_count += 1
+
+    def add_reference(self, node, child, rounded=False, border=1, dashed=False):
+        """ Helper function to add a reference to the table. """
+        self.check_add_new_line()
+        r = ' STYLE="ROUNDED"' if rounded else ''
+        self.html += f'<TD BORDER="{border}" PORT="ref{self.ref_count}"{r}> </TD>'
+        self.edges.append( (f'{node.get_name()}:ref{self.ref_count}',
+                            child.get_name(), dashed) )
+        self.ref_count += 1
+        self.col_count += 1
+
+    def add_dots(self, rounded=False, border=1):
+        """ Helper function to add dots to the table. """
+        self.check_add_new_line()
+        r = 'STYLE="ROUNDED"' if rounded else ''
+        self.html += f'<TD BORDER="{border}" {r}>...</TD>'
+        self.col_count += 1
+
+    def to_string(self, border=1, color='white'):
+        """ Construct the HTML table string with the 'border' and 'color' settings. """
+        if self.col_count == 0 and self.row_count == 0:
+            if self.is_empty:
+                self.add_string(' ')
+            return html_table_frame(self.html, border, color, spacing=0)
+        return html_table_frame(self.html, border, color)
+    
+    def get_column(self):
+        """ Get the number of columns in the table. """
+        return self.col_count
+    
+    def get_max_column(self):
+        """ Get the maximum value of the number of columns of rows in the table. """
+        return self.max_col_count
+    
+    def get_row(self):
+        """ Get the number of rows in the table. """
+        return self.row_count
+
+    def get_edges(self):
+        """ Get the edges that need to be added to connect the table to other tables in the graph. """
+        return self.edges
+
+if __name__ == '__main__':
+    table = HTML_Table()
+    rows = 4
+    columns = 5
+    for r in range(rows):
+        for c in range(columns):
+            table.add_value(f'{c},{r}')
+        table.add_new_line()
+    print(table.to_string())

memory_graph/list_view.py

@@ -0,0 +1,57 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+class List_View:
+    def __init__(self, base_list, begin, end):
+        self.base_list = base_list
+        self.begin = max(0, begin)
+        self.end = min(end, len(base_list))
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            # Calculate new begin and end indices within the bounds of the current view
+            start, stop, step = index.indices(self.end - self.begin)
+            if step != 1:
+                raise ValueError("List_View does not support slices with steps other than 1")
+            # Adjust the indices relative to the base list
+            new_start = self.begin + start
+            new_end = self.begin + stop
+            return List_View(self.base_list, new_start, new_end)
+        elif isinstance(index, int):
+            if index < 0 or index >= (self.end - self.begin):
+                raise IndexError("list index out of range")
+            return self.base_list[self.begin + index]
+        else:
+            raise TypeError("Invalid index type")
+
+    def __setitem__(self, index, value):
+        if index < 0 or index >= (self.end - self.begin):
+            raise IndexError("list index out of range")
+        self.base_list[self.begin + index] = value
+
+    def __len__(self):
+        return self.end - self.begin
+
+    def __iter__(self):
+        for i in range(self.begin, self.end):
+            yield self.base_list[i]
+
+    def __repr__(self):
+        return f"List_View({self.base_list[self.begin:self.end]})"
+
+def test_list_vew():
+    original_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    list_view = List_View(original_list, 3, 8)
+    print(list_view)  # Output: List_View([3, 4, 5, 6, 7])
+    print(list_view[1:4])  # Output: List_View([4, 5, 6])
+    # 2D array
+    n = 4
+    data = [i for i in range(n*n)]
+    list_views = [List_View(data, i, i+n) for i in range(0,len(data),n)]
+    for row in list_views:
+        print(row)
+
+if __name__ == "__main__":
+    test_list_vew()

memory_graph/memory_to_nodes.py

@@ -0,0 +1,200 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from memory_graph.node_leaf import Node_Leaf
+from memory_graph.node_linear import Node_Linear
+from memory_graph.node_key_value import Node_Key_Value
+
+import memory_graph.utils as utils    
+import memory_graph.config as config
+
+import graphviz
+
+def read_nodes(data):
+
+    def data_to_node(data_type, data):
+        if data_type in config.type_to_node: # for predefined types
+            return config.type_to_node[data_type](data)
+        elif utils.has_dict_attributes(data): # for user defined classes
+            return Node_Key_Value(data, utils.filter_dict(utils.get_dict_attributes(data)) )
+        elif utils.is_finite_iterable(data): # for lists, tuples, sets, ...
+            return Node_Linear(data, data)
+        else:
+            return Node_Leaf(data, data)
+
+    def memory_to_nodes_recursive(nodes, data, parent, parent_index):
+        data_type = type(data)
+        if not data_type in config.not_node_types or parent is None:
+            data_id = id(data)
+            if data_id in nodes:
+                node = nodes[data_id]
+            else:
+                node = data_to_node(data_type, data)
+                nodes[data_id] = node
+                for index in node.get_children().indices_all():
+                    child = node.get_children()[index]
+                    memory_to_nodes_recursive(nodes, child, node, index)
+            if not parent is None:
+                node.add_parent_index(parent, parent_index)
+
+    nodes = {}
+    memory_to_nodes_recursive(nodes, data, None, None)
+    root_id = id(data)
+    return nodes, root_id
+
+# --------------------------------------------------------------------------------------------
+
+def get_max_type_depth(node_id, node):
+    if node_id in config.type_to_depth:
+        return config.type_to_depth[node_id]
+    elif node.get_type() in config.type_to_depth:
+        return config.type_to_depth[node.get_type()]
+    return None
+
+def slice_nodes(nodes, root_id, max_graph_depth):
+
+    def slice_nodes_recursive(nodes, node_id, id_to_slices, max_graph_depth):
+        if max_graph_depth == 0 or node_id in id_to_slices:
+            return
+        if node_id in nodes:
+            node = nodes[node_id]
+            children = node.get_children()
+            if children.is_empty():
+                id_to_slices[node_id] = None
+            else:
+                slicer = node.get_slicer()
+                slices = children.slice(slicer)
+                id_to_slices[node_id] = slices
+                if not node.is_hidden_node():
+                    max_graph_depth -= 1
+                max_type_depth = get_max_type_depth(node_id, node)
+                if max_type_depth:
+                    max_graph_depth = min(max_type_depth, max_graph_depth)
+                for index in slices:
+                    slice_nodes_recursive(nodes, id(children[index]), id_to_slices, max_graph_depth)
+    id_to_slices = {}
+    slice_nodes_recursive(nodes, root_id, id_to_slices, max_graph_depth)
+    return id_to_slices
+
+# --------------------------------------------------------------------------------------------
+
+def add_parent_indices(nodes, type_to_parent_indices, id_to_slices, max_missing_edges):
+    #print('add_parent_indices type_to_parent_indices:',type_to_parent_indices)
+    for _, parent_indices in type_to_parent_indices.items():
+        dashed = len(parent_indices) > max_missing_edges
+        for parent, index in parent_indices[0:max_missing_edges]:
+            new_parent = False
+            parent_id = parent.get_id()
+            if not parent_id in id_to_slices:
+                new_parent = True
+                id_to_slices[parent_id] = parent.get_children().empty_slices()
+            slices = id_to_slices[parent_id]
+            slices.add_index(index, dashed=dashed)
+            if new_parent:
+                add_indices_to_parents(nodes, parent_id, id_to_slices, max_missing_edges)
+
+def add_indices_to_parents(nodes, node_id, id_to_slices, max_missing_edges):
+    #print('add_indices_to_parents node_id:',node_id)
+    type_to_parent_indices = {}
+    parent_indices = nodes[node_id].get_parent_indices()
+    for parent, indices in parent_indices.items():
+        if parent is None:
+            continue
+        parent_type = parent.get_type()
+        parent_id = parent.get_id()
+        if (parent_type in type_to_parent_indices and 
+            len(type_to_parent_indices[parent_type]) > max_missing_edges): # early stop
+            continue
+        parent_slices = None
+        if parent_id in id_to_slices:
+            parent_slices = id_to_slices[parent_id]
+        for index in indices:
+            if parent_slices is None or not parent_slices.has_index(index):
+                if not parent_type in type_to_parent_indices:
+                    type_to_parent_indices[parent_type] = []
+                parent_indices = type_to_parent_indices[parent_type]
+                if len(parent_indices) > max_missing_edges:
+                    break
+                else:
+                    parent_indices.append((parent, index))
+    add_parent_indices(nodes, type_to_parent_indices, id_to_slices, max_missing_edges)
+
+def add_missing_edges(nodes, id_to_slices, max_missing_edges=3):
+    old_id_to_slices_keys = set(id_to_slices.keys())
+    for node_id in old_id_to_slices_keys:
+        add_indices_to_parents(nodes, node_id, id_to_slices, max_missing_edges)
+    return id_to_slices
+
+# --------------------------------------------------------------------------------------------
+
+import memory_graph.config_helpers as config_helpers
+
+def create_depth_of_nodes(nodes, nodes_at_depth):
+    depth_of_nodes = {}
+    for node_id, depth in nodes_at_depth.items():
+        node = nodes[node_id]
+        if node_id in nodes and not node.is_hidden_node():
+            if not depth in depth_of_nodes:
+                depth_of_nodes[depth] = []
+            depth_of_nodes[depth].append(node)
+    return depth_of_nodes
+
+def add_subgraph(graphviz_graph, nodes_to_subgraph):
+    new_node_names = [node.get_name() for node in nodes_to_subgraph]
+    if len(new_node_names) > 1:
+        graphviz_graph.body.append('subgraph { rank=same; '+ ' -> '.join(new_node_names) + '[weight='+str(config.graph_stability)+', style=invis]; }\n')
+
+def add_to_graphviz_graph(graphviz_graph, nodes, node, slices, id_to_slices, subgraphed_nodes, depth):
+    html_table = node.get_html_table(nodes, slices, id_to_slices)
+    edges = html_table.get_edges()
+    color = config_helpers.get_color(node)
+    border = 3 if node.is_root() else 1
+    graphviz_graph.node(node.get_name(),
+                        html_table.to_string(border, color),
+                        xlabel=node.get_label(slices))
+    # ------------ edges
+    for parent,child,dashed in edges:
+        graphviz_graph.edge(parent, child+':table', style='dashed' if dashed else 'solid')
+
+def build_graph_depth_first(graphviz_graph, nodes,  node_id, id_to_slices, nodes_at_depth, subgraphed_nodes, depth):
+    if node_id in id_to_slices:
+        if node_id in nodes_at_depth:
+            return
+        nodes_at_depth[node_id] = depth
+        node = nodes[node_id]
+        children = node.get_children()
+        slices = None
+        if node_id in id_to_slices:
+            slices = id_to_slices[node_id]
+            if not slices is None:
+                for index in slices:
+                    child_id = id(children[index])
+                    build_graph_depth_first(graphviz_graph, nodes, child_id, id_to_slices, nodes_at_depth, subgraphed_nodes, depth+1)
+        if not node.is_hidden_node():
+            add_to_graphviz_graph(graphviz_graph, nodes, node, slices, id_to_slices, subgraphed_nodes, depth)
+
+def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
+    nodes_at_depth = {}
+    build_graph_depth_first(graphviz_graph, nodes, root_id, id_to_slices, nodes_at_depth, set(), 0)
+    depth_of_nodes = create_depth_of_nodes(nodes, nodes_at_depth)
+    #print('nodes_at_depth:',nodes_at_depth,'depth_of_nodes:', depth_of_nodes)
+    for depth, depth_nodes in depth_of_nodes.items():
+        add_subgraph(graphviz_graph, depth_nodes)
+
+def memory_to_nodes(data):
+    nodes, root_id = read_nodes(data)
+    #print('nodes:',nodes,'root_id:',root_id)
+    id_to_slices = slice_nodes(nodes, root_id, config.max_graph_depth)
+    #print('id_to_slices:',id_to_slices)
+    id_to_slices = add_missing_edges(nodes, id_to_slices, config.max_missing_edges)
+    #print('id_to_slices:',id_to_slices)
+    graphviz_graph_attr = {}
+    graphviz_node_attr = {'shape':'plaintext'}
+    graphviz_edge_attr = {}
+    graphviz_graph=graphviz.Digraph('memory_graph',
+                                    graph_attr=graphviz_graph_attr,
+                                    node_attr=graphviz_node_attr,
+                                    edge_attr=graphviz_edge_attr)
+    build_graph(graphviz_graph, nodes, root_id, id_to_slices)
+    return graphviz_graph

memory_graph/node_base.py

@@ -0,0 +1,136 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph.utils as utils
+import memory_graph.config as config
+import memory_graph.config_helpers as config_helpers
+from memory_graph.sequence import Sequence1D
+
+from abc import ABC, abstractmethod
+
+class Node_Base(ABC):
+    """
+    Node_Base represents a node in the memory graph. This base class has different subclasses for different types of nodes.
+    """
+    
+    def __init__(self, data, children=None):
+        """
+        Create a Node_Base object.
+        """
+        self.data = data
+        self.children = Sequence1D([]) if children is None else children
+        self.parent_indices = {}
+
+    def __repr__(self):
+        """
+        Return a string representation of the node showing the original data represented by the node.
+        """
+        return f'{self.get_type_name()}'
+
+    def add_parent_index(self, parent, parent_index):
+        """
+        Add a parent to the node.
+        """
+        if not parent in self.parent_indices:
+            self.parent_indices[parent] = []
+        self.parent_indices[parent].append(parent_index)
+
+    def is_root(self):
+        """
+        Return if the node is the root node.
+        """
+        return len(self.parent_indices) == 0
+
+    def get_parent_indices(self):
+        return self.parent_indices
+
+    def get_id(self):
+        """
+        Return the id of the node.
+        """
+        return id(self.data)
+
+    def __eq__(self, other):
+        """
+        Return if the node is equal to another node.
+        """
+        return self.get_id() == other.get_id()
+    
+    def __hash__(self):
+        """
+        Return the hash of the node.
+        """
+        return self.get_id()
+
+    def get_data(self):
+        """
+        Return the original data represented by the node.
+        """
+        return self.data
+    
+    def get_type(self):
+        """
+        Return the type of the data represented by the node.
+        """
+        return type(self.data)
+    
+    def get_type_name(self):
+        """
+        Return the name of the type of the data represented by the node.
+        """
+        return utils.get_type_name(self.data)
+
+    def get_children(self):
+        """
+        Return the children of the node. Initially the children are raw data, but 
+        later they too are converted to Node_Base by the Memory_visitor using the Node_Base 'transform' method.
+        """
+        return self.children
+
+    def get_name(self):
+        """
+        Return a unique name for the node.
+        """
+        return f'node{self.get_id()}'
+
+    def get_html_table(self, nodes, slices, id_to_slices):
+        """
+        Return the HTML_Table object that determines how the node is visualized in the graph.
+        """
+        from memory_graph.html_table import HTML_Table
+        import memory_graph.node_base
+        html_table = HTML_Table()
+        self.fill_html_table(nodes, html_table, slices, id_to_slices)
+        return html_table
+    
+    def get_slicer(self):
+        return config_helpers.get_slicer(self, self.get_data())
+    
+    def is_hidden_node(self):
+        """
+        Return if the node is a hidden node in the graph.
+        """
+        from memory_graph.node_key_value import Node_Key_Value
+        if self.get_type() is tuple:
+            parent_indices = self.get_parent_indices()
+            if len(parent_indices) == 1:
+                first_parent = next(iter(parent_indices))
+                if type(first_parent) is Node_Key_Value:
+                    return True
+        return False
+
+    # -------------------- Node_Base interface, overriden by subclasses --------------------
+
+    @abstractmethod
+    def fill_html_table(self, html_table, slices, id_to_slices):
+        """
+        Fill the HTML_Table object with each child of the node.
+        """
+        pass
+
+    def get_label(self, slices):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        return self.get_type_name()

memory_graph/node_key_value.py

@@ -0,0 +1,124 @@
+# 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_Key_Value(Node_Base):
+    """
+    Node_Key_Value (subclass of Node_Base) is a node that represents a node with key-value 
+    pairs (tuples) as children. This node type mainly used for dictionaries and classes. 
+    Each child is made a Hidden_Node_Base so that each tuple is not shown as a separate node 
+    but instead as a key,value pair in the current node.
+    """
+
+    def __init__(self, data, children):
+        """
+        Create a Node_Key_Value object. Use a Slicer to slice the children so the
+        Node_Base will not get too big or have too many childeren in the graph.
+        """
+        super().__init__(data, Sequence1D(children))
+    
+    def has_references(self, nodes, slices, id_to_slices):
+        """
+        Return if the node has references to other nodes.
+        """
+        for index in slices:
+            child_id = id(self.children[index])
+            child = nodes[child_id]
+            key_id = id(child.get_children()[0])
+            if key_id in nodes:
+                key = nodes[key_id]
+                if not key.is_hidden_node():
+                    return True
+            value_id = id(child.get_children()[1])
+            if value_id in nodes:
+                value = nodes[value_id]
+                if not value.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, id_to_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
+        vertical = self.is_vertical(nodes, slices, id_to_slices)
+        if vertical:
+            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)
+
+    @staticmethod
+    def get_value_dashed(nodes, child, index, id_to_slices):
+        grandchild = child[index]
+        child_id = id(child)
+        is_dashed = False
+        if child_id in id_to_slices:
+            slices = id_to_slices[child_id]
+            if not slices is None:
+                is_dashed = slices.is_dashed(index)
+        return grandchild, is_dashed
+
+    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:
+                child = self.children[index]
+                key, is_dashed = self.get_value_dashed(nodes, child,0,id_to_slices)
+                html_table.add_entry(self, nodes, key, id_to_slices, rounded=True, dashed=is_dashed)
+                value, is_dashed = self.get_value_dashed(nodes, child,1,id_to_slices)
+                html_table.add_entry(self, nodes, value, id_to_slices, dashed=is_dashed)
+            else:
+                html_table.add_dots(rounded=True)
+                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:
+                child = self.children[index]
+                key, is_dashed = self.get_value_dashed(nodes, child,0,id_to_slices)
+                html_table.add_entry(self, nodes, key, id_to_slices, rounded=True, dashed=is_dashed)
+            else:
+                html_table.add_dots(rounded=True)
+        html_table.add_new_line()
+        for index in slices.table_iter(self.children.size()):
+            if index>=0:
+                child = self.children[index]
+                value, is_dashed = self.get_value_dashed(nodes, child,1,id_to_slices)
+                html_table.add_entry(self, nodes, value, id_to_slices, dashed=is_dashed)
+            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_leaf.py

@@ -0,0 +1,23 @@
+# 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
+
+class Node_Leaf(Node_Base):
+    """
+    Node_Leaf (subclass of Node_Base) is a leaf node with no children but a value.
+    """
+
+    def __init__(self, data, value):
+        """
+        Create a Node_Leaf object.
+        """
+        super().__init__(data)
+        self.value = value
+
+    def fill_html_table(self, nodes, html_table, slices, id_to_slices):
+        """
+        Fill the html_table with the children of the Node_Base.
+        """
+        html_table.add_value(self.value)