memory-graph 0.3.13__tar.gz → 0.3.15__tar.gz

memory_graph-0.3.15/MANIFEST.in

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

{memory_graph-0.3.13 → memory_graph-0.3.15}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.13
-Summary: Draws a graph of your data to analyze its structure.
+Version: 0.3.15
+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
 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)
@@ -147,6 +146,7 @@ import memory_graph as mg
 a = (4, 3, 2)
 b = a
 mg.render(locals(), 'immutable1.png')
+
 a += (1,)
 mg.render(locals(), 'immutable2.png')
 ```
@@ -164,6 +164,7 @@ import memory_graph as mg
 a = [4, 3, 2]
 b = a
 mg.render(locals(), 'mutable1.png')
+
 a += [1] # equivalent to:  a.append(1)
 mg.render(locals(), 'mutable2.png')
 ```
@@ -197,7 +198,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
@@ -222,9 +223,26 @@ mg.show(locals())
 ```
 ![copy_method.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_method.png)
 
+### Name Rebinding ###
+When `a` and `b` share a mutable value, then changing the value of `a` changes the value of `b` and vice versa. However, reassigning the value of `a` does not change `b`. When you reassign `a`, you only rebind the name `a` to a new value without effecting any other variables.
+
+```python
+import memory_graph as mg
+
+a = [4, 3, 2]
+b = a
+mg.render(locals(), 'rebinding1.png')
+
+a += [1]        # changes the value of 'a' and 'b'
+a = [100, 200]  # rebinds 'a' to a new value, 'b' is uneffected
+mg.render(locals(), 'rebinding2.png')
+```
+| ![rebinding1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding1.png) | ![rebinding2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| rebinding1.png | rebinding2.png |
 
 ## 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 +270,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 +282,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 +337,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 +480,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)
@@ -551,9 +568,9 @@ 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 |
+| 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.
+Additionally, the simplification hides away 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:
@@ -779,3 +796,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.13/memory_graph.egg-info/PKG-INFO → memory_graph-0.3.15/README.md

@@ -1,22 +1,3 @@
-Metadata-Version: 2.1
-Name: memory_graph
-Version: 0.3.13
-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)
@@ -147,6 +127,7 @@ import memory_graph as mg
 a = (4, 3, 2)
 b = a
 mg.render(locals(), 'immutable1.png')
+
 a += (1,)
 mg.render(locals(), 'immutable2.png')
 ```
@@ -164,6 +145,7 @@ import memory_graph as mg
 a = [4, 3, 2]
 b = a
 mg.render(locals(), 'mutable1.png')
+
 a += [1] # equivalent to:  a.append(1)
 mg.render(locals(), 'mutable2.png')
 ```
@@ -197,7 +179,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
@@ -222,9 +204,26 @@ mg.show(locals())
 ```
 ![copy_method.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_method.png)
 
+### Name Rebinding ###
+When `a` and `b` share a mutable value, then changing the value of `a` changes the value of `b` and vice versa. However, reassigning the value of `a` does not change `b`. When you reassign `a`, you only rebind the name `a` to a new value without effecting any other variables.
+
+```python
+import memory_graph as mg
+
+a = [4, 3, 2]
+b = a
+mg.render(locals(), 'rebinding1.png')
+
+a += [1]        # changes the value of 'a' and 'b'
+a = [100, 200]  # rebinds 'a' to a new value, 'b' is uneffected
+mg.render(locals(), 'rebinding2.png')
+```
+| ![rebinding1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding1.png) | ![rebinding2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| rebinding1.png | rebinding2.png |
 
 ## 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)
@@ -551,9 +549,9 @@ 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 |
+| 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.
+Additionally, the simplification hides away 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:
@@ -779,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.15/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.15/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.15/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.15/images/cmp.sh

@@ -0,0 +1,3 @@
+xdg-open $1
+sleep 0.3
+xdg-open ../images_old/$1

memory_graph-0.3.15/images/cmp.sh~

@@ -0,0 +1 @@
+o $1 && sleep 0.3 && o ../images_old/$1

memory_graph-0.3.15/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.15/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.15/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 "%H %Wx%H %f\n" $name*.png | sort -nr | head -n1| awk '{print $2}')
+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"

memory_graph-0.3.15/images/create_images.sh

@@ -0,0 +1,36 @@
+# intro
+python many_types.py
+
+# debugging
+python debugging.py
+bash create_gif.sh debugging
+
+# data model
+python immutable.py
+python mutable.py
+python copies.py
+python copy_method.py
+python name_rebinding.py
+
+# call stack
+python add_one.py
+python factorial.py
+bash create_gif.sh factorial
+python power_set.py
+bash create_gif.sh power_set
+
+# datastructures
+python linked_list.py
+python bin_tree.py
+python hash_set.py
+
+# configuration
+python not_node_types.py
+python highlight.py
+
+# extensions
+python extension_numpy.py
+python extension_pandas.py
+
+# introspection
+python avltree.py

memory_graph-0.3.15/images/debugging.py

@@ -0,0 +1,19 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+image=0
+def get_fac_name():
+    global image
+    image+=1
+    return f"debugging{image:02d}.png"
+
+squares = []
+squares_collector = []
+for i in range(1,6):
+    squares.append(i**2)
+    squares_collector.append(squares.copy())
+    mg.render(locals(), get_fac_name())
+mg.render(locals(), get_fac_name())