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

{memory_graph-0.3.11/memory_graph.egg-info → memory_graph-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.11
+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
@@ -156,7 +156,7 @@ mg.render(locals(), 'immutable2.png')
 
 
 ### Mutable Type ###
-With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy so that `a` and `b` are independent.
+With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
 
 ```python
 import memory_graph as mg
@@ -264,7 +264,7 @@ This function:
 * then blocks execution until the <Enter> key is pressed
 * finally returns the value of the `fun()` call
 
-to change it's 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 <Enter> to continue...".
 
@@ -326,7 +326,7 @@ For the best debugging experience with memory_graph set for example expression:
 ```
 mg.render(locals(), "my_graph.pdf")
 ```
-as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()`, `render()` calls to your code.
+as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
 The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
@@ -511,7 +511,7 @@ for i in range(n):
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
 - ***mg.config.max_graph_depth*** : int
-  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short.
+  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short. Dashed references indicate that there are more references to a node than are shown.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -535,7 +535,7 @@ Different aspects of memory_graph can be configured. The default configuration i
   - 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.
 
 ### Temporary Configuration ###
-In addition to the global configuration, a temporary configuration can be set for a single `show()`, `render()`, `d()`, `ds()` 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:
+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:
 
 ```python
 import memory_graph as mg
@@ -750,7 +750,7 @@ Then after starting 'ipython' call function `mg_switch()` to turn on/off the aut
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)
 
 ## In the Browser ##
-We can run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
+We can also run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
 ![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##

{memory_graph-0.3.11 → memory_graph-0.3.12}/README.md

@@ -137,7 +137,7 @@ mg.render(locals(), 'immutable2.png')
 
 
 ### Mutable Type ###
-With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy so that `a` and `b` are independent.
+With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
 
 ```python
 import memory_graph as mg
@@ -245,7 +245,7 @@ This function:
 * then blocks execution until the <Enter> key is pressed
 * finally returns the value of the `fun()` call
 
-to change it's 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 <Enter> to continue...".
 
@@ -307,7 +307,7 @@ For the best debugging experience with memory_graph set for example expression:
 ```
 mg.render(locals(), "my_graph.pdf")
 ```
-as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()`, `render()` calls to your code.
+as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
 The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
@@ -492,7 +492,7 @@ for i in range(n):
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
 - ***mg.config.max_graph_depth*** : int
-  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short.
+  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short. Dashed references indicate that there are more references to a node than are shown.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -516,7 +516,7 @@ Different aspects of memory_graph can be configured. The default configuration i
   - 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.
 
 ### Temporary Configuration ###
-In addition to the global configuration, a temporary configuration can be set for a single `show()`, `render()`, `d()`, `ds()` 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:
+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:
 
 ```python
 import memory_graph as mg
@@ -731,7 +731,7 @@ Then after starting 'ipython' call function `mg_switch()` to turn on/off the aut
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)
 
 ## In the Browser ##
-We can run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
+We can also run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
 ![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##

memory_graph-0.3.12/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.12/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.12/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.12/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.12/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.12/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.12/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"

memory_graph-0.3.12/images/create_images.sh

@@ -0,0 +1,34 @@
+# 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
+
+# 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 highlight.py
+
+# extensions
+python extension_numpy.py
+python extension_pandas.py
+
+# introspection
+python avltree.py

memory_graph-0.3.12/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())

memory_graph-0.3.12/images/extension_numpy.py

@@ -0,0 +1,14 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+import numpy as np
+import memory_graph.extension_numpy
+np.random.seed(0) # use same random numbers each run
+
+array = np.array([1.1, 2, 3, 4, 5])
+matrix = np.matrix([[i*20+j for j in range(20)] for i in range(20)])
+ndarray = np.random.rand(20,20)
+
+mg.render( locals(), "extension_numpy.png")

memory_graph-0.3.12/images/extension_pandas.py

@@ -0,0 +1,17 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+import pandas as pd
+import memory_graph.extension_pandas
+
+series = pd.Series( [i for i in range(20)] )
+dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
+                             "duration": [50, 40, 45] })
+dataframe2 = pd.DataFrame({  'Name'   : [ 'Tom', 'Anna', 'Steve', 'Lisa'],
+                             'Age'    : [    28,     34,      29,     42],
+                             'Length' : [  1.70,   1.66,    1.82,   1.73] },
+                            index=['one', 'two', 'three', 'four']) # with row names
+
+mg.render( locals(), "extension_pandas.png")

memory_graph-0.3.12/images/factorial.py

@@ -0,0 +1,24 @@
+# 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"factorial{image:02d}.png"
+
+def factorial(n):
+    if n==0:
+        return 1
+    #mg.show( mg.get_call_stack(), block=True ) # draw graph
+    mg.render( mg.get_call_stack(), get_fac_name())
+    result = n*factorial(n-1)
+    #mg.show( mg.get_call_stack(), block=True ) # draw graph
+    mg.render( mg.get_call_stack(), get_fac_name())
+    return result
+
+mg.render( mg.get_call_stack(), get_fac_name())
+factorial(3)

memory_graph-0.3.12/images/hash_set.py

@@ -0,0 +1,39 @@
+# 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 HashSet:
+    
+        def __init__(self, capacity=15):
+            self.buckets = [None] * capacity
+    
+        def add(self, value):
+            index = hash(value) % len(self.buckets)
+            if self.buckets[index] is None:
+                self.buckets[index] = []
+            bucket = self.buckets[index]
+            bucket.append(value)
+            if value == 36:
+                mg.render(locals(), "hash_set.png")
+                exit()
+        
+        def contains(self, value):
+            index = hash(value) % len(self.buckets)
+            if self.buckets[index] is None:
+                return False
+            return value in self.buckets[index]
+        
+        def remove(self, value):
+            index = hash(value) % len(self.buckets)
+            if self.buckets[index] is not None:
+                self.buckets[index].remove(value)
+        
+hash_set = HashSet()
+n = 100
+for i in range(n):
+    new_value = random.randrange(n)
+    hash_set.add(new_value)

memory_graph-0.3.12/images/highlight.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
+from memory_graph.slicer import Slicer
+
+data = [ list(range(20)) for i in range(1,5)]
+highlight = data[2]
+
+mg.render( locals(), "highlight.png",
+    colors                = {id(highlight): "red"   }, # set color to "red"
+    vertical_orientations = {id(highlight): False   }, # set horizontal orientation
+    slicers               = {id(highlight): Slicer()}  # set no slicing
+)

memory_graph-0.3.12/images/immutable.py

@@ -0,0 +1,11 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+a = (4, 3, 2)
+b = a
+mg.render(locals(), 'immutable1.png')
+a += (1,)
+mg.render(locals(), 'immutable2.png')

memory_graph-0.3.12/images/jupyter_example.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
+}