memory-graph 0.3.17__tar.gz → 0.3.19__tar.gz

{memory_graph-0.3.17/memory_graph.egg-info → memory_graph-0.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.17
+Version: 0.3.19
 Summary: Generate intuitive graphs of your Python data, great for debugging and understanding complex relationships.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -211,13 +211,14 @@ class My_Class:
         self.digits = [1, 2]
         self.letters = ['x', 'y']
 
-    def copy(self): # custom copy method copies the digits but shares the letters
+    def custom_copy(self): 
+	    """ Copies 'digits' but shares 'letters'. """
         c = copy.copy(self)
         c.digits = copy.copy(self.digits)
         return c
 
 a = My_Class()
-b = a.copy()
+b = a.custom_copy()
 
 mg.show(locals())
 ```
@@ -663,8 +664,8 @@ mg.show(locals())
 
 Next figure out what are the attributes you want to graph and choose a Node type, there are four options:
 
-### 1) Node_Base ###
-Node_base is a leaf node (with no children) and shows just a single value.
+### 1) Node_Leaf ###
+Node_Leaf is a leaf node (with no children) and shows just a single value.
 ```python
 import memory_graph as mg
 import bintrees
@@ -677,11 +678,12 @@ tree.insert(20, "twenty")
 tree.insert(15, "fifteen")
 
 mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
-mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_base.Node_Base(f"key:{data.key} value:{data.value}")
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_leaf.Node_Leaf(data, 
+                                                f"key:{data.key} value:{data.value}")
 
 mg.show(locals())
 ```
-![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_leaf.png)
 
 ### 2) Node_Linear ###
 Node_Linear shows all the values in a line like a list.
@@ -784,7 +786,7 @@ We can also run memory_graph in the browser: <a href="https://bterwijn.github.io
 
 ## Troubleshooting ##
 
-- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([Evince](https://www.fosshub.com/Evince.html), [Okular](https://okular.kde.org/), [SumatraPDF](https://www.sumatrapdfreader.org/), ...) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and to open it manually.
+- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([SumatraPDF](https://www.sumatrapdfreader.org/), [Okular](https://okular.kde.org/),  ...) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and to open it manually.
 
 - When graph edges overlap it can be hard to distinguish them. Using an interactive graphviz viewer, such as [xdot](https://github.com/jrfonseca/xdot.py), on a '*.gv' DOT output file will help.
 

{memory_graph-0.3.17 → memory_graph-0.3.19}/README.md

@@ -192,13 +192,14 @@ class My_Class:
         self.digits = [1, 2]
         self.letters = ['x', 'y']
 
-    def copy(self): # custom copy method copies the digits but shares the letters
+    def custom_copy(self): 
+	    """ Copies 'digits' but shares 'letters'. """
         c = copy.copy(self)
         c.digits = copy.copy(self.digits)
         return c
 
 a = My_Class()
-b = a.copy()
+b = a.custom_copy()
 
 mg.show(locals())
 ```
@@ -644,8 +645,8 @@ mg.show(locals())
 
 Next figure out what are the attributes you want to graph and choose a Node type, there are four options:
 
-### 1) Node_Base ###
-Node_base is a leaf node (with no children) and shows just a single value.
+### 1) Node_Leaf ###
+Node_Leaf is a leaf node (with no children) and shows just a single value.
 ```python
 import memory_graph as mg
 import bintrees
@@ -658,11 +659,12 @@ tree.insert(20, "twenty")
 tree.insert(15, "fifteen")
 
 mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
-mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_base.Node_Base(f"key:{data.key} value:{data.value}")
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_leaf.Node_Leaf(data, 
+                                                f"key:{data.key} value:{data.value}")
 
 mg.show(locals())
 ```
-![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_leaf.png)
 
 ### 2) Node_Linear ###
 Node_Linear shows all the values in a line like a list.
@@ -765,7 +767,7 @@ We can also run memory_graph in the browser: <a href="https://bterwijn.github.io
 
 ## Troubleshooting ##
 
-- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([Evince](https://www.fosshub.com/Evince.html), [Okular](https://okular.kde.org/), [SumatraPDF](https://www.sumatrapdfreader.org/), ...) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and to open it manually.
+- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([SumatraPDF](https://www.sumatrapdfreader.org/), [Okular](https://okular.kde.org/),  ...) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and to open it manually.
 
 - When graph edges overlap it can be hard to distinguish them. Using an interactive graphviz viewer, such as [xdot](https://github.com/jrfonseca/xdot.py), on a '*.gv' DOT output file will help.
 

{memory_graph-0.3.17 → memory_graph-0.3.19}/images/avltree.py

@@ -19,8 +19,8 @@ mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node
 mg.config.type_to_slicer[bintrees.avltree.Node] = mg.slicer.Slicer()
 mg.render(locals(), 'avltree_dir.png')
 
-mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_base.Node_Base(f"key:{data.key} value:{data.value}")
-mg.render(locals(), 'avltree_base.png')
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_leaf.Node_Leaf(data, f"key:{data.key} value:{data.value}")
+mg.render(locals(), 'avltree_leaf.png')
 
 mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node_Linear(data,
                                                                                         ['left:', data.left,

{memory_graph-0.3.17 → memory_graph-0.3.19}/images/copy_method.py

@@ -11,12 +11,13 @@ class My_Class:
         self.digits = [1, 2]
         self.letters = ['x', 'y']
 
-    def copy(self): # custom copy method copies the digits but shares the letters
+    def custom_copy(self):
+        """ Copies 'digits' but shares 'letters'. """
         c = copy.copy(self)
         c.digits = copy.copy(self.digits)
         return c
 
 a = My_Class()
-b = a.copy()
+b = a.custom_copy()
 
 mg.render(locals(), 'copy_method.png')

memory_graph-0.3.19/images/log.txt

@@ -0,0 +1,186 @@
+diff --git a/images/avltree.py b/images/avltree.py
+index a8400e8..c984c04 100644
+--- a/images/avltree.py
++++ b/images/avltree.py
+@@ -19,7 +19,7 @@ mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node
+ mg.config.type_to_slicer[bintrees.avltree.Node] = mg.slicer.Slicer()
+ mg.render(locals(), 'avltree_dir.png')
+ 
+-mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_base.Node_Base(f"key:{data.key} value:{data.value}")
++mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_leaf.Node_Leaf(data, f"key:{data.key} value:{data.value}")
+ mg.render(locals(), 'avltree_base.png')
+ 
+ mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node_Linear(data,
+diff --git a/images/avltree_base.png b/images/avltree_base.png
+index 324c36d..de59c50 100644
+Binary files a/images/avltree_base.png and b/images/avltree_base.png differ
+diff --git a/images/not_node_types2.png b/images/not_node_types2.png
+index b001e4b..ee6e943 100644
+Binary files a/images/not_node_types2.png and b/images/not_node_types2.png differ
+diff --git a/memory_graph/config_default.py b/memory_graph/config_default.py
+index 4945c75..02877c0 100644
+--- a/memory_graph/config_default.py
++++ b/memory_graph/config_default.py
+@@ -3,7 +3,7 @@
+ # SPDX-License-Identifier: BSD-2-Clause
+ 
+ """ Sets the default configuration values for the memory graph. """
+-from memory_graph.node_base      import Node_Base
++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
+ from memory_graph.node_table     import Node_Table
+@@ -37,14 +37,14 @@ config.not_node_types = {
+ """ Types that will not have references pointing to their children in the graph but instead will have their children visualized in their node. """
+ config.no_child_references_types = {dict, types.MappingProxyType}
+ 
+-""" Conversion from type to Node_Base objects. """
++""" Conversion from type to Node objects. """
+ config.type_to_node = {
+-    str: lambda data: Node_Base(data), # visit as whole string, don't iterate over characters
++    str: lambda data: Node_Leaf(data, data), # visit as whole string, don't iterate over characters
+     call_stack: lambda data: Node_Key_Value(data, data.items()),
+-    types.FunctionType: lambda data: Node_Base(data.__qualname__),
+-    types.MethodType: lambda data: Node_Base(data.__qualname__),
+-    classmethod: lambda data: Node_Base(data.__qualname__),
+-    staticmethod: lambda data: Node_Base(data.__qualname__),
++    types.FunctionType: lambda data: Node_Leaf(data, data.__qualname__),
++    types.MethodType: lambda data: Node_Leaf(data, data.__qualname__),
++    classmethod: lambda data: Node_Leaf(data, data.__qualname__),
++    staticmethod: lambda data: Node_Leaf(data, data.__qualname__),
+     range: lambda data: Node_Key_Value(data, {'start':data.start, 'stop':data.stop, 'step':data.step}.items()),
+     dict: lambda data: (
+         Node_Key_Value(data, utils.filter_dict(data.items()) )
+@@ -79,7 +79,7 @@ config.type_to_color = {
+ }
+ 
+ """ Types that will be visualized in vertical orientation if 'True', or horizontal orientation 
+-if 'False'. Otherwise the Node_Base decides based on it having references."""
++if 'False'. Otherwise the Node decides based on it having references."""
+ config.type_to_vertical_orientation = {
+ }
+ 
+diff --git a/memory_graph/memory_to_nodes.py b/memory_graph/memory_to_nodes.py
+index a67662e..10c559a 100644
+--- a/memory_graph/memory_to_nodes.py
++++ b/memory_graph/memory_to_nodes.py
+@@ -2,7 +2,7 @@
+ # Copyright (c) 2023, Bas Terwijn.
+ # SPDX-License-Identifier: BSD-2-Clause
+ 
+-from memory_graph.node_base import Node_Base
++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
+ 
+@@ -21,7 +21,7 @@ def read_nodes(data):
+         elif utils.is_finite_iterable(data): # for lists, tuples, sets, ...
+             return Node_Linear(data, data)
+         else:
+-            return Node_Base(data)
++            return Node_Leaf(data, data)
+ 
+     def memory_to_nodes_recursive(nodes, data, parent, parent_index):
+         data_type = type(data)
+diff --git a/memory_graph/node_base.py b/memory_graph/node_base.py
+index 1f46b9a..3d1fbe1 100644
+--- a/memory_graph/node_base.py
++++ b/memory_graph/node_base.py
+@@ -7,7 +7,9 @@ import memory_graph.config as config
+ import memory_graph.config_helpers as config_helpers
+ from memory_graph.sequence import Sequence1D
+ 
+-class Node_Base:
++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.
+     """
+@@ -99,10 +101,7 @@ class Node_Base:
+         from memory_graph.html_table import HTML_Table
+         import memory_graph.node_base
+         html_table = HTML_Table()
+-        if type(self) is memory_graph.node_base.Node_Base:
+-            html_table.add_string(f'{self.data}')
+-        elif not slices is None:
+-            self.fill_html_table(nodes, html_table, slices, id_to_slices)
++        self.fill_html_table(nodes, html_table, slices, id_to_slices)
+         return html_table
+     
+     def get_slicer(self):
+@@ -123,6 +122,7 @@ class Node_Base:
+ 
+     # -------------------- 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.
+@@ -133,4 +133,4 @@ class Node_Base:
+         """
+         Return a label for the node to be shown in the graph next to the HTML table.
+         """
+-        return self.get_type_name()
+
++        return self.get_type_name()
+diff --git a/memory_graph/node_key_value.py b/memory_graph/node_key_value.py
+index 762857e..0c2cd86 100644
+--- a/memory_graph/node_key_value.py
++++ b/memory_graph/node_key_value.py
+@@ -54,6 +54,8 @@ class Node_Key_Value(Node_Base):
+         """
+         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)
+@@ -119,4 +121,4 @@ class Node_Key_Value(Node_Base):
+         if len(s) == 1:
+             if s[0][1] - s[0][0] == size:
+                 return f'{type_name}'
+-        return f'{type_name} {size}'
+
++        return f'{type_name} {size}'
+diff --git a/memory_graph/node_linear.py b/memory_graph/node_linear.py
+index c6926f0..38b8cf0 100644
+--- a/memory_graph/node_linear.py
++++ b/memory_graph/node_linear.py
+@@ -45,6 +45,8 @@ class Node_Linear(Node_Base):
+         """
+         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:
+@@ -95,4 +97,4 @@ class Node_Linear(Node_Base):
+             if s[0][1] - s[0][0] == size:
+                 return f'{type_name}'
+         return f'{type_name} {size}'
+-        
+
++        
+diff --git a/memory_graph/node_table.py b/memory_graph/node_table.py
+index 67914a9..82279d3 100644
+--- a/memory_graph/node_table.py
++++ b/memory_graph/node_table.py
+@@ -35,7 +35,7 @@ class Node_Table(Node_Base):
+         """
+         Fill the html_table with the children of the Node_Base.
+         """
+-        if slices.is_empty():
++        if slices is None or slices.is_empty():
+             return
+         children = self.children
+         children_size = children.size()
+@@ -80,4 +80,4 @@ class Node_Table(Node_Base):
+         """
+         size = self.get_children().size()
+         return f'{self.get_type_name()} {size[0]}⨯{size[1]}'
+-    
+
++    

{memory_graph-0.3.17 → memory_graph-0.3.19}/memory_graph/__init__.py

@@ -10,10 +10,11 @@ import memory_graph.utils as utils
 
 import inspect
 import sys
+from memory_graph.call_stack import call_stack
 
 import graphviz
 
-__version__ = "0.3.17"
+__version__ = "0.3.19"
 __author__ = 'Bas Terwijn'
 render_filename = 'memory_graph.pdf'
 last_show_filename = None
@@ -173,14 +174,24 @@ def get_locals_from_call_stack(stack_index=0):
     frameInfo = inspect.stack()[1+stack_index] # get frameInfo of calling frame
     return frameInfo.frame.f_locals
 
+def get_function_name(frameInfo):
+    frame = frameInfo.frame
+    func_name = frame.f_code.co_name
+    if 'self' in frame.f_locals:  # instance method
+        return f"{frame.f_locals['self'].__class__.__name__}.{func_name}"
+    elif 'cls' in frame.f_locals:  # class method
+        return f"{frame.f_locals['cls'].__name__}.{func_name}"
+    else:  # forget about static method, too complex
+        return func_name  # just the function
+
 def stack_frames_to_dict(frames):
     """ Returns a dictionary representing the data on the call stack. 
     Each key is the stack level and function name, each value is the locals of the frame at that level. 
     """
     def to_dict(value): #  fix by TerenceTux for Python 3.13
         return {k: v for k, v in value.items()}
-    return {f"{level}: {frameInfo.function}" : to_dict(frameInfo.frame.f_locals)
-            for level, frameInfo in enumerate(frames)}
+    return call_stack({f"{level}: {get_function_name(frameInfo)}" : to_dict(frameInfo.frame.f_locals)
+            for level, frameInfo in enumerate(frames)})
 
 def stack(up_to_function="<module>",stack_index=0):
     return get_call_stack(up_to_function, 1+stack_index)

memory_graph-0.3.19/memory_graph/call_stack.py

@@ -0,0 +1,9 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+class call_stack(dict):
+    """Inherits from dict to give the call stack it own name and color. """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

{memory_graph-0.3.17 → memory_graph-0.3.19}/memory_graph/config_default.py

@@ -3,11 +3,12 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 """ Sets the default configuration values for the memory graph. """
-from memory_graph.node_base      import Node_Base
+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
 from memory_graph.node_table     import Node_Table
 
+from memory_graph.call_stack import call_stack
 from memory_graph.slicer import Slicer
 
 import memory_graph.config as config
@@ -36,11 +37,14 @@ config.not_node_types = {
 """ Types that will not have references pointing to their children in the graph but instead will have their children visualized in their node. """
 config.no_child_references_types = {dict, types.MappingProxyType}
 
-""" Conversion from type to Node_Base objects. """
+""" Conversion from type to Node objects. """
 config.type_to_node = {
-    str: lambda data: Node_Base(data), # visit as whole string, don't iterate over characters
-    types.FunctionType: lambda data: Node_Base(data.__qualname__),
-    types.MethodType: lambda data: Node_Base(data.__qualname__),
+    str: lambda data: Node_Leaf(data, data), # visit as whole string, don't iterate over characters
+    call_stack: lambda data: Node_Key_Value(data, data.items()),
+    types.FunctionType: lambda data: Node_Leaf(data, data.__qualname__),
+    types.MethodType: lambda data: Node_Leaf(data, data.__qualname__),
+    classmethod: lambda data: Node_Leaf(data, data.__qualname__),
+    staticmethod: lambda data: Node_Leaf(data, data.__qualname__),
     range: lambda data: Node_Key_Value(data, {'start':data.start, 'stop':data.stop, 'step':data.step}.items()),
     dict: lambda data: (
         Node_Key_Value(data, utils.filter_dict(data.items()) )
@@ -67,14 +71,15 @@ config.type_to_color = {
     bytearray : "khaki2",
     # ================= key_value
     Node_Key_Value : "seagreen1", # for classes
-    type: "seagreen2",            # where class variables are stored
+    call_stack : 'khaki',
+    type: "seagreen3",            # where class variables are stored
     dict : "dodgerblue1",
     types.MappingProxyType : "dodgerblue2", # not used
-    range : "cornsilk",
+    range : "cornsilk2",
 }
 
 """ Types that will be visualized in vertical orientation if 'True', or horizontal orientation 
-if 'False'. Otherwise the Node_Base decides based on it having references."""
+if 'False'. Otherwise the Node decides based on it having references."""
 config.type_to_vertical_orientation = {
 }
 

{memory_graph-0.3.17 → memory_graph-0.3.19}/memory_graph/memory_to_nodes.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-from memory_graph.node_base import Node_Base
+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
 
@@ -21,7 +21,7 @@ def read_nodes(data):
         elif utils.is_finite_iterable(data): # for lists, tuples, sets, ...
             return Node_Linear(data, data)
         else:
-            return Node_Base(data)
+            return Node_Leaf(data, data)
 
     def memory_to_nodes_recursive(nodes, data, parent, parent_index):
         data_type = type(data)

{memory_graph-0.3.17 → memory_graph-0.3.19}/memory_graph/node_base.py

@@ -7,7 +7,9 @@ import memory_graph.config as config
 import memory_graph.config_helpers as config_helpers
 from memory_graph.sequence import Sequence1D
 
-class Node_Base:
+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.
     """
@@ -99,10 +101,7 @@ class Node_Base:
         from memory_graph.html_table import HTML_Table
         import memory_graph.node_base
         html_table = HTML_Table()
-        if type(self) is memory_graph.node_base.Node_Base:
-            html_table.add_string(f'{self.data}')
-        elif not slices is None:
-            self.fill_html_table(nodes, html_table, slices, id_to_slices)
+        self.fill_html_table(nodes, html_table, slices, id_to_slices)
         return html_table
     
     def get_slicer(self):
@@ -123,6 +122,7 @@ class Node_Base:
 
     # -------------------- 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.
@@ -133,4 +133,4 @@ class Node_Base:
         """
         Return a label for the node to be shown in the graph next to the HTML table.
         """
-        return self.get_type_name()
+        return self.get_type_name()

{memory_graph-0.3.17 → memory_graph-0.3.19}/memory_graph/node_key_value.py

@@ -54,6 +54,8 @@ class Node_Key_Value(Node_Base):
         """
         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)
@@ -119,4 +121,4 @@ class Node_Key_Value(Node_Base):
         if len(s) == 1:
             if s[0][1] - s[0][0] == size:
                 return f'{type_name}'
-        return f'{type_name} {size}'
+        return f'{type_name} {size}'

memory_graph-0.3.19/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)