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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.9
+Version: 0.3.11
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -91,7 +91,7 @@ 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' (default value: 'memory_graph.pdf')
+mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
 ```
 
 # Chapters #
@@ -112,6 +112,10 @@ mg.render(data) # renders to 'mg.render_filename' (default value: 'memory_graph.
 
 [Jupyter Notebook](#jupyter-notebook)
 
+[ipython](#ipython)
+
+[In the Browser](#in-the-browser)
+
 [Troubleshooting](#troubleshooting)
 
 
@@ -152,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 `b` is independent from `a`.
+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.
 
 ```python
 import memory_graph as mg
@@ -167,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 could be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much or are smaller, 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:
@@ -220,7 +224,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. 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`.
 
 ```python
 import memory_graph as mg
@@ -254,9 +258,15 @@ It is often helpful to temporarily block program execution to inspect the graph.
 mg.block(fun, arg1, arg2, ...) 
 ```
 
-This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. 
-Set `mg.block_shows_location = False` to skip printing the source location.
-Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
+This function:
+* first executes `fun(arg1, arg2, ...)`
+* then prints the current source location in the program
+* then blocks execution until the &lt;Enter&gt; key is pressed
+* finally returns the value of the `fun()` call
+
+to change it's 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...".
 
 ### Recursion ###
 The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
@@ -327,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.
 ```
@@ -498,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.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -544,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
@@ -620,9 +632,9 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_dir.png)
 
-Next figure out what are the attributes you want to graph and choose a Node type, there are four options.
+Next figure out what are the attributes you want to graph and choose a Node type, there are four options:
 
-### 1 Node_Base ###
+### 1) Node_Base ###
 Node_base is a leaf node (with no children) and shows just a single value.
 ```python
 import memory_graph as mg
@@ -642,7 +654,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
 
-### 2 Node_Linear ###
+### 2) Node_Linear ###
 Node_Linear shows all the values in a line like a list.
 ```python
 import memory_graph as mg
@@ -666,7 +678,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_linear.png)
 
-### 3 Node_Key_Value ###
+### 3) Node_Key_Value ###
 Node_Key_Value shows key-value pairs like a dictionary. Note the required `items()` call at the end.
 ```python
 import memory_graph as mg
@@ -690,7 +702,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_key_value.png)
 
-### 4 Node_Table ###
+### 4) Node_Table ###
 Node_Table shows all the values as a table.
 ```python
 import memory_graph as mg
@@ -727,6 +739,19 @@ mg.block(display, mg.create_graph(mg.locals_jupyter()) ) # the same but blocked
 See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.ipynb).
 ![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.
+
+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\
+
+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)
+
+## 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>
+![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##
 

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

@@ -72,7 +72,7 @@ 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' (default value: 'memory_graph.pdf')
+mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
 ```
 
 # Chapters #
@@ -93,6 +93,10 @@ mg.render(data) # renders to 'mg.render_filename' (default value: 'memory_graph.
 
 [Jupyter Notebook](#jupyter-notebook)
 
+[ipython](#ipython)
+
+[In the Browser](#in-the-browser)
+
 [Troubleshooting](#troubleshooting)
 
 
@@ -133,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 `b` is independent from `a`.
+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.
 
 ```python
 import memory_graph as mg
@@ -148,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 could be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much or are smaller, 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:
@@ -201,7 +205,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. 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`.
 
 ```python
 import memory_graph as mg
@@ -235,9 +239,15 @@ It is often helpful to temporarily block program execution to inspect the graph.
 mg.block(fun, arg1, arg2, ...) 
 ```
 
-This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the <Enter> key is pressed. 
-Set `mg.block_shows_location = False` to skip printing the source location.
-Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
+This function:
+* first executes `fun(arg1, arg2, ...)`
+* then prints the current source location in the program
+* then blocks execution until the &lt;Enter&gt; key is pressed
+* finally returns the value of the `fun()` call
+
+to change it's 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...".
 
 ### Recursion ###
 The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
@@ -308,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.
 ```
@@ -479,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.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -525,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
@@ -601,9 +613,9 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_dir.png)
 
-Next figure out what are the attributes you want to graph and choose a Node type, there are four options.
+Next figure out what are the attributes you want to graph and choose a Node type, there are four options:
 
-### 1 Node_Base ###
+### 1) Node_Base ###
 Node_base is a leaf node (with no children) and shows just a single value.
 ```python
 import memory_graph as mg
@@ -623,7 +635,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
 
-### 2 Node_Linear ###
+### 2) Node_Linear ###
 Node_Linear shows all the values in a line like a list.
 ```python
 import memory_graph as mg
@@ -647,7 +659,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_linear.png)
 
-### 3 Node_Key_Value ###
+### 3) Node_Key_Value ###
 Node_Key_Value shows key-value pairs like a dictionary. Note the required `items()` call at the end.
 ```python
 import memory_graph as mg
@@ -671,7 +683,7 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_key_value.png)
 
-### 4 Node_Table ###
+### 4) Node_Table ###
 Node_Table shows all the values as a table.
 ```python
 import memory_graph as mg
@@ -708,6 +720,19 @@ mg.block(display, mg.create_graph(mg.locals_jupyter()) ) # the same but blocked
 See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.ipynb).
 ![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.
+
+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\
+
+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)
+
+## 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>
+![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##
 

{memory_graph-0.3.9 → memory_graph-0.3.11}/memory_graph/__init__.py

@@ -13,15 +13,15 @@ import sys
 
 import graphviz
 
-__version__ = "0.3.09"
+__version__ = "0.3.11"
 __author__ = 'Bas Terwijn'
 render_filename = 'memory_graph.pdf'
-block_shows_location = True
+block_prints_location = True
 press_enter_message = "Press <Enter> to continue..."
 
-def get_source_location(stack_index):
+def get_source_location(stack_index=0):
     """ Helper function to get the source location of the stack with 'stack_index' of the call stack. """
-    frameInfo = inspect.stack()[stack_index] # get frameInfo of calling frame
+    frameInfo = inspect.stack()[1+stack_index] # get frameInfo of calling frame
     filename= frameInfo.filename
     line_nr= frameInfo.lineno
     function = frameInfo.function
@@ -32,14 +32,15 @@ def block(fun=None, *args, **kwargs):
     Calls the given function `fun` with specified arguments and keyword arguments,
     waits for the user to press Enter, and returns the result of `fun`.
     """
+    stack_index = 0
     if 'stack_index' in kwargs:
         stack_index = kwargs['stack_index']
         del kwargs['stack_index']
     result = None
     if callable(fun):
         result = fun(*args, **kwargs)
-    if memory_graph.block_shows_location:
-        print('blocked at ' + get_source_location(stack_index), end=', ')
+    if memory_graph.block_prints_location:
+        print('blocked at ' + get_source_location(1+stack_index), end=', ')
     if memory_graph.press_enter_message:
         print(memory_graph.press_enter_message)
     input()
@@ -58,7 +59,7 @@ def create_graph(data,
     graphviz_graph = memory_to_nodes.memory_to_nodes(data)
     return graphviz_graph
 
-def show(data ,block=False,
+def show(data, block=False,
                  colors = None,
                  vertical_orientations = None,
                  slicers = None):
@@ -82,84 +83,84 @@ def render(data, outfile=None, block=False,
 
 # ------------ aliases
 
-def sl(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def sl(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of locals() and blocks. 
     """
-    data = get_locals_from_calling_frame(stack_index=stack_index)
+    data = get_locals_from_call_stack(stack_index=1+stack_index)
     memory_graph.show(data, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
     
-def ss(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def ss(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of mg.get_call_stack() and blocks. 
     """
-    data = get_call_stack(stack_index=stack_index)
+    data = get_call_stack(stack_index=1+stack_index)
     memory_graph.show(data, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
 
-def bsl(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def bsl(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of locals() and blocks. 
     """
-    data = get_locals_from_calling_frame(stack_index=stack_index)
-    memory_graph.block(memory_graph.show, data, stack_index=stack_index+1, block=False, 
+    data = get_locals_from_call_stack(stack_index=1+stack_index)
+    memory_graph.block(memory_graph.show, data, stack_index=1+stack_index, block=False, 
                        colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
     
-def bss(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def bss(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of mg.get_call_stack() and blocks. 
     """
-    data = get_call_stack(stack_index=stack_index)
-    memory_graph.block(memory_graph.show, data, stack_index=stack_index+1, block=False, 
+    data = get_call_stack(stack_index=1+stack_index)
+    memory_graph.block(memory_graph.show, data, stack_index=1+stack_index, block=False, 
                        colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
 
-def rl(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def rl(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of locals() and blocks. 
     """
-    data = get_locals_from_calling_frame(stack_index=stack_index)
+    data = get_locals_from_call_stack(stack_index=1+stack_index)
     memory_graph.render(data, block=False, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
     
-def rs(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def rs(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of mg.get_call_stack() and blocks. 
     """
-    data = get_call_stack(stack_index=stack_index)
+    data = get_call_stack(stack_index=1+stack_index)
     memory_graph.render(data, block=False, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
 
-def brl(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def brl(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of locals() and blocks. 
     """
-    data = get_locals_from_calling_frame(stack_index=stack_index)
-    memory_graph.block(memory_graph.render, data, stack_index=stack_index+1, block=False, 
+    data = get_locals_from_call_stack(stack_index=1+stack_index)
+    memory_graph.block(memory_graph.render, data, stack_index=1+stack_index, block=False, 
                        colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
     
-def brs(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def brs(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of mg.get_call_stack() and blocks. 
     """
-    data = get_call_stack(stack_index=stack_index)
-    memory_graph.block(memory_graph.render, data, stack_index=stack_index+1, block=False, 
+    data = get_call_stack(stack_index=1+stack_index)
+    memory_graph.block(memory_graph.render, data, stack_index=1+stack_index, block=False, 
                        colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
 
-def l(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def l(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of locals() and blocks. 
     """
-    bsl(stack_index=stack_index+1, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
+    bsl(stack_index=1+stack_index, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
     
-def s(stack_index=2, colors = None, vertical_orientations = None, slicers = None):
+def s(stack_index=0, colors = None, vertical_orientations = None, slicers = None):
     """ 
     Shows the graph of mg.get_call_stack() and blocks. 
     """
-    bss(stack_index=stack_index+1, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
+    bss(stack_index=1+stack_index, colors=colors, vertical_orientations=vertical_orientations, slicers=slicers)
 
 
 # ------------ call stack
 
-def get_locals_from_calling_frame(stack_index=1):
+def get_locals_from_call_stack(stack_index=0):
     """ Helper function to get locals of the stack with 'stack_inex' of the call stack. """
-    frameInfo = inspect.stack()[stack_index] # get frameInfo of calling frame
+    frameInfo = inspect.stack()[1+stack_index] # get frameInfo of calling frame
     return frameInfo.frame.f_locals
 
 def stack_frames_to_dict(frames):
@@ -169,10 +170,10 @@ def stack_frames_to_dict(frames):
     return {f"{level}: {frameInfo.function}" : frameInfo.frame.f_locals
             for level, frameInfo in enumerate(frames)}
 
-def get_call_stack(up_to_function="<module>",stack_index=1):
+def get_call_stack(up_to_function="<module>",stack_index=0):
     """ Gets the call stack up to the function 'up_to_function'. """
     frames = reversed(list(
-        utils.take_up_to(lambda i: i.function==up_to_function, inspect.stack()[stack_index:])
+        utils.take_up_to(lambda i: i.function==up_to_function, inspect.stack()[1+stack_index:])
         ))
     return stack_frames_to_dict(frames)
 
@@ -197,27 +198,52 @@ def get_call_stack_pycharm(after_function="trace_dispatch",up_to_function="<modu
     return get_call_stack_after_up_to(after_function,up_to_function)
 
 def save_call_stack(filename):
-    """ Save the call stack to 'filename' for inspection to see what functions need to be 
+    """ Saves the call stack to 'filename' for inspection to see what functions need to be 
     filtered out to create the desired graph. """
     with open(filename,'w') as file:
-        for f in inspect.stack():
-            file.write(f"function:{f.function} filename:{f.filename}\n")
-
+        for frame in inspect.stack():
+            file.write(f"function:{frame.function} filename:{frame.filename}\n")
+
+def print_call_stack_vars(stack_index=0):
+    """ Prints all variables on the call stack. """
+    for level, frameInfo in enumerate(reversed(inspect.stack())):
+        print('=====',level,frameInfo.function)
+        print(tuple(frameInfo.frame.f_locals.keys()))
+              
 # ------------ jupyter filtering
-            
+
 jupyter_filter_keys = {'exit','quit','v','In','Out','jupyter_filter_keys'}
 def jupyter_locals_filter(jupyter_locals):
     """ Filter out the jupyter specific keys that polute the graph. """
     return {k:v for k,v in jupyter_locals.items()
             if k not in jupyter_filter_keys and k[0] != '_'}
 
-def locals_jupyter(stack_index=2):
+def locals_jupyter(stack_index=0):
     """ Get the locals of the calling frame in a jupyter notebook, filtering out the jupyter specific keys. """
-    return jupyter_locals_filter(get_locals_from_calling_frame(stack_index))
+    return jupyter_locals_filter(get_locals_from_call_stack(1+stack_index))
 
-def get_call_stack_jupyter(up_to_function="<module>",stack_index=2):
+def get_call_stack_jupyter(up_to_function="<module>",stack_index=0):
     """ Get the call stack in a jupyter notebook, filtering out the jupyter specific keys. """
-    call_stack = get_call_stack(up_to_function,stack_index)
+    call_stack = get_call_stack(up_to_function,1+stack_index)
     globals_frame = next(iter(call_stack))
     call_stack[globals_frame] = jupyter_locals_filter(call_stack[globals_frame])
     return call_stack
+
+# ------------ ipython filtering
+
+ipython_filter_keys = {'mg_visualization_status', 'sys', 'ipython', 'In', 'Out', 'get_ipython', 'exit', 'quit', 'open'}
+def ipython_locals_filter(ipython_locals):
+    """ Filter out the ipython specific keys that polute the graph. """
+    return {k:v for k,v in ipython_locals.items()
+            if k not in ipython_filter_keys and k[0] != '_'}
+
+def locals_ipython(stack_index=0):
+    """ Get the locals of the calling frame in a ipython, filtering out the ipython specific keys. """
+    return ipython_locals_filter(get_locals_from_call_stack(1+stack_index))
+
+def get_call_stack_ipython(up_to_function="<module>",stack_index=0):
+    """ Get the call stack in a ipython, filtering out the ipython specific keys. """
+    call_stack = get_call_stack(up_to_function,1+stack_index)
+    globals_frame = next(iter(call_stack))
+    call_stack[globals_frame] = ipython_locals_filter(call_stack[globals_frame])
+    return call_stack

{memory_graph-0.3.9 → memory_graph-0.3.11}/memory_graph/config.py

@@ -4,9 +4,11 @@
 
 """ 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
 
 not_node_types = {}
 no_child_references_types = set()

{memory_graph-0.3.9 → memory_graph-0.3.11}/memory_graph/config_default.py

@@ -15,14 +15,17 @@ 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
-
+""" 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_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. """
 config.max_string_length = 42
 
+""" The number of references keeping child nodes in order versus other references pullen them out. """
+config.graph_stability = 10
+
 """ Types that by default will not have references pointing to them in the graph but instead will be visualized in the node of their parent. """
 config.not_node_types = {
     type(None), bool, int, float, complex, str,

{memory_graph-0.3.9 → memory_graph-0.3.11}/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.9 → memory_graph-0.3.11}/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
 
 # --------------------------------------------------------------------------------------------
@@ -133,8 +133,7 @@ def create_depth_of_nodes(nodes, nodes_at_depth):
 def add_subgraph(graphviz_graph, nodes_to_subgraph):
     new_node_names = [node.get_name() for node in nodes_to_subgraph]
     if len(new_node_names) > 1:
-        #graphviz_graph.body.append('{ rank="same"  '+(" -> ".join(new_node_names))+'  [weight=999,style=invis]; }\n')
-        graphviz_graph.body.append('{ rank="same"  '+('; '.join(new_node_names))+'; }\n')
+        graphviz_graph.body.append('subgraph { rank=same; '+ ' -> '.join(new_node_names) + '[weight='+str(config.graph_stability)+', style=invis]; }\n')
 
 def add_to_graphviz_graph(graphviz_graph, nodes, node, slices, id_to_slices, subgraphed_nodes, depth):
     html_table = node.get_html_table(nodes, slices, id_to_slices)
@@ -176,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.9 → memory_graph-0.3.11}/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