memory-graph 0.3.7__tar.gz → 0.3.9__tar.gz

{memory_graph-0.3.7/memory_graph.egg-info → memory_graph-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.7
+Version: 0.3.9
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -68,7 +68,7 @@ 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.
+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
@@ -88,8 +88,10 @@ Instead of showing the graph you can also render it to an output file of your ch
 
 ```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' (default value: 'memory_graph.pdf')
 ```
 
 # Chapters #
@@ -106,6 +108,8 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 
 [Extensions](#extensions)
 
+[Introspection](#introspection)
+
 [Jupyter Notebook](#jupyter-notebook)
 
 [Troubleshooting](#troubleshooting)
@@ -247,10 +251,12 @@ This is because `b` is of immutable type 'tuple' so its value gets copied automa
 It is often helpful to temporarily block program execution to inspect the graph. For this, you can use the `mg.block()` function:
 
 ```python
-mg.block(fun, arg1, arg2, ..., loc=True) 
+mg.block(fun, arg1, arg2, ...) 
 ```
 
-This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. To skip printing the source location, set `loc=False`.
+This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. 
+Set `mg.block_shows_location = False` to skip printing the source location.
+Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
 
 ### Recursion ###
 The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
@@ -333,12 +339,20 @@ mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
 
 ### Debugging without Debugger Tool ###
 
-To simplify debugging without a debugger tool, we offer these blocking alias functions that you can insert into your code at a specific point to visualize a graph:
+To simplify debugging without a debugger tool, we offer these alias functions that you can insert into your code at the point where you want to visualize a graph:
 
 | alias | purpose | function call |
 |:---|:---|:---|
-| `mg.l()` | graph **l**ocal variables | `mg.block(mg.show, locals())` |
-| `mg.s()` | graph the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.sl()` | **s**how **l**ocal variables | `mg.show(locals())` |
+| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.get_call_stack())` |
+| `mg.bsl()` | **b**lock after **s**howing **l**ocal variables | `mg.block(mg.show, locals())` |
+| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.rl()` | **r**ender **l**ocal variables | `mg.render(locals())` |
+| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.get_call_stack())` |
+| `mg.brl()` | **b**lock after **r**endering **l**ocal variables | `mg.block(mg.render, locals())` |
+| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.get_call_stack())` |
+| `mg.l()` | same as `mg.bsl()` |  |
+| `mg.s()` | same as `mg.bss()` |  |
 
 For example, executing this program:
 
@@ -350,7 +364,7 @@ squares_collector = []
 for i in range(1, 6):
     squares.append(i**2)
     squares_collector.append(squares.copy())
-    mg.l() # graph local variables
+    mg.l() # block after showing local variables
 ```
 and pressing &lt;Enter&gt; a number of times, results in:
 
@@ -564,9 +578,151 @@ mg.show(locals())
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 
+## Introspection ##
+This section is likely to change. Sometimes the introspection fails or is not as desired. For example the `bintrees.avltree.Node` object doesn't show any attributes in the graph below.
+
+```python
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+
+
+### dir() ###
+A useful start is to give it some color, show the list of all its attributes using `dir()`, and setting an empty Slicer to see the attribute list in full.
+
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_dir.png)
+
+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.
+```python
+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.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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
+
+### 2 Node_Linear ###
+Node_Linear shows all the values in a line like a list.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_linear.png)
+
+### 3 Node_Key_Value ###
+Node_Key_Value shows key-value pairs like a dictionary. Note the required `items()` call at the end.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_key_value.png)
+
+### 4 Node_Table ###
+Node_Table shows all the values as a table.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_table.png)
+
+
 ## Jupyter Notebook ##
+In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out.
 
-In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out. 
+We can use `mg.show()` and `mg.render()` in a Jupyter Notebook, but alternatively we can also use `mg.create_graph()` to create a graph and the `display()` function to render it inline with for example:
+
+```python
+display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables inline
+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).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)

{memory_graph-0.3.7 → memory_graph-0.3.9}/README.md

@@ -49,7 +49,7 @@ 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.
+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
@@ -69,8 +69,10 @@ Instead of showing the graph you can also render it to an output file of your ch
 
 ```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' (default value: 'memory_graph.pdf')
 ```
 
 # Chapters #
@@ -87,6 +89,8 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 
 [Extensions](#extensions)
 
+[Introspection](#introspection)
+
 [Jupyter Notebook](#jupyter-notebook)
 
 [Troubleshooting](#troubleshooting)
@@ -228,10 +232,12 @@ This is because `b` is of immutable type 'tuple' so its value gets copied automa
 It is often helpful to temporarily block program execution to inspect the graph. For this, you can use the `mg.block()` function:
 
 ```python
-mg.block(fun, arg1, arg2, ..., loc=True) 
+mg.block(fun, arg1, arg2, ...) 
 ```
 
-This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. To skip printing the source location, set `loc=False`.
+This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. 
+Set `mg.block_shows_location = False` to skip printing the source location.
+Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
 
 ### Recursion ###
 The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
@@ -314,12 +320,20 @@ mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
 
 ### Debugging without Debugger Tool ###
 
-To simplify debugging without a debugger tool, we offer these blocking alias functions that you can insert into your code at a specific point to visualize a graph:
+To simplify debugging without a debugger tool, we offer these alias functions that you can insert into your code at the point where you want to visualize a graph:
 
 | alias | purpose | function call |
 |:---|:---|:---|
-| `mg.l()` | graph **l**ocal variables | `mg.block(mg.show, locals())` |
-| `mg.s()` | graph the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.sl()` | **s**how **l**ocal variables | `mg.show(locals())` |
+| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.get_call_stack())` |
+| `mg.bsl()` | **b**lock after **s**howing **l**ocal variables | `mg.block(mg.show, locals())` |
+| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.rl()` | **r**ender **l**ocal variables | `mg.render(locals())` |
+| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.get_call_stack())` |
+| `mg.brl()` | **b**lock after **r**endering **l**ocal variables | `mg.block(mg.render, locals())` |
+| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.get_call_stack())` |
+| `mg.l()` | same as `mg.bsl()` |  |
+| `mg.s()` | same as `mg.bss()` |  |
 
 For example, executing this program:
 
@@ -331,7 +345,7 @@ squares_collector = []
 for i in range(1, 6):
     squares.append(i**2)
     squares_collector.append(squares.copy())
-    mg.l() # graph local variables
+    mg.l() # block after showing local variables
 ```
 and pressing &lt;Enter&gt; a number of times, results in:
 
@@ -545,9 +559,151 @@ mg.show(locals())
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 
+## Introspection ##
+This section is likely to change. Sometimes the introspection fails or is not as desired. For example the `bintrees.avltree.Node` object doesn't show any attributes in the graph below.
+
+```python
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+
+
+### dir() ###
+A useful start is to give it some color, show the list of all its attributes using `dir()`, and setting an empty Slicer to see the attribute list in full.
+
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_dir.png)
+
+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.
+```python
+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.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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
+
+### 2 Node_Linear ###
+Node_Linear shows all the values in a line like a list.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_linear.png)
+
+### 3 Node_Key_Value ###
+Node_Key_Value shows key-value pairs like a dictionary. Note the required `items()` call at the end.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_key_value.png)
+
+### 4 Node_Table ###
+Node_Table shows all the values as a table.
+```python
+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.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_table.png)
+
+
 ## Jupyter Notebook ##
+In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out.
 
-In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out. 
+We can use `mg.show()` and `mg.render()` in a Jupyter Notebook, but alternatively we can also use `mg.create_graph()` to create a graph and the `display()` function to render it inline with for example:
+
+```python
+display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables inline
+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).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)

memory_graph-0.3.9/TODO.txt

@@ -0,0 +1,9 @@
+
+mg.block(fun, print_loc=True), update docs, stack-overflow posts
+
+Jupyter Notebook inline render using display()
+
+webassembly inline render
+
+optional max introspect depth for each type/id
+https://discuss.python.org/t/request-for-feedback-memory-graph-a-python-visualization-tool-for-education/78347

memory_graph-0.3.9/images/add_one.py

@@ -0,0 +1,18 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+def add_one(a, b, c):
+    a += [1]
+    b += (1,)
+    c += [1]
+    mg.render( mg.get_call_stack(), "add_one.png")
+
+a = [4, 3, 2]
+b = (4, 3, 2)
+c = [4, 3, 2]
+
+add_one(a, b, c.copy())
+print(f"a:{a} b:{b} c:{c}")

memory_graph-0.3.9/images/avltree.py

@@ -0,0 +1,43 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+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') # id keeps changing
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+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.9/images/bin_tree.py

@@ -0,0 +1,47 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+import random
+random.seed(0) # use same random numbers each run
+
+class Node:
+
+    def __init__(self, value):
+        self.smaller = None
+        self.value = value
+        self.larger = None
+
+class BinTree:
+
+    def __init__(self):
+        self.root = None
+
+    def add_recursive(self, new_value, node):
+        if new_value < node.value:
+            if node.smaller is None:
+                node.smaller = Node(new_value)
+            else:
+                self.add_recursive(new_value, node.smaller)
+        else:
+            if node.larger is None:
+                node.larger = Node(new_value)
+            else:
+                self.add_recursive(new_value, node.larger)
+        if new_value == 51:
+            mg.render(locals(), f"bin_tree.png")
+            exit(0)
+
+    def add(self, value):
+        if self.root is None:
+            self.root = Node(value)
+        else:
+            self.add_recursive(value, self.root)
+
+tree = BinTree()
+n = 100
+for i in range(n):
+    new_value = random.randrange(n)
+    tree.add(new_value)
+

memory_graph-0.3.9/images/copies.py

@@ -0,0 +1,15 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+import copy
+
+a = [ [1, 2], ['x', 'y'] ] # a nested list (a list containing lists)
+
+# three different ways to make a "copy" of 'a':
+c1 = a
+c2 = copy.copy(a) # equivalent to:  a.copy() a[:] list(a)
+c3 = copy.deepcopy(a)
+
+mg.render(locals(), 'copies.png')

memory_graph-0.3.9/images/copy_method.py

@@ -0,0 +1,22 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+import copy
+
+class My_Class:
+
+    def __init__(self):
+        self.digits = [1, 2]
+        self.letters = ['x', 'y']
+
+    def copy(self): # custom copy method copies the digits but shares the letters
+        c = copy.copy(self)
+        c.digits = copy.copy(self.digits)
+        return c
+
+a = My_Class()
+b = a.copy()
+
+mg.render(locals(), 'copy_method.png')

memory_graph-0.3.9/images/create_gif.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+# install:
+#
+#   sudo apt install imagemagick
+
+name="$1"
+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)
+echo "largest_size: $largest_size"
+
+echo "resizing images"
+mogrify -resize $largest_size -background white -gravity center -extent $largest_size $files
+echo "creating file: $name.gif"
+convert -delay 150 -loop 0 $files $name.gif
+echo "done"