memory-graph 0.3.14__tar.gz → 0.3.16__tar.gz

{memory_graph-0.3.14 → memory_graph-0.3.16}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.14
-Summary: Generate intuitive graphs of your Python data, perfect for debugging and understanding complex relationships.
+Version: 0.3.16
+Summary: Generate intuitive graphs of your Python data, great for debugging and understanding complex relationships.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
 Author-email: bterwijn@gmail.com
@@ -146,6 +146,7 @@ import memory_graph as mg
 a = (4, 3, 2)
 b = a
 mg.render(locals(), 'immutable1.png')
+
 a += (1,)
 mg.render(locals(), 'immutable2.png')
 ```
@@ -163,6 +164,7 @@ import memory_graph as mg
 a = [4, 3, 2]
 b = a
 mg.render(locals(), 'mutable1.png')
+
 a += [1] # equivalent to:  a.append(1)
 mg.render(locals(), 'mutable2.png')
 ```
@@ -197,7 +199,7 @@ mg.show(locals())
 
 
 ### Custom Copy ###
-We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
+We can write our own custom copy function or method in case the three standard "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
 
 ```python
 import memory_graph as mg
@@ -221,9 +223,26 @@ mg.show(locals())
 ```
 ![copy_method.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_method.png)
 
+### Name Rebinding ###
+When `a` and `b` share a mutable value, then changing the value of `a` changes the value of `b` and vice versa. However, reassigning the value of `a` does not change `b`. When you reassign `a`, you only rebind the name `a` to a new value without effecting any other variables.
+
+```python
+import memory_graph as mg
+
+a = [4, 3, 2]
+b = a
+mg.render(locals(), 'rebinding1.png')
+
+a += [1]        # changes the value of 'a' and 'b'
+a = [100, 200]  # rebinds 'a' to a new value, 'b' is uneffected
+mg.render(locals(), 'rebinding2.png')
+```
+| ![rebinding1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding1.png) | ![rebinding2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| rebinding1.png | rebinding2.png |
 
 ## Call Stack ##
-The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -232,7 +251,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    mg.show(mg.get_call_stack())
+    mg.show(mg.stack())
 
 a = [4, 3, 2]
 b = (4, 3, 2)
@@ -276,9 +295,9 @@ import memory_graph as mg
 def factorial(n):
     if n==0:
         return 1
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     result = n * factorial(n-1)
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print(factorial(3))
@@ -295,7 +314,7 @@ A more interesting recursive example that shows sharing of data is power_set().
 import memory_graph as mg
 
 def get_subsets(subsets, data, i, subset):
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     if i == len(data):
         subsets.append(subset.copy())
         return
@@ -303,7 +322,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
 
 def power_set(data):
     subsets = []
@@ -327,13 +346,13 @@ mg.render(locals(), "my_graph.pdf")
 as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
-The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
+The ```mg.stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
 
 | debugger | function to get the call stack |
 |:---|:---|
-| **pdb, pudb** | `mg.get_call_stack_pdb()` |
-| **Visual Studio Code** | `mg.get_call_stack_vscode()` |
-| **Pycharm** | `mg.get_call_stack_pycharm()` |
+| **pdb, pudb** | `mg.stack_pdb()` |
+| **Visual Studio Code** | `mg.stack_vscode()` |
+| **Pycharm** | `mg.stack_pycharm()` |
 
 ![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
 
@@ -344,7 +363,7 @@ mg.save_call_stack("call_stack.txt")
 ```
 Choose 'after' and 'up_to' what function you want to slice and then call this function to get the desired call stack:
 ```
-mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
+mg.stack_after_up_to(after_function, up_to_function="<module>")
 ```
 
 ### Debugging without Debugger Tool ###
@@ -354,13 +373,13 @@ To simplify debugging without a debugger tool, we offer these alias functions th
 | alias | purpose | function call |
 |:---|:---|:---|
 | `mg.sl()` | **s**how **l**ocal variables | `mg.show(locals())` |
-| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.get_call_stack())` |
+| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.stack())` |
 | `mg.bsl()` | **b**lock after **s**howing **l**ocal variables | `mg.block(mg.show, locals())` |
-| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.stack())` |
 | `mg.rl()` | **r**ender **l**ocal variables | `mg.render(locals())` |
-| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.get_call_stack())` |
+| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.stack())` |
 | `mg.brl()` | **b**lock after **r**endering **l**ocal variables | `mg.block(mg.render, locals())` |
-| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.get_call_stack())` |
+| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.stack())` |
 | `mg.l()` | same as `mg.bsl()` |  |
 | `mg.s()` | same as `mg.bss()` |  |
 
@@ -533,7 +552,7 @@ Different aspects of memory_graph can be configured. The default configuration i
   - Maps each type to a Slicer. A slicer determines how many elements of a data type are shown in the graph to prevent the graph from getting too big. 'Slicer()' does no slicing, 'Slicer(1,2,3)' shows just 1 element at the beginning, 2 in the middle, and 3 at the end.
 
 ### Simplified Graph ###
-Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.
 
 The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
 ```python
@@ -551,7 +570,7 @@ mg.render(locals(), 'not_node_types2.png')
 |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
 | not_node_types1.png — simplified | not_node_types2.png — technically correct |
 
-Additionally, the simplification hides the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
+Additionally, the simplification hides away the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
 
 ### Temporary Configuration ###
 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:
@@ -746,7 +765,7 @@ mg.show(locals())
 
 
 ## Jupyter Notebook ##
-In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out.
+In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.stack_jupyter()` to get the whole call stack with these variables filtered out.
 
 We can use `mg.show()` and `mg.render()` in a Jupyter Notebook, but alternatively we can also use `mg.create_graph()` to create a graph and the `display()` function to render it inline with for example:
 
@@ -759,11 +778,11 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
-In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_ipython()` to get the whole call stack with these variables filtered out.
+In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.stack_ipython()` to get the whole call stack with these variables filtered out.
 
 Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/auto_memory_graph.py) in the ipython startup directory:
-* Linux/Mac: ~/.ipython/profile_default/startup/
-* Windows: %USERPROFILE%\.ipython\profile_default\startup\
+* Linux/Mac: `~/.ipython/profile_default/startup/`
+* Windows: `%USERPROFILE%\.ipython\profile_default\startup\`
 
 Then after starting 'ipython' call function `mg_switch()` to turn on/off the automatic visualization of local variables after each command.
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)

memory_graph-0.3.14/memory_graph.egg-info/PKG-INFO → memory_graph-0.3.16/README.md

@@ -1,22 +1,3 @@
-Metadata-Version: 2.1
-Name: memory_graph
-Version: 0.3.14
-Summary: Generate intuitive graphs of your Python data, perfect for debugging and understanding complex relationships.
-Home-page: https://github.com/bterwijn/memory_graph
-Author: Bas Terwijn
-Author-email: bterwijn@gmail.com
-License: BSD 2-clause
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Education
-Classifier: Topic :: Software Development :: Debuggers
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: graphviz
-
 # Installation #
 Install (or upgrade) `memory_graph` using pip:
 ```
@@ -146,6 +127,7 @@ import memory_graph as mg
 a = (4, 3, 2)
 b = a
 mg.render(locals(), 'immutable1.png')
+
 a += (1,)
 mg.render(locals(), 'immutable2.png')
 ```
@@ -163,6 +145,7 @@ import memory_graph as mg
 a = [4, 3, 2]
 b = a
 mg.render(locals(), 'mutable1.png')
+
 a += [1] # equivalent to:  a.append(1)
 mg.render(locals(), 'mutable2.png')
 ```
@@ -197,7 +180,7 @@ mg.show(locals())
 
 
 ### Custom Copy ###
-We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
+We can write our own custom copy function or method in case the three standard "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
 
 ```python
 import memory_graph as mg
@@ -221,9 +204,26 @@ mg.show(locals())
 ```
 ![copy_method.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_method.png)
 
+### Name Rebinding ###
+When `a` and `b` share a mutable value, then changing the value of `a` changes the value of `b` and vice versa. However, reassigning the value of `a` does not change `b`. When you reassign `a`, you only rebind the name `a` to a new value without effecting any other variables.
+
+```python
+import memory_graph as mg
+
+a = [4, 3, 2]
+b = a
+mg.render(locals(), 'rebinding1.png')
+
+a += [1]        # changes the value of 'a' and 'b'
+a = [100, 200]  # rebinds 'a' to a new value, 'b' is uneffected
+mg.render(locals(), 'rebinding2.png')
+```
+| ![rebinding1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding1.png) | ![rebinding2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding2.png) |
+|:-----------------------------------------------------------:|:-------------------------------------------------------------:|
+| rebinding1.png | rebinding2.png |
 
 ## Call Stack ##
-The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -232,7 +232,7 @@ def add_one(a, b, c):
     a += [1]
     b += (1,)
     c += [1]
-    mg.show(mg.get_call_stack())
+    mg.show(mg.stack())
 
 a = [4, 3, 2]
 b = (4, 3, 2)
@@ -276,9 +276,9 @@ import memory_graph as mg
 def factorial(n):
     if n==0:
         return 1
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     result = n * factorial(n-1)
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print(factorial(3))
@@ -295,7 +295,7 @@ A more interesting recursive example that shows sharing of data is power_set().
 import memory_graph as mg
 
 def get_subsets(subsets, data, i, subset):
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
     if i == len(data):
         subsets.append(subset.copy())
         return
@@ -303,7 +303,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.block(mg.show, mg.get_call_stack())
+    mg.block(mg.show, mg.stack())
 
 def power_set(data):
     subsets = []
@@ -327,13 +327,13 @@ mg.render(locals(), "my_graph.pdf")
 as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
-The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
+The ```mg.stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
 
 | debugger | function to get the call stack |
 |:---|:---|
-| **pdb, pudb** | `mg.get_call_stack_pdb()` |
-| **Visual Studio Code** | `mg.get_call_stack_vscode()` |
-| **Pycharm** | `mg.get_call_stack_pycharm()` |
+| **pdb, pudb** | `mg.stack_pdb()` |
+| **Visual Studio Code** | `mg.stack_vscode()` |
+| **Pycharm** | `mg.stack_pycharm()` |
 
 ![debug_vscode.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debug_vscode.png)
 
@@ -344,7 +344,7 @@ mg.save_call_stack("call_stack.txt")
 ```
 Choose 'after' and 'up_to' what function you want to slice and then call this function to get the desired call stack:
 ```
-mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
+mg.stack_after_up_to(after_function, up_to_function="<module>")
 ```
 
 ### Debugging without Debugger Tool ###
@@ -354,13 +354,13 @@ To simplify debugging without a debugger tool, we offer these alias functions th
 | alias | purpose | function call |
 |:---|:---|:---|
 | `mg.sl()` | **s**how **l**ocal variables | `mg.show(locals())` |
-| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.get_call_stack())` |
+| `mg.ss()` | **s**how the call **s**tack | `mg.show(mg.stack())` |
 | `mg.bsl()` | **b**lock after **s**howing **l**ocal variables | `mg.block(mg.show, locals())` |
-| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.get_call_stack())` |
+| `mg.bss()` | **b**lock after **s**howing the call **s**tack | `mg.block(mg.show, mg.stack())` |
 | `mg.rl()` | **r**ender **l**ocal variables | `mg.render(locals())` |
-| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.get_call_stack())` |
+| `mg.rs()` | **r**ender the call **s**tack | `mg.render(mg.stack())` |
 | `mg.brl()` | **b**lock after **r**endering **l**ocal variables | `mg.block(mg.render, locals())` |
-| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.get_call_stack())` |
+| `mg.brs()` | **b**lock after **r**endering the call **s**tack | `mg.block(mg.render, mg.stack())` |
 | `mg.l()` | same as `mg.bsl()` |  |
 | `mg.s()` | same as `mg.bss()` |  |
 
@@ -533,7 +533,7 @@ Different aspects of memory_graph can be configured. The default configuration i
   - Maps each type to a Slicer. A slicer determines how many elements of a data type are shown in the graph to prevent the graph from getting too big. 'Slicer()' does no slicing, 'Slicer(1,2,3)' shows just 1 element at the beginning, 2 in the middle, and 3 at the end.
 
 ### Simplified Graph ###
-Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes—changing `a` won’t effect `b`.
+Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.
 
 The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand and focuses on the mutable types where unexpected changes can occur. This is why it is the default behavior. If you do want to show separate nodes for `int` values, such as for educational purposes, you can simply remove `int` from the `mg.config.not_node_types` set:
 ```python
@@ -551,7 +551,7 @@ mg.render(locals(), 'not_node_types2.png')
 |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
 | not_node_types1.png — simplified | not_node_types2.png — technically correct |
 
-Additionally, the simplification hides the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
+Additionally, the simplification hides away the [reuse of small int values](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong) in the current CPython implementation, an optimization that might otherwise confuse beginner Python programmers. For instance, after executing `a[1]+=1; b[1]+=1` the `201` value is, maybe surprisingly, still shared between `a` and `b`, whereas executing `a[2]+=1; b[2]+=1` does not result in sharing the `301` value.
 
 ### Temporary Configuration ###
 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:
@@ -746,7 +746,7 @@ mg.show(locals())
 
 
 ## Jupyter Notebook ##
-In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out.
+In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.stack_jupyter()` to get the whole call stack with these variables filtered out.
 
 We can use `mg.show()` and `mg.render()` in a Jupyter Notebook, but alternatively we can also use `mg.create_graph()` to create a graph and the `display()` function to render it inline with for example:
 
@@ -759,11 +759,11 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
-In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_ipython()` to get the whole call stack with these variables filtered out.
+In ipython `locals()` has additional variables that cause problems in the graph, use `mg.locals_ipython()` to get the local variables with these problematic variables filtered out. Use `mg.stack_ipython()` to get the whole call stack with these variables filtered out.
 
 Additionally install file [auto_memory_graph.py](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/auto_memory_graph.py) in the ipython startup directory:
-* Linux/Mac: ~/.ipython/profile_default/startup/
-* Windows: %USERPROFILE%\.ipython\profile_default\startup\
+* Linux/Mac: `~/.ipython/profile_default/startup/`
+* Windows: `%USERPROFILE%\.ipython\profile_default\startup\`
 
 Then after starting 'ipython' call function `mg_switch()` to turn on/off the automatic visualization of local variables after each command.
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)

{memory_graph-0.3.14 → memory_graph-0.3.16}/images/add_one.py

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

{memory_graph-0.3.14 → memory_graph-0.3.16}/images/create_images.sh

@@ -10,6 +10,7 @@ python immutable.py
 python mutable.py
 python copies.py
 python copy_method.py
+python name_rebinding.py
 
 # call stack
 python add_one.py

{memory_graph-0.3.14 → memory_graph-0.3.16}/images/factorial.py

@@ -13,12 +13,12 @@ def get_fac_name():
 def factorial(n):
     if n==0:
         return 1
-    #mg.show( mg.get_call_stack(), block=True ) # draw graph
-    mg.render( mg.get_call_stack(), get_fac_name())
+    #mg.show( mg.stack(), block=True ) # draw graph
+    mg.render( mg.stack(), get_fac_name())
     result = n*factorial(n-1)
-    #mg.show( mg.get_call_stack(), block=True ) # draw graph
-    mg.render( mg.get_call_stack(), get_fac_name())
+    #mg.show( mg.stack(), block=True ) # draw graph
+    mg.render( mg.stack(), get_fac_name())
     return result
 
-mg.render( mg.get_call_stack(), get_fac_name())
+mg.render( mg.stack(), get_fac_name())
 factorial(3)

memory_graph-0.3.16/images/name_rebinding.py

@@ -0,0 +1,9 @@
+import memory_graph as mg
+
+a = [4, 3, 2]
+b = a
+mg.render(locals(), 'rebinding1.png')
+
+a += [1]        # changes value of 'a' and 'b'
+a = [100, 200]  # rebinds 'a' to a new value, 'b' is uneffected
+mg.render(locals(), 'rebinding2.png')

{memory_graph-0.3.14 → memory_graph-0.3.16}/images/power_set.py

@@ -8,7 +8,7 @@ image = 1
 
 def get_subsets(subsets, data, i, subset):
     global image
-    mg.render(mg.get_call_stack(), f"power_set{image}.png")
+    mg.render(mg.stack(), f"power_set{image}.png")
     image += 1
     if i == len(data):
         subsets.append(subset.copy())
@@ -17,7 +17,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.render(mg.get_call_stack(), f"power_set{image}.png")
+    mg.render(mg.stack(), f"power_set{image}.png")
     image += 1
 
 def power_set(data):