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

memory_graph-0.3.14/MANIFEST.in

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

{memory_graph-0.3.13/memory_graph.egg-info → memory_graph-0.3.14}/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.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)
 
-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.
+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'
+```
+
+# 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)
@@ -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 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.13 → memory_graph-0.3.14}/README.md

@@ -5,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)
 
-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.
+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'
+```
+
+# 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> 
 
@@ -48,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)
@@ -178,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
@@ -205,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
@@ -233,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, ...) 
@@ -245,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...".
 
@@ -300,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:
@@ -444,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)
@@ -532,9 +530,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 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:
@@ -760,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/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.14/images/.ipynb_checkpoints/jupyter_example-checkpoint.ipynb

@@ -0,0 +1,85 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "23f6d43f-dd17-4020-971e-5bb8a5b1e30b",
+   "metadata": {},
+   "source": [
+    "# test: locals_jupyter()\n",
+    "Show a graph build with the filtered Jupyter locals using function `mg.locals_jupyter()`. Just adding integers to a list:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8913787-bbef-4adb-b027-ac0f28500233",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import memory_graph as mg\n",
+    "\n",
+    "data = []\n",
+    "for i in range(5):\n",
+    "    data.append(i)\n",
+    "    display(mg.create_graph(mg.locals_jupyter())) # display in jupyter notebook\n",
+    "    mg.block(mg.show, mg.locals_jupyter()) # display in PDF reader\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f66d9b8d-0937-4ad0-97b4-a7459e84c4f2",
+   "metadata": {},
+   "source": [
+    "# test: get_call_stack_jupyter()\n",
+    "Show a graph build the filterd Jupyter call stack from function `mg.get_call_stack_jupyter()`. Recursively filling a list with all permutation of elements with resampling:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15d0c443-7cc6-4b4f-a9db-598aaf261364",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import memory_graph as mg\n",
+    "\n",
+    "def get_all_permutations(permutations, elements, data, max_length):\n",
+    "    if len(data) == max_length: # recursive stop condition\n",
+    "        permutations.append(data.copy())\n",
+    "    else:\n",
+    "        for i in elements:\n",
+    "            data.append(i)\n",
+    "            mg.block(mg.show, mg.get_call_stack_jupyter())\n",
+    "            get_all_permutations(permutations, elements, data, max_length)\n",
+    "            data.pop()\n",
+    "            mg.block(mg.show, mg.get_call_stack_jupyter())\n",
+    "\n",
+    "permutations = []\n",
+    "get_all_permutations(permutations, ['L','R'], [], 3)\n",
+    "print(permutations)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

memory_graph-0.3.14/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.14/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.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.14/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.14/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.14/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')