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

{memory_graph-0.3.10/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.10
+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
@@ -171,7 +171,7 @@ mg.render(locals(), 'mutable2.png')
 |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
 | mutable1.png | mutable2.png |
 
-One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small which makes copying less of a concern.
+One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small making copying less of a concern.
 
 ### Copying ###
 Python offers three different "copy" options that we will demonstrate using a nested list:
@@ -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:
@@ -337,6 +337,8 @@ The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debug
 | **Visual Studio Code** | `mg.get_call_stack_vscode()` |
 | **Pycharm** | `mg.get_call_stack_pycharm()` |
 
+![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
+
 #### Other Debuggers ####
 For other debuggers, invoke this function within the *watch* context. Then, in the "call_stack.txt" file, identify the slice of functions you wish to include in the call stack.
 ```
@@ -508,8 +510,8 @@ for i in range(n):
 ## Configuration ##
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
-- ***mg.config.max_tree_depth*** : int
-  - The maxium depth of the graph. A `★` symbol indictes where the graph is cut short.
+- ***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. 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.
@@ -533,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
@@ -554,7 +556,7 @@ mg.show( locals(),
 Different extensions are available for types from other Python packages. 
 
 ### Numpy ###
-Numpy types `arrray` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
 
 ```python
 import memory_graph as mg
@@ -740,7 +742,7 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ## 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.
 
-Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/sc/auto_memory_graph.py) in the ipython startup directory:
+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\
 
@@ -748,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.10 → 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
@@ -152,7 +152,7 @@ mg.render(locals(), 'mutable2.png')
 |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
 | mutable1.png | mutable2.png |
 
-One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small which makes copying less of a concern.
+One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small making copying less of a concern.
 
 ### Copying ###
 Python offers three different "copy" options that we will demonstrate using a nested list:
@@ -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:
@@ -318,6 +318,8 @@ The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debug
 | **Visual Studio Code** | `mg.get_call_stack_vscode()` |
 | **Pycharm** | `mg.get_call_stack_pycharm()` |
 
+![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
+
 #### Other Debuggers ####
 For other debuggers, invoke this function within the *watch* context. Then, in the "call_stack.txt" file, identify the slice of functions you wish to include in the call stack.
 ```
@@ -489,8 +491,8 @@ for i in range(n):
 ## Configuration ##
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
-- ***mg.config.max_tree_depth*** : int
-  - The maxium depth of the graph. A `★` symbol indictes where the graph is cut short.
+- ***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. 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.
@@ -514,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
@@ -535,7 +537,7 @@ mg.show( locals(),
 Different extensions are available for types from other Python packages. 
 
 ### Numpy ###
-Numpy types `arrray` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
 
 ```python
 import memory_graph as mg
@@ -721,7 +723,7 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ## 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.
 
-Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/sc/auto_memory_graph.py) in the ipython startup directory:
+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\
 
@@ -729,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.10 → memory_graph-0.3.12}/memory_graph/__init__.py

@@ -13,7 +13,7 @@ import sys
 
 import graphviz
 
-__version__ = "0.3.10"
+__version__ = "0.3.12"
 __author__ = 'Bas Terwijn'
 render_filename = 'memory_graph.pdf'
 block_prints_location = True
@@ -167,7 +167,9 @@ def stack_frames_to_dict(frames):
     """ Returns a dictionary representing the data on the call stack. 
     Each key is the stack level and function name, each value is the locals of the frame at that level. 
     """
-    return {f"{level}: {frameInfo.function}" : frameInfo.frame.f_locals
+    def to_dict(value): #  fix by TerenceTux for Python 3.13
+        return {k: v for k, v in value.items()}
+    return {f"{level}: {frameInfo.function}" : to_dict(frameInfo.frame.f_locals)
             for level, frameInfo in enumerate(frames)}
 
 def get_call_stack(up_to_function="<module>",stack_index=0):

{memory_graph-0.3.10 → memory_graph-0.3.12}/memory_graph/config.py

@@ -4,7 +4,8 @@
 
 """ Configuration file for the graph visualizer. The configuration values are set later by the 'config_default.py' file. """
 
-max_tree_depth = None
+max_graph_depth = None
+graph_cut_symbol = None
 max_missing_edges = None
 max_string_length = None
 graph_stability = None

{memory_graph-0.3.10 → memory_graph-0.3.12}/memory_graph/config_default.py

@@ -16,8 +16,8 @@ import memory_graph.utils as utils
 import types
 
 """ The maximum depth of nodes in the graph. When the graph gets too big set this to a small positive number. A `✂` symbol indictes where the graph is cut short. """
-config.max_tree_depth = -1
-
+config.max_graph_depth = 12
+config.graph_cut_symbol = '✂'
 config.max_missing_edges = 3
 
 """ The maximum length of strings shown in the graph. Longer strings will be truncated. """

{memory_graph-0.3.10 → memory_graph-0.3.12}/memory_graph/html_table.py

@@ -80,7 +80,7 @@ class HTML_Table:
             if child_id in id_to_slices:
                 self.add_reference(node, child, rounded, border, dashed)
             else:
-                self.add_value("✂", rounded, border)
+                self.add_value(config.graph_cut_symbol, rounded, border)
         else:
             self.add_value(child, rounded, border)
 

{memory_graph-0.3.10 → memory_graph-0.3.12}/memory_graph/memory_to_nodes.py

@@ -45,10 +45,10 @@ def read_nodes(data):
 
 # --------------------------------------------------------------------------------------------
 
-def slice_nodes(nodes, root_id, max_tree_depth):
+def slice_nodes(nodes, root_id, max_graph_depth):
 
-    def slice_nodes_recursive(nodes, node_id, id_to_slices, max_tree_depth):
-        if max_tree_depth == 0 or node_id in id_to_slices:
+    def slice_nodes_recursive(nodes, node_id, id_to_slices, max_graph_depth):
+        if max_graph_depth == 0 or node_id in id_to_slices:
             return
         if node_id in nodes:
             node = nodes[node_id]
@@ -60,11 +60,11 @@ def slice_nodes(nodes, root_id, max_tree_depth):
                 slices = children.slice(slicer)
                 id_to_slices[node_id] = slices
                 if not node.is_hidden_node():
-                    max_tree_depth -= 1
+                    max_graph_depth -= 1
                 for index in slices:
-                    slice_nodes_recursive(nodes, id(children[index]), id_to_slices, max_tree_depth)
+                    slice_nodes_recursive(nodes, id(children[index]), id_to_slices, max_graph_depth)
     id_to_slices = {}
-    slice_nodes_recursive(nodes, root_id, id_to_slices, max_tree_depth)
+    slice_nodes_recursive(nodes, root_id, id_to_slices, max_graph_depth)
     return id_to_slices
 
 # --------------------------------------------------------------------------------------------
@@ -175,7 +175,7 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
 def memory_to_nodes(data):
     nodes, root_id = read_nodes(data)
     #print('nodes:',nodes,'root_id:',root_id)
-    id_to_slices = slice_nodes(nodes, root_id, config.max_tree_depth)
+    id_to_slices = slice_nodes(nodes, root_id, config.max_graph_depth)
     #print('id_to_slices:',id_to_slices)
     id_to_slices = add_missing_edges(nodes, id_to_slices, config.max_missing_edges)
     #print('id_to_slices:',id_to_slices)

{memory_graph-0.3.10 → memory_graph-0.3.12}/memory_graph/test.py

@@ -214,7 +214,7 @@ class BinTree:
 
 def test_missing_edges(fun):
     random.seed(0)
-    config.max_tree_depth = 7
+    config.max_graph_depth = 7
     config.max_missing_edges = 5
     tree = BinTree()
     last_node = None

memory_graph-0.3.12/memory_graph/test_max_graph_depth.py

@@ -0,0 +1,27 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+def build_nested_list(depth = 15):
+    first = [1,2]
+    last = first
+    if depth>0:
+        first2, last = build_nested_list(depth-1)
+        first.append(first2)
+    return first, last
+
+first,last = build_nested_list(15)
+for i in range(20):
+    last.append('X')
+
+child = ('who', 'are', 'my', 'parents?')
+last[4] = child
+last[5] = child
+last[6] = child
+last[7] = child
+last[8] = child
+
+mg.show([first,child])
+#mg.show([first])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.10
+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
@@ -171,7 +171,7 @@ mg.render(locals(), 'mutable2.png')
 |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
 | mutable1.png | mutable2.png |
 
-One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small which makes copying less of a concern.
+One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small making copying less of a concern.
 
 ### Copying ###
 Python offers three different "copy" options that we will demonstrate using a nested list:
@@ -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:
@@ -337,6 +337,8 @@ The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debug
 | **Visual Studio Code** | `mg.get_call_stack_vscode()` |
 | **Pycharm** | `mg.get_call_stack_pycharm()` |
 
+![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
+
 #### Other Debuggers ####
 For other debuggers, invoke this function within the *watch* context. Then, in the "call_stack.txt" file, identify the slice of functions you wish to include in the call stack.
 ```
@@ -508,8 +510,8 @@ for i in range(n):
 ## Configuration ##
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
-- ***mg.config.max_tree_depth*** : int
-  - The maxium depth of the graph. A `★` symbol indictes where the graph is cut short.
+- ***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. 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.
@@ -533,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
@@ -554,7 +556,7 @@ mg.show( locals(),
 Different extensions are available for types from other Python packages. 
 
 ### Numpy ###
-Numpy types `arrray` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
 
 ```python
 import memory_graph as mg
@@ -740,7 +742,7 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ## 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.
 
-Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/sc/auto_memory_graph.py) in the ipython startup directory:
+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\
 
@@ -748,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.10 → memory_graph-0.3.12}/memory_graph.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ images/copy_method.png
 images/copy_method.py
 images/create_gif.sh
 images/create_images.sh
+images/debug_vscode.png
 images/debugging.gif
 images/debugging.py
 images/extension_numpy.png
@@ -69,6 +70,7 @@ memory_graph/slices.py
 memory_graph/slices_iterator.py
 memory_graph/slices_table_iterator.py
 memory_graph/test.py
+memory_graph/test_max_graph_depth.py
 memory_graph/test_memory_graph.py
 memory_graph/test_memory_to_nodes.py
 memory_graph/test_sequence.py

{memory_graph-0.3.10 → memory_graph-0.3.12}/setup.py

@@ -11,7 +11,7 @@ long_description_from_readme = (this_directory / "README.md").read_text()
 
 setup(
     name = 'memory_graph',
-    version = '0.3.10',
+    version = '0.3.12',
     description = 'Draws a graph of your data to analyze its structure.',
     long_description = long_description_from_readme,
     long_description_content_type = 'text/markdown',

{memory_graph-0.3.10 → memory_graph-0.3.12}/src/auto_memory_graph.py

@@ -8,9 +8,12 @@ def mg_visualization(execution_result):
     ipython_locals = get_ipython().user_ns
     mg.show(mg.ipython_locals_filter(ipython_locals))
 
-def mg_switch():
+def mg_switch(status = None):
     global mg_visualization_status
-    mg_visualization_status = not mg_visualization_status
+    if isinstance(status, bool):
+        mg_visualization_status = status
+    else:
+        mg_visualization_status = not mg_visualization_status
     if mg_visualization_status:
         get_ipython().events.register("post_run_cell", mg_visualization)
     else:

{memory_graph-0.3.10 → memory_graph-0.3.12}/src/pyodide.html

@@ -54,7 +54,9 @@
 </head>
 <body>
   <div class="container">
-    <div class="part"><!-- ========== Top Left ========== --> <p>Log:</p>
+    <div class="part"><!-- ========== Top Left ========== --> 
+      <p>See the <a href="https://pypi.org/project/memory-graph/" style="font-size: 1.5em;">memory_graph</a> python package.<br>
+      Log:</p>
       <textarea id="log"></textarea>
     </div>
     
@@ -67,7 +69,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    print("display the call stack")
+    print("display a graph of the call stack")
     js.display(mg.create_graph(mg.get_call_stack()))
 
 print("initialize test data")
@@ -76,9 +78,10 @@ b = (4, 3, 2)
 c = [4, 3, 2]
 print(f"a:{a} b:{b} c:{c}")
 
-print("call function add_one()")
+print("call function: add_one(a, b, c.copy())")
 add_one(a, b, c.copy())
 print(f"a:{a} b:{b} c:{c}")
+print("only 'a' has changed, the graph explains why")
     </textarea>
     <button id="run-button" disabled>Run</button>
     </div>