memory-graph 0.3.12__tar.gz → 0.3.14__tar.gz

memory_graph-0.3.14/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include images/ *

{memory_graph-0.3.12 → memory_graph-0.3.14}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.12
-Summary: Draws a graph of your data to analyze its structure.
+Version: 0.3.14
+Summary: Generate intuitive graphs of your Python data, perfect for debugging and understanding complex relationships.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
 Author-email: bterwijn@gmail.com
@@ -24,9 +24,35 @@ pip install --upgrade memory_graph
 ```
 Additionally [Graphviz](https://graphviz.org/download/) needs to be installed.
 
-# Sharing Data #
+# Memory Graph #
+For program understanding and debugging, the [memory_graph](https://pypi.org/project/memory-graph/) package can visualize your data, supporting many different data types, including but not limited to:
+
+```python
+import memory_graph as mg
+
+class MyClass:
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+data = [ range(1, 2), (3, 4), {5, 6}, {7:'seven', 8:'eight'},  MyClass(9, 10) ]
+mg.show(data)
+```
+![many_types.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/many_types.png)
+
+Instead of showing the graph on screen you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
 
-In Python, assigning the list from variable `a` to variable `b` causes both variables to reference the same list object and therefore share the data. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
+```python
+mg.render(data, "my_graph.pdf")
+mg.render(data, "my_graph.svg")
+mg.render(data, "my_graph.png")
+mg.render(data, "my_graph.gv") # Graphviz DOT file
+mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
+```
+
+# Sharing Values #
+In Python, assigning the list from variable `a` to variable `b` causes both variables to reference the same list value and thus share it. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
 
 <table><tr><td> 
 
@@ -67,33 +93,6 @@ identical?: True
 ```
 A better way to understand what data is shared is to draw a graph of the data using the [memory_graph](https://pypi.org/project/memory-graph/) package.
 
-# Memory Graph #
-The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types, not limited to:
-
-```python
-import memory_graph as mg
-
-class MyClass:
-
-    def __init__(self, x, y):
-        self.x = x
-        self.y = y
-
-data = [ range(1, 2), (3, 4), {5, 6}, {7:'seven', 8:'eight'},  MyClass(9, 10) ]
-mg.show(data)
-```
-![many_types.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/many_types.png)
-
-Instead of showing the graph you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
-
-```python
-mg.render(data, "my_graph.pdf")
-mg.render(data, "my_graph.svg")
-mg.render(data, "my_graph.png")
-mg.render(data, "my_graph.gv") # Graphviz DOT file
-mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
-```
-
 # Chapters #
 
 [Python Data Model](#python-data-model)
@@ -197,7 +196,7 @@ mg.show(locals())
 ![copies.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copies.png)
 
 
-### Custom Copy Method ###
+### Custom Copy ###
 We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
 
 ```python
@@ -224,7 +223,7 @@ mg.show(locals())
 
 
 ## Call Stack ##
-The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. Then by examining the graph, we can determine whether any local variables from different functions on the call stack share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -252,7 +251,7 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
 ### Block ###
-It is often helpful to temporarily block program execution to inspect the graph. For this, you can use the `mg.block()` function:
+It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
 
 ```python
 mg.block(fun, arg1, arg2, ...) 
@@ -264,7 +263,7 @@ This function:
 * then blocks execution until the &lt;Enter&gt; key is pressed
 * finally returns the value of the `fun()` call
 
-to change its behavior:
+To change its behavior:
 * Set `mg.block_prints_location = False` to skip printing the source location.
 * Set `mg.press_enter_message = None` to skip printing "Press &lt;Enter&gt; to continue...".
 
@@ -319,7 +318,6 @@ print( power_set(['a', 'b', 'c']) )
 [['a', 'b', 'c'], ['a', 'b'], ['a', 'c'], ['a'], ['b', 'c'], ['b'], ['c'], []]
 ```
 
-
 ## Debugging ##
 
 For the best debugging experience with memory_graph set for example expression:
@@ -463,7 +461,7 @@ class BinTree:
 tree = BinTree()
 n = 100
 for i in range(n):
-    new_value = random.randrange(100)
+    new_value = random.randrange(n)
     tree.add(new_value)
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
@@ -534,6 +532,27 @@ Different aspects of memory_graph can be configured. The default configuration i
 - ***mg.config.type_to_slicer*** : dict
   - Maps each type to a Slicer. A slicer determines how many elements of a data type are shown in the graph to prevent the graph from getting too big. 'Slicer()' does no slicing, 'Slicer(1,2,3)' shows just 1 element at the beginning, 2 in the middle, and 3 at the end.
 
+### Simplified Graph ###
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+
+The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
+```python
+import memory_graph as mg
+
+a = [100, 200, 300]
+b = a.copy()
+mg.render(locals(), 'not_node_types1.png')
+
+mg.config.not_node_types.remove(int) # now show separate nodes for int values
+
+mg.render(locals(), 'not_node_types2.png')
+```
+| ![not_node_types1](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types1.png) | ![not_node_types2](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| not_node_types1.png — simplified | not_node_types2.png — technically correct |
+
+Additionally, the simplification hides the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
+
 ### Temporary Configuration ###
 In addition to the global configuration, a temporary configuration can be set for a single `show()` or `render()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
 
@@ -545,7 +564,7 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to "red"
+    colors                = {id(highlight): "red"   }, # set color to red
     vertical_orientations = {id(highlight): False   }, # set horizontal orientation
     slicers               = {id(highlight): Slicer()}  # set no slicing 
 )
@@ -736,7 +755,7 @@ display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables in
 mg.block(display, mg.create_graph(mg.locals_jupyter()) ) # the same but blocked
 ```
 
-See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.ipynb).
+See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
@@ -758,3 +777,6 @@ We can also run memory_graph in the browser: <a href="https://bterwijn.github.io
 - 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.
 
 - 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.
+
+### Invocation_Tree Package ###
+The [memory_graph](https://pypi.org/project/memory-graph/) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://pypi.org/project/invocation-tree/) package.

memory_graph-0.3.12/memory_graph.egg-info/PKG-INFO → memory_graph-0.3.14/README.md

@@ -1,22 +1,3 @@
-Metadata-Version: 2.1
-Name: memory_graph
-Version: 0.3.12
-Summary: Draws a graph of your data to analyze its structure.
-Home-page: https://github.com/bterwijn/memory_graph
-Author: Bas Terwijn
-Author-email: bterwijn@gmail.com
-License: BSD 2-clause
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Education
-Classifier: Topic :: Software Development :: Debuggers
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: graphviz
-
 # Installation #
 Install (or upgrade) `memory_graph` using pip:
 ```
@@ -24,9 +5,35 @@ pip install --upgrade memory_graph
 ```
 Additionally [Graphviz](https://graphviz.org/download/) needs to be installed.
 
-# Sharing Data #
+# Memory Graph #
+For program understanding and debugging, the [memory_graph](https://pypi.org/project/memory-graph/) package can visualize your data, supporting many different data types, including but not limited to:
+
+```python
+import memory_graph as mg
+
+class MyClass:
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+data = [ range(1, 2), (3, 4), {5, 6}, {7:'seven', 8:'eight'},  MyClass(9, 10) ]
+mg.show(data)
+```
+![many_types.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/many_types.png)
+
+Instead of showing the graph on screen you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
+
+```python
+mg.render(data, "my_graph.pdf")
+mg.render(data, "my_graph.svg")
+mg.render(data, "my_graph.png")
+mg.render(data, "my_graph.gv") # Graphviz DOT file
+mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
+```
 
-In Python, assigning the list from variable `a` to variable `b` causes both variables to reference the same list object and therefore share the data. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
+# Sharing Values #
+In Python, assigning the list from variable `a` to variable `b` causes both variables to reference the same list value and thus share it. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
 
 <table><tr><td> 
 
@@ -67,33 +74,6 @@ identical?: True
 ```
 A better way to understand what data is shared is to draw a graph of the data using the [memory_graph](https://pypi.org/project/memory-graph/) package.
 
-# Memory Graph #
-The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types, not limited to:
-
-```python
-import memory_graph as mg
-
-class MyClass:
-
-    def __init__(self, x, y):
-        self.x = x
-        self.y = y
-
-data = [ range(1, 2), (3, 4), {5, 6}, {7:'seven', 8:'eight'},  MyClass(9, 10) ]
-mg.show(data)
-```
-![many_types.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/many_types.png)
-
-Instead of showing the graph you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
-
-```python
-mg.render(data, "my_graph.pdf")
-mg.render(data, "my_graph.svg")
-mg.render(data, "my_graph.png")
-mg.render(data, "my_graph.gv") # Graphviz DOT file
-mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
-```
-
 # Chapters #
 
 [Python Data Model](#python-data-model)
@@ -197,7 +177,7 @@ mg.show(locals())
 ![copies.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copies.png)
 
 
-### Custom Copy Method ###
+### Custom Copy ###
 We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
 
 ```python
@@ -224,7 +204,7 @@ mg.show(locals())
 
 
 ## Call Stack ##
-The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. Then by examining the graph, we can determine whether any local variables from different functions on the call stack share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -252,7 +232,7 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
 ### Block ###
-It is often helpful to temporarily block program execution to inspect the graph. For this, you can use the `mg.block()` function:
+It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
 
 ```python
 mg.block(fun, arg1, arg2, ...) 
@@ -264,7 +244,7 @@ This function:
 * then blocks execution until the &lt;Enter&gt; key is pressed
 * finally returns the value of the `fun()` call
 
-to change its behavior:
+To change its behavior:
 * Set `mg.block_prints_location = False` to skip printing the source location.
 * Set `mg.press_enter_message = None` to skip printing "Press &lt;Enter&gt; to continue...".
 
@@ -319,7 +299,6 @@ print( power_set(['a', 'b', 'c']) )
 [['a', 'b', 'c'], ['a', 'b'], ['a', 'c'], ['a'], ['b', 'c'], ['b'], ['c'], []]
 ```
 
-
 ## Debugging ##
 
 For the best debugging experience with memory_graph set for example expression:
@@ -463,7 +442,7 @@ class BinTree:
 tree = BinTree()
 n = 100
 for i in range(n):
-    new_value = random.randrange(100)
+    new_value = random.randrange(n)
     tree.add(new_value)
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
@@ -534,6 +513,27 @@ Different aspects of memory_graph can be configured. The default configuration i
 - ***mg.config.type_to_slicer*** : dict
   - Maps each type to a Slicer. A slicer determines how many elements of a data type are shown in the graph to prevent the graph from getting too big. 'Slicer()' does no slicing, 'Slicer(1,2,3)' shows just 1 element at the beginning, 2 in the middle, and 3 at the end.
 
+### Simplified Graph ###
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+
+The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
+```python
+import memory_graph as mg
+
+a = [100, 200, 300]
+b = a.copy()
+mg.render(locals(), 'not_node_types1.png')
+
+mg.config.not_node_types.remove(int) # now show separate nodes for int values
+
+mg.render(locals(), 'not_node_types2.png')
+```
+| ![not_node_types1](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types1.png) | ![not_node_types2](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| not_node_types1.png — simplified | not_node_types2.png — technically correct |
+
+Additionally, the simplification hides the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
+
 ### Temporary Configuration ###
 In addition to the global configuration, a temporary configuration can be set for a single `show()` or `render()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
 
@@ -545,7 +545,7 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to "red"
+    colors                = {id(highlight): "red"   }, # set color to red
     vertical_orientations = {id(highlight): False   }, # set horizontal orientation
     slicers               = {id(highlight): Slicer()}  # set no slicing 
 )
@@ -736,7 +736,7 @@ display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables in
 mg.block(display, mg.create_graph(mg.locals_jupyter()) ) # the same but blocked
 ```
 
-See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.ipynb).
+See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
@@ -758,3 +758,6 @@ We can also run memory_graph in the browser: <a href="https://bterwijn.github.io
 - 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.
 
 - 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.
+
+### Invocation_Tree Package ###
+The [memory_graph](https://pypi.org/project/memory-graph/) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://pypi.org/project/invocation-tree/) package.

memory_graph-0.3.14/images/avltree.py~

@@ -0,0 +1,41 @@
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.render(locals(), 'avltree_fail.png')
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.render(locals(), 'avltree_color.png')
+
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node_Linear(data, dir(data))
+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_linear.Node_Linear(data,
+                                                                                        ['left', data.left,
+                                                                                         'key', data.key,
+                                                                                         'value', data.value,
+                                                                                         'right', data.right])
+mg.render(locals(), 'avltree_linear.png')
+
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_key_value.Node_Key_Value(data,
+                                                                                              {'left': data.left,
+                                                                                               'key': data.key,
+                                                                                               'value': data.value,
+                                                                                               'right': data.right}.items())
+mg.render(locals(), 'avltree_key_value.png')
+
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_table.Node_Table(data,
+                                                                                      [[data.key, data.value],
+                                                                                       [data.left, data.right]]
+                                                                                      )
+mg.render(locals(), 'avltree_table.png')

memory_graph-0.3.14/images/avltree_fail.gv

@@ -0,0 +1,26 @@
+digraph memory_graph {
+	node [shape=plaintext]
+	node130513740275104 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="white"><TR><TD PORT="table">
+&lt;bintrees.avltree.Node object at 0x76b3992...
+</TD></TR></TABLE>
+> xlabel="Node"]
+	node130513740453920 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="seagreen1"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD BORDER="1" STYLE="ROUNDED"> _root </TD><TD BORDER="1" STYLE="ROUNDED"> _count </TD></TR>
+    <TR><TD BORDER="1" PORT="ref0"> </TD><TD BORDER="1"> 4 </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=AVLTree]
+	node130513740453920:ref0 -> node130513740275104:table [style=solid]
+	node130513742307200 [label=<
+<TABLE BORDER="0" CELLBORDER="3" CELLSPACING="0" CELLPADDING="0" BGCOLOR="dodgerblue1"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD BORDER="1" STYLE="ROUNDED"> tree </TD></TR>
+    <TR><TD BORDER="1" PORT="ref0"> </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=dict]
+	node130513742307200:ref0 -> node130513740453920:table [style=solid]
+}

{memory_graph-0.3.12 → memory_graph-0.3.14}/images/create_gif.sh

@@ -9,7 +9,7 @@ files=$(ls -v $name*.png)
 echo "creating gif with:"
 echo "$files"
 
-largest_size=$(identify -format "%Wx%H %f\n" $name*.png | sort -nr | head -n1)
+largest_size=$(identify -format "%H %Wx%H %f\n" $name*.png | sort -nr | head -n1| awk '{print $2}')
 echo "largest_size: $largest_size"
 
 echo "resizing images"

{memory_graph-0.3.12 → memory_graph-0.3.14}/images/create_images.sh

@@ -24,6 +24,7 @@ python bin_tree.py
 python hash_set.py
 
 # configuration
+python not_node_types.py
 python highlight.py
 
 # extensions

memory_graph-0.3.14/images/memory_graph.gv

@@ -0,0 +1,20 @@
+digraph memory_graph {
+	node [shape=plaintext]
+	node126810958314944 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="lightcoral"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD><font color="#505050">0</font></TD><TD BORDER="1"> 0 </TD></TR>
+    <TR><TD><font color="#505050">1</font></TD><TD BORDER="1"> 1 </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=list]
+	node126810936962048 [label=<
+<TABLE BORDER="0" CELLBORDER="3" CELLSPACING="0" CELLPADDING="0" BGCOLOR="dodgerblue1"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD BORDER="1" STYLE="ROUNDED"> data </TD><TD BORDER="1" STYLE="ROUNDED"> i </TD></TR>
+    <TR><TD BORDER="1" PORT="ref0"> </TD><TD BORDER="1"> 1 </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=dict]
+	node126810936962048:ref0 -> node126810958314944:table [style=solid]
+}

memory_graph-0.3.14/images/my_graph.gv

@@ -0,0 +1,35 @@
+digraph memory_graph {
+	node [shape=plaintext]
+	node123611189233536 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="lightcoral"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD><font color="#505050">0</font></TD><TD BORDER="1"> 1 </TD></TR>
+    <TR><TD><font color="#505050">1</font></TD><TD BORDER="1"> 2 </TD></TR>
+    <TR><TD><font color="#505050">2</font></TD><TD BORDER="1"> 3 </TD></TR>
+    <TR><TD><font color="#505050">3</font></TD><TD BORDER="1"> 0 </TD></TR>
+    <TR><TD><font color="#505050">4</font></TD><TD BORDER="1"> 1 </TD></TR>
+    <TR><TD><font color="#505050">5</font></TD><TD BORDER="1"> 4 </TD></TR>
+    <TR><TD><font color="#505050">6</font></TD><TD BORDER="1"> 9 </TD></TR>
+    <TR><TD><font color="#505050">7</font></TD><TD BORDER="1"> 16 </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=list]
+	node123611188190208 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="dodgerblue1"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD BORDER="1" STYLE="ROUNDED"> d </TD><TD BORDER="1" STYLE="ROUNDED"> i </TD></TR>
+    <TR><TD BORDER="1" PORT="ref0"> </TD><TD BORDER="1"> 4 </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=dict]
+	node123611188190208:ref0 -> node123611189233536:table [style=solid]
+	node123611178012800 [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="0" BGCOLOR="dodgerblue1"><TR><TD PORT="table">
+  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">
+    <TR><TD BORDER="1" STYLE="ROUNDED"> 0: &lt;module&gt; </TD></TR>
+    <TR><TD BORDER="1" PORT="ref0"> </TD></TR>
+  </TABLE>
+</TD></TR></TABLE>
+> xlabel=dict]
+	node123611178012800:ref0 -> node123611188190208:table [style=solid]
+}