memory-graph 0.3.65__tar.gz → 0.3.67__tar.gz

{memory_graph-0.3.65 → memory_graph-0.3.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.65
+Version: 0.3.67
 Summary: Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License-Expression: BSD-2-Clause
@@ -30,11 +30,11 @@ Additionally [Graphviz](https://graphviz.org/download/) needs to be installed.
 Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph.com/#breakpoints=8&continues=1&timestep=1.0&play) 👈 now, no installation required!
 
 - learn the right **mental model** to think about Python data (references, mutability, shallow vs deep copy)
-- **visualize the structure of your data** to easily understand and debug any data structure
+- **visualize the structure of your data** to more easily understand and debug any data structure
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.gif)
+![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
 # Videos #
@@ -43,7 +43,7 @@ Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=ht
 | [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
 
 # Memory Graph #
-For program understanding and debugging, the [memory_graph](https://pypi.org/project/memory-graph/) package can visualize your data, supporting many different data types, including but not limited to:
+For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
 
 ```python
 import memory_graph as mg
@@ -69,7 +69,7 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 mg.render(data) # renders to default: 'memory_graph.pdf'
 ```
 
-# Sharing Values #
+# Sharing Values, Aliasing #
 In Python, assigning a list from variable `a` to variable `b` causes both variables to reference the same list value and thus share it. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
 
 <table><tr><td> 
@@ -86,7 +86,7 @@ b.append(1) # changing 'b' changes 'a'
 print('a:', a)
 print('b:', b)
 
-# check if 'a' and 'b' share values
+# check if 'a' and 'b' share the list
 print('ids:', id(a), id(b))
 print('identical?:', a is b)
 
@@ -98,18 +98,18 @@ mg.show( locals() )
 
 ![mutable2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/mutable2.png)
 
-a graph showing `a` and `b` share values
+a graph showing `a` and `b` share the list
 
 </td></tr></table>
 
-The fact that `a` and `b` share values can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
+The fact that `a` and `b` share the list can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
 ```{verbatim}
 a: 4, 3, 2, 1
 b: 4, 3, 2, 1
 ids: 126432214913216 126432214913216
 identical?: True
 ```
-A better way to understand what values are shared is to draw a graph using [memory_graph](https://pypi.org/project/memory-graph/).
+A better way to understand what values are shared is to draw a graph using [memory_graph](https://github.com/bterwijn/memory_graph).
 
 # Topics #
 
@@ -161,7 +161,7 @@ Bas Terwijn
 ## Inspiration ##
 Inspired by [Python Tutor](https://pythontutor.com/).
 
-The main differences are that running memory_graph locally is a key design choice to support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) and mirroring the data’s hierarchy improves graph readability.
+The main differences are that by running memory_graph locally we support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) so that it scales to full programs in many environments and IDEs instead of just code snippets in a webbrowser, and by mirroring the data’s hierarchy we improve graph readability for larger graphs.
 
 ## Social Media #
 * [LinkedIn](https://www.linkedin.com/groups/13244150/)
@@ -271,22 +271,28 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable. 
+
+Also note the difference between statement `b += [1]` that changes `b` and `a`, and statement `c = c + [300]` that first creates the new value `c + [300]` and assigns this value to `c` without effecting `b`. This shows that `x += y` is not the same as `x = x + y` for values of mutable type.
 
 ```python
 import memory_graph as mg
 
-a = [4, 3, 2]
+a = [100, 200]
 b = a
 mg.render(locals(), 'rebinding1.png')
 
-b += [1]        # changes the value of 'b' and 'a'
-b = [100, 200]  # rebinds 'b' to another value, 'a' is unaffected
+b += [300]      # changes the value of 'b' and 'a'
+b = [400, 500]  # rebinds 'b' to a new value, 'a' is unaffected
+c = b
 mg.render(locals(), 'rebinding2.png')
+
+c = c + [600]   # rebinds 'c' to new value 'c + [600]', `b` is unaffected
+mg.render(locals(), 'rebinding3.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 |
+| ![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) | ![rebinding3.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding3.png) |
+|:--------------:|:--------------:|:--------------:|
+| rebinding1.png | rebinding2.png | rebinding3.png |
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/rebind.py&play).
 
@@ -314,7 +320,7 @@ When copying a mix of values of mutable and immutable type, to save on time and
 import memory_graph as mg
 import copy
 
-a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable
+a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable values
 
 # three different ways to make a "copy" of 'a':
 c1 = a
@@ -381,7 +387,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -394,7 +400,7 @@ 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 return value of the `fun()` call
+* and returns the return value of the `fun()` call
 
 ## 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(4)` is computed:
@@ -494,6 +500,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 |:---|:---|
 | [pdb](https://docs.python.org/3/library/pdb.html), [pudb](https://pypi.org/project/pudb/) | `mg.stack_pdb()` |
 | [Visual Studio Code](https://code.visualstudio.com/docs/languages/python) | `mg.stack_vscode()` |
+| [Jupyter Notebooks in VS Code](https://code.visualstudio.com/docs/datascience/jupyter-notebooks) | `mg.stack_vscode_jupyter()` |
 | [Cursor AI](https://www.cursor.com/) | `mg.stack_cursor()` |
 | [PyCharm](https://www.jetbrains.com/pycharm/) | `mg.stack_pycharm()` |
 | [Wing](https://wingware.com/) | `mg.stack_wing()` |
@@ -775,7 +782,7 @@ Different aspects of memory_graph can be configured. The default configuration c
 ## 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`'s ints 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.embedded_types` set:
+The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand to focus on 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.embedded_types` set:
 ```python
 import memory_graph as mg
 
@@ -809,7 +816,7 @@ tree.insert(15, "fifteen")
 
 mg.show(locals())
 ```
-![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+![avltree_fail.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
 
 ## All attributes using dir() ##
 A useful start is to give it some color, show the list of all its attributes using `dir()`, and setting an empty Slicer to see the attribute list in full.
@@ -980,6 +987,8 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
+Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_search.py&breakpoints=32&continues=1&timestep=0.5&play)
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 
@@ -1052,12 +1061,12 @@ mg.show(locals())
 Different extensions are available for types from other Python packages. 
 
 ## Numpy ##
-Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+For Numpy types `array` and `matrix` and `ndarray`, use `mg.extend_numpy()`:
 
 ```python
 import memory_graph as mg
 import numpy as np
-import memory_graph.extension_numpy
+mg.extend_numpy()
 np.random.seed(0) # use same random numbers each run
 
 matrix = np.matrix([[i*5+j for j in range(4)] for i in range(5)])
@@ -1072,12 +1081,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=numpy&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_numpy.py&continues=1).
 
 ## Pandas ##
-Pandas types `Series` and `DataFrame` can be graphed with "memory_graph.extension_pandas":
+For pandas types `Series` and `DataFrame`, use `mg.extend_pandas()`:
 
 ```python
 import memory_graph as mg
 import pandas as pd
-import memory_graph.extension_pandas
+mg.extend_pandas()
 
 series = pd.Series( [i for i in range(20)] )
 dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
@@ -1093,12 +1102,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=pandas&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_pandas.py&continues=1).
 
 ## PyTorch ##
-Torch type `tensor` can be graphed with "memory_graph.extension_torch":
+For torch type `tensor`, use `mg.extend_torch()`:
 
 ```python
 import memory_graph as mg
 import torch
-import memory_graph.extension_torch
+mg.extend_torch()
 torch.manual_seed(0) # same random numbers each run
 
 tensor_1d = torch.rand(3)
@@ -1171,4 +1180,4 @@ $ bash create_gif.sh animated
 - When graph edges overlap it can be hard to distinguish them. Using an interactive graphviz viewer, such as [xdot](https://github.com/jrfonseca/xdot.py), on a '*.gv' DOT output file will help.
 
 # Other Packages #
-The [memory_graph](https://pypi.org/project/memory-graph/) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://pypi.org/project/invocation-tree/) package.
+The [memory_graph](https://github.com/bterwijn/memory_graph) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://github.com/bterwijn/invocation_tree) package.

{memory_graph-0.3.65 → memory_graph-0.3.67}/README.md

@@ -10,11 +10,11 @@ Additionally [Graphviz](https://graphviz.org/download/) needs to be installed.
 Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph.com/#breakpoints=8&continues=1&timestep=1.0&play) 👈 now, no installation required!
 
 - learn the right **mental model** to think about Python data (references, mutability, shallow vs deep copy)
-- **visualize the structure of your data** to easily understand and debug any data structure
+- **visualize the structure of your data** to more easily understand and debug any data structure
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.gif)
+![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
 # Videos #
@@ -23,7 +23,7 @@ Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=ht
 | [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
 
 # Memory Graph #
-For program understanding and debugging, the [memory_graph](https://pypi.org/project/memory-graph/) package can visualize your data, supporting many different data types, including but not limited to:
+For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
 
 ```python
 import memory_graph as mg
@@ -49,7 +49,7 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 mg.render(data) # renders to default: 'memory_graph.pdf'
 ```
 
-# Sharing Values #
+# Sharing Values, Aliasing #
 In Python, assigning a list from variable `a` to variable `b` causes both variables to reference the same list value and thus share it. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
 
 <table><tr><td> 
@@ -66,7 +66,7 @@ b.append(1) # changing 'b' changes 'a'
 print('a:', a)
 print('b:', b)
 
-# check if 'a' and 'b' share values
+# check if 'a' and 'b' share the list
 print('ids:', id(a), id(b))
 print('identical?:', a is b)
 
@@ -78,18 +78,18 @@ mg.show( locals() )
 
 ![mutable2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/mutable2.png)
 
-a graph showing `a` and `b` share values
+a graph showing `a` and `b` share the list
 
 </td></tr></table>
 
-The fact that `a` and `b` share values can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
+The fact that `a` and `b` share the list can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
 ```{verbatim}
 a: 4, 3, 2, 1
 b: 4, 3, 2, 1
 ids: 126432214913216 126432214913216
 identical?: True
 ```
-A better way to understand what values are shared is to draw a graph using [memory_graph](https://pypi.org/project/memory-graph/).
+A better way to understand what values are shared is to draw a graph using [memory_graph](https://github.com/bterwijn/memory_graph).
 
 # Topics #
 
@@ -141,7 +141,7 @@ Bas Terwijn
 ## Inspiration ##
 Inspired by [Python Tutor](https://pythontutor.com/).
 
-The main differences are that running memory_graph locally is a key design choice to support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) and mirroring the data’s hierarchy improves graph readability.
+The main differences are that by running memory_graph locally we support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) so that it scales to full programs in many environments and IDEs instead of just code snippets in a webbrowser, and by mirroring the data’s hierarchy we improve graph readability for larger graphs.
 
 ## Social Media #
 * [LinkedIn](https://www.linkedin.com/groups/13244150/)
@@ -251,22 +251,28 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable. 
+
+Also note the difference between statement `b += [1]` that changes `b` and `a`, and statement `c = c + [300]` that first creates the new value `c + [300]` and assigns this value to `c` without effecting `b`. This shows that `x += y` is not the same as `x = x + y` for values of mutable type.
 
 ```python
 import memory_graph as mg
 
-a = [4, 3, 2]
+a = [100, 200]
 b = a
 mg.render(locals(), 'rebinding1.png')
 
-b += [1]        # changes the value of 'b' and 'a'
-b = [100, 200]  # rebinds 'b' to another value, 'a' is unaffected
+b += [300]      # changes the value of 'b' and 'a'
+b = [400, 500]  # rebinds 'b' to a new value, 'a' is unaffected
+c = b
 mg.render(locals(), 'rebinding2.png')
+
+c = c + [600]   # rebinds 'c' to new value 'c + [600]', `b` is unaffected
+mg.render(locals(), 'rebinding3.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 |
+| ![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) | ![rebinding3.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding3.png) |
+|:--------------:|:--------------:|:--------------:|
+| rebinding1.png | rebinding2.png | rebinding3.png |
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/rebind.py&play).
 
@@ -294,7 +300,7 @@ When copying a mix of values of mutable and immutable type, to save on time and
 import memory_graph as mg
 import copy
 
-a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable
+a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable values
 
 # three different ways to make a "copy" of 'a':
 c1 = a
@@ -361,7 +367,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -374,7 +380,7 @@ 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 return value of the `fun()` call
+* and returns the return value of the `fun()` call
 
 ## 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(4)` is computed:
@@ -474,6 +480,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 |:---|:---|
 | [pdb](https://docs.python.org/3/library/pdb.html), [pudb](https://pypi.org/project/pudb/) | `mg.stack_pdb()` |
 | [Visual Studio Code](https://code.visualstudio.com/docs/languages/python) | `mg.stack_vscode()` |
+| [Jupyter Notebooks in VS Code](https://code.visualstudio.com/docs/datascience/jupyter-notebooks) | `mg.stack_vscode_jupyter()` |
 | [Cursor AI](https://www.cursor.com/) | `mg.stack_cursor()` |
 | [PyCharm](https://www.jetbrains.com/pycharm/) | `mg.stack_pycharm()` |
 | [Wing](https://wingware.com/) | `mg.stack_wing()` |
@@ -755,7 +762,7 @@ Different aspects of memory_graph can be configured. The default configuration c
 ## 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`'s ints 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.embedded_types` set:
+The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand to focus on 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.embedded_types` set:
 ```python
 import memory_graph as mg
 
@@ -789,7 +796,7 @@ tree.insert(15, "fifteen")
 
 mg.show(locals())
 ```
-![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+![avltree_fail.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
 
 ## All attributes using dir() ##
 A useful start is to give it some color, show the list of all its attributes using `dir()`, and setting an empty Slicer to see the attribute list in full.
@@ -960,6 +967,8 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
+Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_search.py&breakpoints=32&continues=1&timestep=0.5&play)
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 
@@ -1032,12 +1041,12 @@ mg.show(locals())
 Different extensions are available for types from other Python packages. 
 
 ## Numpy ##
-Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+For Numpy types `array` and `matrix` and `ndarray`, use `mg.extend_numpy()`:
 
 ```python
 import memory_graph as mg
 import numpy as np
-import memory_graph.extension_numpy
+mg.extend_numpy()
 np.random.seed(0) # use same random numbers each run
 
 matrix = np.matrix([[i*5+j for j in range(4)] for i in range(5)])
@@ -1052,12 +1061,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=numpy&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_numpy.py&continues=1).
 
 ## Pandas ##
-Pandas types `Series` and `DataFrame` can be graphed with "memory_graph.extension_pandas":
+For pandas types `Series` and `DataFrame`, use `mg.extend_pandas()`:
 
 ```python
 import memory_graph as mg
 import pandas as pd
-import memory_graph.extension_pandas
+mg.extend_pandas()
 
 series = pd.Series( [i for i in range(20)] )
 dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
@@ -1073,12 +1082,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=pandas&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_pandas.py&continues=1).
 
 ## PyTorch ##
-Torch type `tensor` can be graphed with "memory_graph.extension_torch":
+For torch type `tensor`, use `mg.extend_torch()`:
 
 ```python
 import memory_graph as mg
 import torch
-import memory_graph.extension_torch
+mg.extend_torch()
 torch.manual_seed(0) # same random numbers each run
 
 tensor_1d = torch.rand(3)
@@ -1151,4 +1160,4 @@ $ bash create_gif.sh animated
 - When graph edges overlap it can be hard to distinguish them. Using an interactive graphviz viewer, such as [xdot](https://github.com/jrfonseca/xdot.py), on a '*.gv' DOT output file will help.
 
 # Other Packages #
-The [memory_graph](https://pypi.org/project/memory-graph/) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://pypi.org/project/invocation-tree/) package.
+The [memory_graph](https://github.com/bterwijn/memory_graph) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://github.com/bterwijn/invocation_tree) package.

{memory_graph-0.3.65 → memory_graph-0.3.67}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.65"
+__version__ = "0.3.67"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes
@@ -241,6 +241,51 @@ def stack_slice(begin_functions : List[Tuple[str, int]] = [],
     end_index = stack_end_index(stack_functions, begin_index, end_functions)
     return stack_frames_to_dict(reversed(frameInfos[begin_index+stack_index:end_index+1]))
 
+def stack_multi_slice(drop_functions : List[Tuple[str, int]] = [],
+                      end_functions : List[str] = ["<module>"],
+                      stack_index : int = 0,
+                      frameInfos : List[inspect.FrameInfo] = None,
+                      ignore_frame_condition = None):
+    """
+    Returns a slice of the call stack, dropping all occurrences of the specified drop_functions.
+    Parameters:
+      drop_functions - list of (function-name, offset), drops all matching 'function-name' frames
+                       including 'offset' number of parent frames for each match.
+      end_functions - list of function-names, ends at the index of the first 'function-name'
+                      that is found in the call stack after stack index (inclusive),
+                      otherwise ends at the last index
+      stack_index - number of frames removed from the beginning
+      ignore_frame_condition - optional callable that takes an inspect.FrameInfo and returns True if the frame should be dropped
+    """
+    if frameInfos is None:
+        frameInfos = inspect.stack()
+    
+    stack_functions = [s.function for s in frameInfos]
+    
+    # establish where to start (skipping innermost debugger eval frames)
+    begin_index = stack_begin_index(stack_functions, drop_functions)
+    if begin_index == 0:
+        begin_index += stack_index
+        
+    end_index = stack_end_index(stack_functions, begin_index, end_functions)
+    
+    drop_indices = set()
+    for drop_func, offset in drop_functions:
+        for i, func in enumerate(stack_functions[begin_index:end_index+1]):
+            actual_i = i + begin_index
+            if func == drop_func:
+                for j in range(actual_i, actual_i + offset):
+                    drop_indices.add(j)
+                    
+    if ignore_frame_condition:
+        for i in range(begin_index, end_index + 1):
+            if i not in drop_indices and ignore_frame_condition(frameInfos[i]):
+                drop_indices.add(i)
+    
+    filtered_frames = [frameInfos[i] for i in range(begin_index, end_index + 1) if i not in drop_indices]
+    
+    return stack_frames_to_dict(reversed(filtered_frames))
+
 def stack(end_functions=["<module>"], stack_index=0):
     return stack_slice([], end_functions, stack_index+2)
 
@@ -275,6 +320,56 @@ def stack_wing(begin_functions=[("_py_line_event",1), ("_py_return_event",1)],
     return stack_slice(begin_functions, end_functions, stack_index)
 
 
+banned_vscode_jupyter_strings = ['pydevd', 'debugpy', 'ipython', 'ipykernel', 'asyncio', 'tornado', 'traitlets', 'runpy']
+
+def is_vscode_jupyter_banned(frameInfo):
+    module_name = frameInfo.frame.f_globals.get('__name__', '')
+    filename = frameInfo.filename
+    func_name = frameInfo.function
+    
+    module_name_lower = module_name.lower()
+    func_name_lower = func_name.lower()
+    filename_lower = filename.lower()
+    
+    # Exempt user notebook/cell code from being banned.
+    if module_name == '__main__' or filename_lower.startswith('<ipython-input'):
+        return False
+    
+    for b in banned_vscode_jupyter_strings:
+        if b in module_name_lower or b in func_name_lower or b in filename_lower:
+            return True
+            
+    return False
+
+def stack_vscode_jupyter(drop_functions=[("trace_dispatch",1), ("_line_event",1), ("_return_event",1), ("do_wait_suspend",1), ("_do_wait_suspend",2)],
+                         end_functions=["<module>"],
+                         stack_index=0):
+    """ Get the call stack natively in a 'vscode' debugging 'jupyter' notebook session, 
+    filtering out the noisy environment specific functions and modules that pollute the graph. """
+    # stack_index + 2 to account for stack_vscode_jupyter and stack_multi_slice
+    call_stack_dict = stack_multi_slice(drop_functions, end_functions, stack_index + 2, ignore_frame_condition=is_vscode_jupyter_banned)
+    
+    for level_key, local_dict in call_stack_dict.items():
+        if '__pydevd_ret_val_dict' in local_dict:
+            ret_vals = local_dict.pop('__pydevd_ret_val_dict')
+            if isinstance(ret_vals, dict):
+                for k, v in ret_vals.items():
+                    # filter out Jupyter internal return values, particularly I/O stream writes
+                    if not any(b in k.lower() for b in banned_vscode_jupyter_strings) and 'write' not in k.lower():
+                        # Place return value in the function's own frame if it is still on the stack
+                        target_dict = local_dict
+                        for l_key, l_dict in call_stack_dict.items():
+                            if ": " in l_key and l_key.split(": ", 1)[1] == k:
+                                target_dict = l_dict
+                                break
+                        target_dict[f"<return> {k}"] = v
+        
+        if "<module>" in level_key:
+            call_stack_dict[level_key] = jupyter_locals_filter(local_dict)
+
+    return call_stack_dict
+
+
 def save_call_stack(filename):
     """ Saves the call stack to 'filename' for inspection to see what functions need to be 
     filtered out to create the desired graph. """
@@ -310,6 +405,12 @@ def wing(filename=None, data=None):
         data = stack_wing()
     render(data, filename)
 
+def vscode_jupyter(filename=None, data=None):
+    if data is None:
+        # stack_index=1 since this function counts as an extra stack frame
+        data = stack_vscode_jupyter(stack_index=1)
+    render(data, filename)
+
 def locals_filter(locals, keys):
     """ Filter out the jupyter specific keys that polute the graph. """
     return {k:v for k,v in utils.filter_dict(jupyter_locals)
@@ -391,3 +492,26 @@ def stack_marimo(end_functions=["<cell line: 0>", "<module>"], stack_index=0):
     globals_frame = next(iter(call_stack))
     call_stack[globals_frame] = marimo_locals_filter(call_stack[globals_frame])
     return call_stack
+
+# ------------ extensions
+
+def extend_numpy(on=True):
+    import memory_graph.extension_numpy as ext_np
+    if on:
+        ext_np.extend_numpy()
+    else:
+        ext_np.unextend_numpy()
+
+def extend_pandas(on=True):
+    import memory_graph.extension_pandas as ext_pd
+    if on:
+        ext_pd.extend_pandas()
+    else:
+        ext_pd.unextend_pandas()
+
+def extend_torch(on=True):
+    import memory_graph.extension_torch as ext_torch
+    if on:
+        ext_torch.extend_torch()
+    else:
+        ext_torch.unextend_torch()

{memory_graph-0.3.65 → memory_graph-0.3.67}/memory_graph/config.py

@@ -7,7 +7,7 @@
 reopen_viewer = None
 render_filename = None
 
-type_lables = None
+type_labels = None
 
 block_prints_location = None
 press_enter_message = None

memory_graph-0.3.67/memory_graph/extension_numpy.py

@@ -0,0 +1,48 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+""" Extension to add the memory graph configuration for Numpy types. """
+from memory_graph.node_linear import Node_Linear
+from memory_graph.node_table import Node_Table
+
+import memory_graph.config as config
+
+def ndarray_to_node(data, ndarray_data):
+    dim = len(ndarray_data.shape)
+    if dim > 2:
+        return Node_Linear(data, [i for i in ndarray_data])
+    elif dim == 2:
+        return Node_Table(data, ndarray_data)
+    else:
+        return Node_Linear(data, ndarray_data)
+
+def get_numpy_immutables():
+    import numpy as np
+    
+    return {
+        np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, 
+        np.float16, np.float32, np.float64,
+        np.complex64, np.complex128,
+        np.bool_, np.bytes_, np.str_, np.datetime64, np.timedelta64
+    }
+
+def extend_numpy():
+    import numpy as np
+
+    config.embedded_types |= get_numpy_immutables()
+    config.type_to_node[np.matrix] = lambda data : Node_Table(data, np.asarray(data)) # convert to ndarray to avoid infinite recursion due to index issue
+    config.type_to_node[np.ndarray] = lambda data : ndarray_to_node(data, data)
+
+    config.type_to_color[np.ndarray] = "hotpink1"
+    config.type_to_color[np.matrix] = "hotpink2"
+
+def unextend_numpy():
+    import numpy as np
+    
+    config.embedded_types -= get_numpy_immutables()
+    del config.type_to_node[np.matrix]
+    del config.type_to_node[np.ndarray]
+
+    del config.type_to_color[np.ndarray]
+    del config.type_to_color[np.matrix]

memory_graph-0.3.67/memory_graph/extension_pandas.py

@@ -0,0 +1,36 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+""" Extension to add the memory graph configuration for Pandas types. """
+from memory_graph.node_linear import Node_Linear
+from memory_graph.node_table import Node_Table
+
+import memory_graph.config as config
+
+def extend_pandas():
+    import pandas as pd
+    
+    config.type_to_node[pd.DataFrame] = lambda data : (
+        Node_Table(data, 
+                data.values.tolist(),
+                col_names = data.columns.tolist(),
+                row_names = [ str(i) for i in data.index.tolist()]
+                )
+    )
+
+    config.type_to_node[pd.Series] = lambda data : (
+        Node_Linear(data, data.tolist())
+    )
+
+    config.type_to_color[pd.DataFrame] = "olivedrab1"
+    config.type_to_color[pd.Series] = "olivedrab2"
+
+def unextend_pandas():
+    import pandas as pd
+
+    del config.type_to_node[pd.DataFrame]
+    del config.type_to_node[pd.Series]
+
+    del config.type_to_color[pd.DataFrame]
+    del config.type_to_color[pd.Series]

memory_graph-0.3.67/memory_graph/extension_torch.py

@@ -0,0 +1,19 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+""" Extension to add the memory graph configuration for Pandas types. """
+import memory_graph.extension_numpy as ext_np
+import memory_graph.config as config
+
+def extend_torch():
+    import torch
+
+    config.type_to_node[torch.Tensor] = lambda data : ext_np.ndarray_to_node(data, data.numpy())
+    config.type_to_color[torch.Tensor] = "darkolivegreen1"
+
+def unextend_torch():
+    import torch
+    
+    del config.type_to_node[torch.Tensor]
+    del config.type_to_color[torch.Tensor]

{memory_graph-0.3.65 → memory_graph-0.3.67}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.65
+Version: 0.3.67
 Summary: Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License-Expression: BSD-2-Clause
@@ -30,11 +30,11 @@ Additionally [Graphviz](https://graphviz.org/download/) needs to be installed.
 Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph.com/#breakpoints=8&continues=1&timestep=1.0&play) 👈 now, no installation required!
 
 - learn the right **mental model** to think about Python data (references, mutability, shallow vs deep copy)
-- **visualize the structure of your data** to easily understand and debug any data structure
+- **visualize the structure of your data** to more easily understand and debug any data structure
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.gif)
+![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
 # Videos #
@@ -43,7 +43,7 @@ Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=ht
 | [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
 
 # Memory Graph #
-For program understanding and debugging, the [memory_graph](https://pypi.org/project/memory-graph/) package can visualize your data, supporting many different data types, including but not limited to:
+For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
 
 ```python
 import memory_graph as mg
@@ -69,7 +69,7 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 mg.render(data) # renders to default: 'memory_graph.pdf'
 ```
 
-# Sharing Values #
+# Sharing Values, Aliasing #
 In Python, assigning a list from variable `a` to variable `b` causes both variables to reference the same list value and thus share it. Consequently, any change applied through one variable will impact the other. This behavior can lead to elusive bugs if a programmer incorrectly assumes that list `a` and `b` are independent.
 
 <table><tr><td> 
@@ -86,7 +86,7 @@ b.append(1) # changing 'b' changes 'a'
 print('a:', a)
 print('b:', b)
 
-# check if 'a' and 'b' share values
+# check if 'a' and 'b' share the list
 print('ids:', id(a), id(b))
 print('identical?:', a is b)
 
@@ -98,18 +98,18 @@ mg.show( locals() )
 
 ![mutable2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/mutable2.png)
 
-a graph showing `a` and `b` share values
+a graph showing `a` and `b` share the list
 
 </td></tr></table>
 
-The fact that `a` and `b` share values can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
+The fact that `a` and `b` share the list can not be verified by printing the lists. It can be verified by comparing the identity of both variables using the `id()` function or by using the `is` comparison operator as shown in the program output below, but this quickly becomes impractical for larger programs.
 ```{verbatim}
 a: 4, 3, 2, 1
 b: 4, 3, 2, 1
 ids: 126432214913216 126432214913216
 identical?: True
 ```
-A better way to understand what values are shared is to draw a graph using [memory_graph](https://pypi.org/project/memory-graph/).
+A better way to understand what values are shared is to draw a graph using [memory_graph](https://github.com/bterwijn/memory_graph).
 
 # Topics #
 
@@ -161,7 +161,7 @@ Bas Terwijn
 ## Inspiration ##
 Inspired by [Python Tutor](https://pythontutor.com/).
 
-The main differences are that running memory_graph locally is a key design choice to support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) and mirroring the data’s hierarchy improves graph readability.
+The main differences are that by running memory_graph locally we support Python Tutor’s [unsupported features](https://github.com/pythontutor-dev/pythontutor/blob/master/unsupported-features.md#unsupported-features) so that it scales to full programs in many environments and IDEs instead of just code snippets in a webbrowser, and by mirroring the data’s hierarchy we improve graph readability for larger graphs.
 
 ## Social Media #
 * [LinkedIn](https://www.linkedin.com/groups/13244150/)
@@ -271,22 +271,28 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable. 
+
+Also note the difference between statement `b += [1]` that changes `b` and `a`, and statement `c = c + [300]` that first creates the new value `c + [300]` and assigns this value to `c` without effecting `b`. This shows that `x += y` is not the same as `x = x + y` for values of mutable type.
 
 ```python
 import memory_graph as mg
 
-a = [4, 3, 2]
+a = [100, 200]
 b = a
 mg.render(locals(), 'rebinding1.png')
 
-b += [1]        # changes the value of 'b' and 'a'
-b = [100, 200]  # rebinds 'b' to another value, 'a' is unaffected
+b += [300]      # changes the value of 'b' and 'a'
+b = [400, 500]  # rebinds 'b' to a new value, 'a' is unaffected
+c = b
 mg.render(locals(), 'rebinding2.png')
+
+c = c + [600]   # rebinds 'c' to new value 'c + [600]', `b` is unaffected
+mg.render(locals(), 'rebinding3.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 |
+| ![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) | ![rebinding3.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/rebinding3.png) |
+|:--------------:|:--------------:|:--------------:|
+| rebinding1.png | rebinding2.png | rebinding3.png |
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/rebind.py&play).
 
@@ -314,7 +320,7 @@ When copying a mix of values of mutable and immutable type, to save on time and
 import memory_graph as mg
 import copy
 
-a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable
+a = ( [1, 2], ('x', 'y') ) # mix of mutable and immutable values
 
 # three different ways to make a "copy" of 'a':
 c1 = a
@@ -381,7 +387,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -394,7 +400,7 @@ 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 return value of the `fun()` call
+* and returns the return value of the `fun()` call
 
 ## 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(4)` is computed:
@@ -494,6 +500,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 |:---|:---|
 | [pdb](https://docs.python.org/3/library/pdb.html), [pudb](https://pypi.org/project/pudb/) | `mg.stack_pdb()` |
 | [Visual Studio Code](https://code.visualstudio.com/docs/languages/python) | `mg.stack_vscode()` |
+| [Jupyter Notebooks in VS Code](https://code.visualstudio.com/docs/datascience/jupyter-notebooks) | `mg.stack_vscode_jupyter()` |
 | [Cursor AI](https://www.cursor.com/) | `mg.stack_cursor()` |
 | [PyCharm](https://www.jetbrains.com/pycharm/) | `mg.stack_pycharm()` |
 | [Wing](https://wingware.com/) | `mg.stack_wing()` |
@@ -775,7 +782,7 @@ Different aspects of memory_graph can be configured. The default configuration c
 ## 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`'s ints 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.embedded_types` set:
+The simplification strikes a balance: it is slightly misleading but keeps the graph clean and easy to understand to focus on 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.embedded_types` set:
 ```python
 import memory_graph as mg
 
@@ -809,7 +816,7 @@ tree.insert(15, "fifteen")
 
 mg.show(locals())
 ```
-![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+![avltree_fail.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
 
 ## All attributes using dir() ##
 A useful start is to give it some color, show the list of all its attributes using `dir()`, and setting an empty Slicer to see the attribute list in full.
@@ -980,6 +987,8 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
+Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_search.py&breakpoints=32&continues=1&timestep=0.5&play)
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 
@@ -1052,12 +1061,12 @@ mg.show(locals())
 Different extensions are available for types from other Python packages. 
 
 ## Numpy ##
-Numpy types `array` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
+For Numpy types `array` and `matrix` and `ndarray`, use `mg.extend_numpy()`:
 
 ```python
 import memory_graph as mg
 import numpy as np
-import memory_graph.extension_numpy
+mg.extend_numpy()
 np.random.seed(0) # use same random numbers each run
 
 matrix = np.matrix([[i*5+j for j in range(4)] for i in range(5)])
@@ -1072,12 +1081,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=numpy&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_numpy.py&continues=1).
 
 ## Pandas ##
-Pandas types `Series` and `DataFrame` can be graphed with "memory_graph.extension_pandas":
+For pandas types `Series` and `DataFrame`, use `mg.extend_pandas()`:
 
 ```python
 import memory_graph as mg
 import pandas as pd
-import memory_graph.extension_pandas
+mg.extend_pandas()
 
 series = pd.Series( [i for i in range(20)] )
 dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
@@ -1093,12 +1102,12 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#micropip=pandas&codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/mg_pandas.py&continues=1).
 
 ## PyTorch ##
-Torch type `tensor` can be graphed with "memory_graph.extension_torch":
+For torch type `tensor`, use `mg.extend_torch()`:
 
 ```python
 import memory_graph as mg
 import torch
-import memory_graph.extension_torch
+mg.extend_torch()
 torch.manual_seed(0) # same random numbers each run
 
 tensor_1d = torch.rand(3)
@@ -1171,4 +1180,4 @@ $ bash create_gif.sh animated
 - When graph edges overlap it can be hard to distinguish them. Using an interactive graphviz viewer, such as [xdot](https://github.com/jrfonseca/xdot.py), on a '*.gv' DOT output file will help.
 
 # Other Packages #
-The [memory_graph](https://pypi.org/project/memory-graph/) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://pypi.org/project/invocation-tree/) package.
+The [memory_graph](https://github.com/bterwijn/memory_graph) package visualizes your data. If instead you want to visualize function calls, check out the [invocation_tree](https://github.com/bterwijn/invocation_tree) package.

{memory_graph-0.3.65 → memory_graph-0.3.67}/memory_graph.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE.txt
 README.md
 pyproject.toml
-setup.py
 memory_graph/__init__.py
 memory_graph/call_stack.py
 memory_graph/config.py

{memory_graph-0.3.65 → memory_graph-0.3.67}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.65"
+version = "0.3.67"
 description = "Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy."
 authors = [
     {name = "Bas Terwijn", email = "bterwijn@gmail.com"}

memory_graph-0.3.65/memory_graph/extension_numpy.py

@@ -1,33 +0,0 @@
-# This file is part of memory_graph.
-# Copyright (c) 2023, Bas Terwijn.
-# SPDX-License-Identifier: BSD-2-Clause
-
-""" Extension to add the memory graph configuration for Numpy types. """
-from memory_graph.node_linear import Node_Linear
-from memory_graph.node_table import Node_Table
-
-import memory_graph.config as config
-
-import numpy as np
-
-config.embedded_types |= {
-    np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, 
-    np.float16, np.float32, np.float64,
-    np.complex64, np.complex128,
-    np.bool_, np.bytes_, np.str_, np.datetime64, np.timedelta64
-}
-
-def ndarray_to_node(data, ndarray_data):
-    dim = len(ndarray_data.shape)
-    if dim > 2:
-        return Node_Linear(data, [i for i in ndarray_data])
-    elif dim == 2:
-        return Node_Table(data, ndarray_data)
-    else:
-        return Node_Linear(data, ndarray_data)
-
-config.type_to_node[np.matrix] = lambda data : Node_Table(data, np.asarray(data)) # convert to ndarray to avoid infinite recursion due to index issue
-config.type_to_node[np.ndarray] = lambda data : ndarray_to_node(data, data)
-
-config.type_to_color[np.ndarray] = "hotpink1"
-config.type_to_color[np.matrix] = "hotpink2"

memory_graph-0.3.65/memory_graph/extension_pandas.py

@@ -1,26 +0,0 @@
-# This file is part of memory_graph.
-# Copyright (c) 2023, Bas Terwijn.
-# SPDX-License-Identifier: BSD-2-Clause
-
-""" Extension to add the memory graph configuration for Pandas type. """
-from memory_graph.node_linear import Node_Linear
-from memory_graph.node_table import Node_Table
-
-import memory_graph.config as config
-
-import pandas as pd
-
-config.type_to_node[pd.DataFrame] = lambda data : (
-    Node_Table(data, 
-               data.values.tolist(),
-               col_names = data.columns.tolist(),
-               row_names = [ str(i) for i in data.index.tolist()]
-            )
-)
-
-config.type_to_node[pd.Series] = lambda data : (
-    Node_Linear(data, data.tolist())
-)
-
-config.type_to_color[pd.DataFrame] = "olivedrab1"
-config.type_to_color[pd.Series] = "olivedrab2"

memory_graph-0.3.65/memory_graph/extension_torch.py

@@ -1,6 +0,0 @@
-import memory_graph.extension_numpy as ext_np
-import memory_graph.config as config
-import torch
-
-config.type_to_node[torch.Tensor] = lambda data : ext_np.ndarray_to_node(data, data.numpy())
-config.type_to_color[torch.Tensor] = "darkolivegreen1"

memory_graph-0.3.65/setup.py

@@ -1,7 +0,0 @@
-from setuptools import setup
-
-setup(
-    name="memory-graph",
-    version="0.3.30",
-    packages=["memory_graph"],
-)