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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.9
+Version: 0.3.10
 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 which makes 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:
@@ -620,9 +630,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 +652,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 +676,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 +700,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 +737,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/sc/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.10}/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 which makes 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:
@@ -601,9 +611,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 +633,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 +657,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 +681,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 +718,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/sc/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.10}/memory_graph/__init__.py

@@ -13,15 +13,15 @@ import sys
 
 import graphviz
 
-__version__ = "0.3.09"
+__version__ = "0.3.10"
 __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.10}/memory_graph/config.py

@@ -7,6 +7,7 @@
 max_tree_depth = 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.10}/memory_graph/config_default.py

@@ -15,7 +15,7 @@ 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.  """
+""" 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_missing_edges = 3
@@ -23,6 +23,9 @@ 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.10}/memory_graph/memory_to_nodes.py

@@ -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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.9
+Version: 0.3.10
 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 which makes 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:
@@ -620,9 +630,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 +652,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 +676,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 +700,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 +737,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/sc/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.10}/memory_graph.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ images/highlight.py
 images/immutable.py
 images/immutable1.png
 images/immutable2.png
+images/ipython.png
 images/jupyter_example.ipynb
 images/jupyter_example.png
 images/linked_list.png
@@ -47,6 +48,7 @@ images/mutable1.png
 images/mutable2.png
 images/power_set.gif
 images/power_set.py
+images/pyodide.png
 images/uva.png
 memory_graph/__init__.py
 memory_graph/config.py
@@ -79,4 +81,6 @@ memory_graph.egg-info/SOURCES.txt
 memory_graph.egg-info/dependency_links.txt
 memory_graph.egg-info/requires.txt
 memory_graph.egg-info/top_level.txt
+src/auto_memory_graph.py
+src/pyodide.html
 uml/memory_graph.uxf

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

@@ -11,7 +11,7 @@ long_description_from_readme = (this_directory / "README.md").read_text()
 
 setup(
     name = 'memory_graph',
-    version = '0.3.09',
+    version = '0.3.10',
     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/src/auto_memory_graph.py

@@ -0,0 +1,18 @@
+import memory_graph as mg
+
+mg_visualization_status = False
+print('running:', __file__)
+print('Call mg_switch() to turn on/off auto memory_graph visualization.')
+
+def mg_visualization(execution_result):
+    ipython_locals = get_ipython().user_ns
+    mg.show(mg.ipython_locals_filter(ipython_locals))
+
+def mg_switch():
+    global mg_visualization_status
+    mg_visualization_status = not mg_visualization_status
+    if mg_visualization_status:
+        get_ipython().events.register("post_run_cell", mg_visualization)
+    else:
+        get_ipython().events.unregister("post_run_cell", mg_visualization)
+    return mg_visualization_status

memory_graph-0.3.10/src/pyodide.html

@@ -0,0 +1,179 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Pyodide Python Runner</title>
+    <script src="https://cdn.jsdelivr.net/pyodide/v0.23.4/full/pyodide.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/viz.js@2.1.2/viz.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/viz.js@2.1.2/full.render.js"></script>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+	    margin: 0;
+	    padding: 0;
+	    height: 100%;
+        }
+	.container {
+	    display: grid;
+	    grid-template-columns: 1fr 1fr;
+	    grid-template-rows: 1fr 1fr;
+	    height: 100vh;
+	}
+	.part {
+	    border: 1px solid black;
+	    display: flex;
+	    flex-direction: column;
+	    justify-content: flex-start;
+	    align-items: flex-start;
+	    padding: 10px;
+	    box-sizing: border-box;
+	}
+        textarea {
+	    flex: 1;
+	    width: 100%;
+	    resize: none;
+	    margin-bottom: 10px;
+        }
+        button {
+            padding: 10px 15px;
+            font-size: 16px;
+            cursor: pointer;
+        }
+        #output {
+            background-color: #f4f4f4;
+            border: 1px solid #ddd;
+            white-space: pre-wrap;
+        }
+	#log {
+            background-color: #f4f4f4;
+            border: 1px solid #ddd;
+            white-space: pre-wrap;
+        }
+    </style>
+</head>
+<body>
+  <div class="container">
+    <div class="part"><!-- ========== Top Left ========== --> <p>Log:</p>
+      <textarea id="log"></textarea>
+    </div>
+    
+    <div class="part"><!-- ========== Top Right ========== --> <p>Python Code:</p>
+    <textarea id="python-code">
+import memory_graph as mg
+import js
+
+def add_one(a, b, c):
+    a += [1]
+    b += (1,)
+    c += [1]
+    print("display the call stack")
+    js.display(mg.create_graph(mg.get_call_stack()))
+
+print("initialize test data")
+a = [4, 3, 2]
+b = (4, 3, 2)
+c = [4, 3, 2]
+print(f"a:{a} b:{b} c:{c}")
+
+print("call function add_one()")
+add_one(a, b, c.copy())
+print(f"a:{a} b:{b} c:{c}")
+    </textarea>
+    <button id="run-button" disabled>Run</button>
+    </div>
+    
+    <div class="part"><!-- ========== Bottom Left ========== --> <p>Graph:</p>
+    <div id="graph-container"></div>
+    </div>
+
+    
+    <div class="part"><!-- ========== Bottom Right ========== --> <p>Output:</p>
+      <textarea id="output"></textarea>
+    </div>
+  </div>
+  
+    
+    <script>
+    window.display = function(graph) {
+	const svgContainer = document.getElementById("graph-container");
+	try {
+            // Use Viz.js to render the DOT code into SVG
+            const viz = new Viz();
+            viz.renderSVGElement(graph.source)
+                .then(svgElement => {
+                    svgContainer.innerHTML = "";
+                    svgContainer.appendChild(svgElement);
+                })
+                .catch(error => {
+                    svgContainer.innerHTML = `Error: ${error}`;
+                });
+        } catch (error) {
+            svgContainer.innerHTML = `Error: ${error}`;
+        }
+    };
+      
+      let memory_graph_ready = false;
+      let pyodide;
+      const logDiv = document.getElementById("log");
+      logDiv.textContent = "Setting up\n";
+      
+      async function initializePyodide() {
+	  // Load Pyodide and micropip
+	  logDiv.textContent += "Loading Pyodide... "
+          pyodide = await loadPyodide();
+          logDiv.textContent +="loaded\n";
+	  logDiv.textContent += "Loading micropip... "
+          await pyodide.loadPackage("micropip");
+          logDiv.textContent += "loaded\n";
+	  const micropip = pyodide.pyimport("micropip");
+	  
+	  // Installing memory_graph
+	  try {
+	      logDiv.textContent += "Installing memory_graph... "
+	      await micropip.install("memory_graph");
+	      logDiv.textContent += "installed\n";
+	      memory_graph_ready = true;
+	      
+	      if (memory_graph_ready) {
+		  logDiv.textContent += "Setup complete, ready to Run\n";
+	          const button = document.getElementById("run-button");
+		  button.disabled = false;
+	      }
+	  } catch (error) {
+	      logDiv.textContent += `Failed to install memory_graph: ${error.message}\n`;
+	  }
+	  
+      }
+
+      initializePyodide(); // Call the initialization function.
+
+      document.getElementById("run-button").addEventListener("click", async () => {
+          const code = document.getElementById("python-code").value;
+          const outputDiv = document.getElementById("output");
+          outputDiv.textContent = ""; // Clear previous output
+
+	  try {
+              // Redirect Python stdout to capture `print()` output
+              pyodide.runPython(`
+import sys
+import io
+sys.stdout = io.StringIO()
+sys.stderr = sys.stdout
+                `);
+
+              // Execute the user-provided code
+	      logDiv.textContent += "running code\n"
+              await pyodide.runPythonAsync(code);
+	      
+              // Retrieve stdout content
+              const output = pyodide.runPython("sys.stdout.getvalue()");
+              outputDiv.textContent = `${output}`;
+          } catch (error) {
+              outputDiv.textContent = `${error}`;
+          }
+	  
+      });
+    </script>
+</body>
+</html>