memory-graph 0.2.5__tar.gz → 0.3.2__tar.gz

{memory_graph-0.2.5 → memory_graph-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.2.5
+Version: 0.3.2
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -302,7 +302,7 @@ def factorial(n):
     memory_graph.show( memory_graph.get_call_stack(), block=True )
     return result
 
-factorial(3)
+print(factorial(3))
 ```
 ![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
 

{memory_graph-0.2.5 → memory_graph-0.3.2}/README.md

@@ -283,7 +283,7 @@ def factorial(n):
     memory_graph.show( memory_graph.get_call_stack(), block=True )
     return result
 
-factorial(3)
+print(factorial(3))
 ```
 ![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
 

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/__init__.py

@@ -1,12 +1,15 @@
-from memory_graph.memory_graph import Memory_Graph
-
-import memory_graph.config_default as config_default
+import memory_graph.memory_to_nodes as memory_to_nodes
+import memory_graph.config as config
+import memory_graph.config_default
+import memory_graph.config_helpers as config_helper
 import memory_graph.utils as utils
 
 import inspect
 import sys
 
-__version__ = "0.2.05"
+import graphviz
+
+__version__ = "0.3.02"
 __author__ = 'Bas Terwijn'
 
 log_file=sys.stdout
@@ -30,8 +33,9 @@ def create_graph(data,
                  vertical_orientations = None,
                  slicers = None):
     """ Creates and returns a memory graph from 'data'. """
-    memory_graph = Memory_Graph(data, colors, vertical_orientations, slicers)
-    return memory_graph.get_graph()
+    config_helper.set_config(colors, vertical_orientations, slicers)
+    graphviz_graph = memory_to_nodes.memory_to_nodes(data)
+    return graphviz_graph
 
 def show(data=None ,block=False, stack_index=2,
                  colors = None,
@@ -45,7 +49,7 @@ def show(data=None ,block=False, stack_index=2,
     if block:
         input(f"showing '{graph.filename}', {get_source_location(2)}, {press_enter_text}")
 
-def render(data=None, output_filename=None, block=False, stack_index=2,
+def render(data=None, outfile=None, block=False, stack_index=2,
                  colors = None,
                  vertical_orientations = None,
                  slicers = None):
@@ -53,7 +57,7 @@ def render(data=None, output_filename=None, block=False, stack_index=2,
     if data is None:
         data=get_locals_from_calling_frame(stack_index)
     graph = create_graph(data, colors, vertical_orientations, slicers)
-    filename = output_filename if output_filename else graph.filename+".pdf"
+    filename = outfile if outfile else graph.filename+".pdf"
     graph.render(outfile=filename)
     if block:
         input(f"rendering '{filename}', {get_source_location(2)}, {press_enter_text}")

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/config.py

@@ -1,9 +1,10 @@
 """ Configuration file for the graph visualizer. The configuration values are set later by the 'config_default.py' file. """
 
-max_number_nodes = 0
-max_string_length = 0
+max_tree_depth = None
+max_missing_edges = None
+max_string_length = None
 
-no_reference_types = {}
+not_node_types = {}
 no_child_references_types = set()
 
 type_to_node = { }

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/config_default.py

@@ -1,9 +1,9 @@
 """ Sets the default configuration values for the memory graph. """
-from memory_graph.node import Node
-from memory_graph.node_linear import Node_Linear
+from memory_graph.node_base      import Node_Base
+from memory_graph.node_linear    import Node_Linear
 from memory_graph.node_key_value import Node_Key_Value
-from memory_graph.node_hidden import Node_Hidden
-from memory_graph.node_table import Node_Table
+from memory_graph.node_table     import Node_Table
+
 from memory_graph.slicer import Slicer
 
 import memory_graph.config as config
@@ -11,39 +11,35 @@ import memory_graph.utils as utils
 
 import types
 
-""" The maxium number of Nodes shown in the graph. When the graph gets too big set this to a smaller number to analyze the problem. A `★` symbol indictes where the gra[h is cut short.  """
-config.max_number_nodes = 1000
+""" The maximum depth of nodes in the graph. When the graph gets too big set this to a small positive number. A `★` symbol indictes where the graph is cut short.  """
+config.max_tree_depth = -1
+
+config.max_missing_edges = 3
 
 """ The maximum length of strings shown in the graph. Longer strings will be truncated. """
 config.max_string_length = 42
 
 """ Types that by default will not have references pointing to them in the graph but instead will be visualized in the node of their parent. """
-config.no_reference_types = {
-    type(None) : lambda d: "None",  # so None can be used to indicate no value
-    bool : lambda d: d, 
-    int : lambda d: d, 
-    float : lambda d: d, 
-    complex : lambda d: d, 
-    str : lambda d: d,
-    types.FunctionType : lambda d: str(d.__qualname__),
-    types.MethodType  : lambda d: str(d.__qualname__),
+config.not_node_types = {
+    type(None), bool, int, float, complex, str,
+    types.FunctionType,
+    types.MethodType,
 }
 
 """ 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 objects. """
+""" Conversion from type to Node_Base objects. """
 config.type_to_node = {
-    str: lambda data: Node(data), # visit as whole string, don't iterate over characters
+    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__),
     range: lambda data: Node_Key_Value(data, {'start':data.start, 'stop':data.stop, 'step':data.step}.items()),
-    types.FunctionType: lambda data: Node(data.__qualname__),
-    types.MethodType: lambda data: Node(data.__qualname__),
     dict: lambda data: (
-        Node_Key_Value(data, utils.filter_dict_attributes(data.items()) )
+        Node_Key_Value(data, utils.filter_dict(data.items()) )
             if dict in config.no_child_references_types else 
-        Node_Linear(data, utils.filter_dict_attributes(data.items()) ) 
+        Node_Linear(data, utils.filter_dict(data.items()) )
         ),
-    Node_Hidden: lambda data: data,
     }
 
 """ Colors of different types in the graph. """
@@ -71,7 +67,7 @@ config.type_to_color = {
 }
 
 """ Types that will be visualized in vertical orientation if 'True', or horizontal orientation 
-if 'False'. Otherwise the Node decides based on it having references."""
+if 'False'. Otherwise the Node_Base decides based on it having references."""
 config.type_to_vertical_orientation = {
 }
 

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/config_helpers.py

@@ -2,7 +2,6 @@
 from memory_graph.slicer import Slicer
 
 import memory_graph.config as config
-import memory_graph.utils as utils
 
 type_to_color = None
 type_to_vertical_orientation = None
@@ -32,39 +31,22 @@ def get_property(data_id, data_type, node_type, dictionary, default):
     return default
 
 def get_color(node, default='white'):
-    return get_property(id(node.get_data()), 
-                        type(node.get_data()),
-                        type(node), 
+    return get_property(node.get_id(),
+                        node.get_type(),
+                        type(node),
                         type_to_color, 
                         default)
     
 def get_vertical_orientation(node, default):
-    return get_property(id(node.get_data()), 
-                        type(node.get_data()),
-                        type(node),  
+    return get_property(node.get_id(),
+                        node.get_type(),
+                        type(node),
                         type_to_vertical_orientation, 
                         default)
 
-def get_slicer_1d(node, data, default=Slicer(10,5,10)):
-    slicer = get_property(id(data),
-                        type(data),
-                        type(node), 
-                        type_to_slicer, 
-                        default)
-    if type(slicer) is Slicer:
-        return slicer
-    if utils.is_iterable(slicer):
-        return next(iter(slicer))
-    return default
-
-def get_slicer_2d(node, data, default=Slicer(5,5)):
-    slicer = get_property(id(data),
+def get_slicer(node, data, default=Slicer(3,2,3)):
+    return get_property(id(data),
                         type(data),
                         type(node), 
                         type_to_slicer, 
-                        default)
-    if type(slicer) is Slicer:
-        return slicer, slicer
-    if len(slicer) == 2:
-        return slicer
-    return default, default
+                        default)

memory_graph-0.3.2/memory_graph/extension_numpy.py

@@ -0,0 +1,26 @@
+""" Extension to add the memory graph configuration for Numpy types. """
+from memory_graph.node_linear import Node_Linear
+from memory_graph.node_table import Node_Table
+
+import memory_graph.config as config
+
+import numpy as np
+
+config.not_node_types |= {
+    np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, 
+    np.float16, np.float32, np.float64, np.float_, 
+    np.complex64, np.complex128, np.complex_, 
+    np.bool_, np.bytes_, np.str_, np.datetime64, np.timedelta64
+}
+
+def ndarrayy_to_node(ndarrayy_data):
+    if len(ndarrayy_data.shape) == 2:
+        return Node_Table(ndarrayy_data, ndarrayy_data)
+    else:
+        return Node_Linear(ndarrayy_data, ndarrayy_data)
+    
+config.type_to_node[np.matrix] = lambda data : Node_Table(data, np.asarray(data)) # convert to ndarray to avoid infinite recursion due to index issue
+config.type_to_node[np.ndarray] = lambda data :  ndarrayy_to_node(data)
+
+config.type_to_color[np.ndarray] = "hotpink1"
+config.type_to_color[np.matrix] = "hotpink2"

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/extension_pandas.py

@@ -9,7 +9,7 @@ import pandas as pd
 config.type_to_node[pd.DataFrame] = lambda data : (
     Node_Table(data, 
                data.values.tolist(),
-               column_names=data.columns.tolist(),
+               col_names = data.columns.tolist(),
                row_names = [ str(i) for i in data.index.tolist()]
             )
 )

{memory_graph-0.2.5 → memory_graph-0.3.2}/memory_graph/html_table.py

@@ -1,4 +1,5 @@
-from memory_graph.node import Node 
+from memory_graph.node_base import Node_Base 
+import memory_graph.node_base
 
 import memory_graph.config as config
 
@@ -59,7 +60,6 @@ class HTML_Table:
     def add_string(self, s):
         """ Add a string s to the outer table. """
         self.html += format_string(s)
-        #self.col_count += 1
 
     def add_index(self, s):
         """ Add an index s to the inner table. """
@@ -67,10 +67,16 @@ class HTML_Table:
         self.html += f'<TD><font color="#505050">{str(s)}</font></TD>'
         self.col_count += 1
 
-    def add_entry(self, node, child, rounded=False, border=1):
-        """ Add child to the inner table either as reference if it a Node or as a value otherwise. """
-        if isinstance(child, Node): 
-            self.add_reference(node, child, rounded, border)
+    def add_entry(self, node, nodes, child, id_to_slices, rounded=False, border=1, dashed=False):
+        """ Add child to the inner 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("✂", rounded, border)
         else:
             self.add_value(child, rounded, border)
 
@@ -81,13 +87,13 @@ class HTML_Table:
         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):
+    def add_reference(self, node, child, rounded=False, border=1, dashed=False):
         """ Helper function to add a reference to the inner 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()) )
+                            child.get_name(), dashed) )
         self.ref_count += 1
         self.col_count += 1
 

memory_graph-0.3.2/memory_graph/list_view.py

@@ -0,0 +1,53 @@
+
+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-0.3.2/memory_graph/memory_to_nodes.py

@@ -0,0 +1,187 @@
+from memory_graph.node_base import Node_Base
+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_attributes(utils.get_dict_attributes(data)) )
+        elif utils.is_iterable(data): # for lists, tuples, sets, ...
+            return Node_Linear(data, data)
+        else:
+            return Node_Base(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 slice_nodes(nodes, root_id, max_tree_depth):
+
+    def slice_nodes_recursive(nodes, node_id, id_to_slices, max_tree_depth):
+        if max_tree_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_tree_depth -= 1
+                for index in slices:
+                    slice_nodes_recursive(nodes, id(children[index]), id_to_slices, max_tree_depth)
+    id_to_slices = {}
+    slice_nodes_recursive(nodes, root_id, id_to_slices, max_tree_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('{ rank="same"  '+(" -> ".join(new_node_names))+'  [weight=999,style=invis]; }\n')
+        graphviz_graph.body.append('{ rank="same"  '+('; '.join(new_node_names))+'; }\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_tree_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