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

{memory_graph-0.3.15/memory_graph.egg-info → memory_graph-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.15
+Version: 0.3.17
 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
@@ -199,7 +199,7 @@ mg.show(locals())
 
 
 ### 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.
+We can write our own custom copy function or method in case the three standard "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
 import memory_graph as mg
@@ -242,7 +242,7 @@ mg.render(locals(), '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. 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`.
+The `mg.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
@@ -251,7 +251,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    mg.show(mg.get_call_stack())
+    mg.show(mg.stack())
 
 a = [4, 3, 2]
 b = (4, 3, 2)
@@ -295,9 +295,9 @@ import memory_graph as mg
 def factorial(n):
     if n==0:
         return 1
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     result = n * factorial(n-1)
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print(factorial(3))
@@ -314,7 +314,7 @@ A more interesting recursive example that shows sharing of data is power_set().
 import memory_graph as mg
 
 def get_subsets(subsets, data, i, subset):
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     if i == len(data):
         subsets.append(subset.copy())
         return
@@ -322,7 +322,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
 
 def power_set(data):
     subsets = []
@@ -346,13 +346,13 @@ 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()` 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:
+The ```mg.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:
 
 | debugger | function to get the call stack |
 |:---|:---|
-| **pdb, pudb** | `mg.get_call_stack_pdb()` |
-| **Visual Studio Code** | `mg.get_call_stack_vscode()` |
-| **Pycharm** | `mg.get_call_stack_pycharm()` |
+| **pdb, pudb** | `mg.stack_pdb()` |
+| **Visual Studio Code** | `mg.stack_vscode()` |
+| **Pycharm** | `mg.stack_pycharm()` |
 
 ![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
 
@@ -363,7 +363,7 @@ mg.save_call_stack("call_stack.txt")
 ```
 Choose 'after' and 'up_to' what function you want to slice and then call this function to get the desired call stack:
 ```
-mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
+mg.stack_after_up_to(after_function, up_to_function="<module>")
 ```
 
 ### Debugging without Debugger Tool ###
@@ -373,13 +373,13 @@ To simplify debugging without a debugger tool, we offer these alias functions th
 | alias | purpose | function call |
 |:---|:---|:---|
 | `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.ss()` | **s**how the call **s**tack | `mg.show(mg.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.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.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.rs()` | **r**ender the call **s**tack | `mg.render(mg.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.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.stack())` |
 | `mg.l()` | same as `mg.bsl()` |  |
 | `mg.s()` | same as `mg.bss()` |  |
 
@@ -430,7 +430,7 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
-        mg.block(mg.show, locals()) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw locals
 
 linked_list = LinkedList()
 n = 100
@@ -446,42 +446,33 @@ 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 __init__(self, value=None, smaller=None, larger=None):
+        self.smaller = smaller
+        self.value = value
+        self.larger = larger
 
-    def add_recursive(self, new_value, node):
-        if new_value < node.value:
-            if node.smaller is None:
-                node.smaller = Node(new_value)
+    def add(self, value):
+        if self.value is None:
+            self.value = value
+        elif value < self.value:
+            if self.smaller is None:
+                self.smaller = BinTree(value)
             else:
-                self.add_recursive(new_value, node.smaller)
+                self.smaller.add(value)
         else:
-            if node.larger is None:
-                node.larger = Node(new_value)
+            if self.larger is None:
+                self.larger = BinTree(value)
             else:
-                self.add_recursive(new_value, node.larger)
-        mg.block(mg.show, locals()) # <--- draw graph
-
-    def add(self, value):
-        if self.root is None:
-            self.root = Node(value)
-        else:
-            self.add_recursive(value, self.root)
+                self.larger.add(value)
+        mg.block(mg.show, mg.stack()) # <--- draw stack
 
 tree = BinTree()
 n = 100
 for i in range(n):
-    new_value = random.randrange(n)
-    tree.add(new_value)
+    value = random.randrange(n)
+    tree.add(value)
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
 
@@ -502,7 +493,7 @@ class HashSet:
             self.buckets[index] = []
         bucket = self.buckets[index]
         bucket.append(value)
-        mg.block(mg.show, locals()) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw locals
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -552,7 +543,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.
 
 ### Simplified Graph ###
-Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.
 
 The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
 ```python
@@ -765,7 +756,7 @@ mg.show(locals())
 
 
 ## 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.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:
 
@@ -778,11 +769,11 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
-In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_ipython()` to get the whole call stack with these variables filtered out.
+In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.stack_ipython()` to get the whole call stack with these variables filtered out.
 
 Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/auto_memory_graph.py) in the ipython startup directory:
-* Linux/Mac: ~/.ipython/profile_default/startup/
-* Windows: %USERPROFILE%\.ipython\profile_default\startup\
+* Linux/Mac: `~/.ipython/profile_default/startup/`
+* Windows: `%USERPROFILE%\.ipython\profile_default\startup\`
 
 Then after starting 'ipython' call function `mg_switch()` to turn on/off the automatic visualization of local variables after each command.
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)

{memory_graph-0.3.15 → memory_graph-0.3.17}/README.md

@@ -180,7 +180,7 @@ mg.show(locals())
 
 
 ### 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.
+We can write our own custom copy function or method in case the three standard "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
 import memory_graph as mg
@@ -223,7 +223,7 @@ mg.render(locals(), '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. 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`.
+The `mg.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
@@ -232,7 +232,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    mg.show(mg.get_call_stack())
+    mg.show(mg.stack())
 
 a = [4, 3, 2]
 b = (4, 3, 2)
@@ -276,9 +276,9 @@ import memory_graph as mg
 def factorial(n):
     if n==0:
         return 1
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     result = n * factorial(n-1)
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print(factorial(3))
@@ -295,7 +295,7 @@ A more interesting recursive example that shows sharing of data is power_set().
 import memory_graph as mg
 
 def get_subsets(subsets, data, i, subset):
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     if i == len(data):
         subsets.append(subset.copy())
         return
@@ -303,7 +303,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
 
 def power_set(data):
     subsets = []
@@ -327,13 +327,13 @@ 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()` 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:
+The ```mg.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:
 
 | debugger | function to get the call stack |
 |:---|:---|
-| **pdb, pudb** | `mg.get_call_stack_pdb()` |
-| **Visual Studio Code** | `mg.get_call_stack_vscode()` |
-| **Pycharm** | `mg.get_call_stack_pycharm()` |
+| **pdb, pudb** | `mg.stack_pdb()` |
+| **Visual Studio Code** | `mg.stack_vscode()` |
+| **Pycharm** | `mg.stack_pycharm()` |
 
 ![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
 
@@ -344,7 +344,7 @@ mg.save_call_stack("call_stack.txt")
 ```
 Choose 'after' and 'up_to' what function you want to slice and then call this function to get the desired call stack:
 ```
-mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
+mg.stack_after_up_to(after_function, up_to_function="<module>")
 ```
 
 ### Debugging without Debugger Tool ###
@@ -354,13 +354,13 @@ To simplify debugging without a debugger tool, we offer these alias functions th
 | alias | purpose | function call |
 |:---|:---|:---|
 | `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.ss()` | **s**how the call **s**tack | `mg.show(mg.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.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.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.rs()` | **r**ender the call **s**tack | `mg.render(mg.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.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.stack())` |
 | `mg.l()` | same as `mg.bsl()` |  |
 | `mg.s()` | same as `mg.bss()` |  |
 
@@ -411,7 +411,7 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
-        mg.block(mg.show, locals()) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw locals
 
 linked_list = LinkedList()
 n = 100
@@ -427,42 +427,33 @@ 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 __init__(self, value=None, smaller=None, larger=None):
+        self.smaller = smaller
+        self.value = value
+        self.larger = larger
 
-    def add_recursive(self, new_value, node):
-        if new_value < node.value:
-            if node.smaller is None:
-                node.smaller = Node(new_value)
+    def add(self, value):
+        if self.value is None:
+            self.value = value
+        elif value < self.value:
+            if self.smaller is None:
+                self.smaller = BinTree(value)
             else:
-                self.add_recursive(new_value, node.smaller)
+                self.smaller.add(value)
         else:
-            if node.larger is None:
-                node.larger = Node(new_value)
+            if self.larger is None:
+                self.larger = BinTree(value)
             else:
-                self.add_recursive(new_value, node.larger)
-        mg.block(mg.show, locals()) # <--- draw graph
-
-    def add(self, value):
-        if self.root is None:
-            self.root = Node(value)
-        else:
-            self.add_recursive(value, self.root)
+                self.larger.add(value)
+        mg.block(mg.show, mg.stack()) # <--- draw stack
 
 tree = BinTree()
 n = 100
 for i in range(n):
-    new_value = random.randrange(n)
-    tree.add(new_value)
+    value = random.randrange(n)
+    tree.add(value)
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
 
@@ -483,7 +474,7 @@ class HashSet:
             self.buckets[index] = []
         bucket = self.buckets[index]
         bucket.append(value)
-        mg.block(mg.show, locals()) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw locals
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -533,7 +524,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.
 
 ### Simplified Graph ###
-Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.
 
 The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
 ```python
@@ -746,7 +737,7 @@ mg.show(locals())
 
 
 ## 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.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:
 
@@ -759,11 +750,11 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
-In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_ipython()` to get the whole call stack with these variables filtered out.
+In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.stack_ipython()` to get the whole call stack with these variables filtered out.
 
 Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/auto_memory_graph.py) in the ipython startup directory:
-* Linux/Mac: ~/.ipython/profile_default/startup/
-* Windows: %USERPROFILE%\.ipython\profile_default\startup\
+* Linux/Mac: `~/.ipython/profile_default/startup/`
+* Windows: `%USERPROFILE%\.ipython\profile_default\startup\`
 
 Then after starting 'ipython' call function `mg_switch()` to turn on/off the automatic visualization of local variables after each command.
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)

memory_graph-0.3.17/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.17/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.15 → memory_graph-0.3.17}/images/add_one.py

@@ -8,7 +8,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    mg.render( mg.get_call_stack(), "add_one.png")
+    mg.render( mg.stack(), "add_one.png")
 
 a = [4, 3, 2]
 b = (4, 3, 2)

memory_graph-0.3.17/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.17/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.17/images/bin_tree.py

@@ -0,0 +1,38 @@
+# 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 BinTree:
+
+    def __init__(self, value=None, smaller=None, larger=None):
+        self.smaller = smaller
+        self.value = value
+        self.larger = larger
+
+    def add(self, value):
+        if self.value is None:
+            self.value = value
+        elif value < self.value:
+            if self.smaller is None:
+                self.smaller = BinTree(value)
+            else:
+                self.smaller.add(value)
+        else:
+            if self.larger is None:
+                self.larger = BinTree(value)
+            else:
+                self.larger.add(value)
+        if value == 51:
+            mg.render(mg.stack(), f"bin_tree.png")
+            exit(0)
+
+tree = BinTree()
+n = 100
+for i in range(n):
+    value = random.randrange(n)
+    tree.add(value)
+