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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.11
+Version: 0.3.13
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -156,7 +156,7 @@ mg.render(locals(), 'immutable2.png')
 
 
 ### Mutable Type ###
-With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy so that `a` and `b` are independent.
+With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
 
 ```python
 import memory_graph as mg
@@ -264,7 +264,7 @@ This function:
 * then blocks execution until the <Enter> key is pressed
 * finally returns the value of the `fun()` call
 
-to change it's behavior:
+to change its behavior:
 * Set `mg.block_prints_location = False` to skip printing the source location.
 * Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
 
@@ -326,7 +326,7 @@ For the best debugging experience with memory_graph set for example expression:
 ```
 mg.render(locals(), "my_graph.pdf")
 ```
-as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()`, `render()` calls to your code.
+as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
 The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
@@ -511,7 +511,7 @@ for i in range(n):
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
 - ***mg.config.max_graph_depth*** : int
-  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short.
+  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short. Dashed references indicate that there are more references to a node than are shown.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -534,8 +534,29 @@ Different aspects of memory_graph can be configured. The default configuration i
 - ***mg.config.type_to_slicer*** : dict
   - 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`.
+
+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
+import memory_graph as mg
+
+a = [100, 200, 300]
+b = a.copy()
+mg.render(locals(), 'not_node_types1.png')
+
+mg.config.not_node_types.remove(int) # now show separate nodes for int values
+
+mg.render(locals(), 'not_node_types2.png')
+```
+| ![not_node_types1](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types1.png) | ![not_node_types2](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/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.
+
 ### Temporary Configuration ###
-In addition to the global configuration, a temporary configuration can be set for a single `show()`, `render()`, `d()`, `ds()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
+In addition to the global configuration, a temporary configuration can be set for a single `show()` or `render()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
 
 ```python
 import memory_graph as mg
@@ -545,7 +566,7 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to "red"
+    colors                = {id(highlight): "red"   }, # set color to red
     vertical_orientations = {id(highlight): False   }, # set horizontal orientation
     slicers               = {id(highlight): Slicer()}  # set no slicing 
 )
@@ -736,7 +757,7 @@ display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables in
 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).
+See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
@@ -750,7 +771,7 @@ Then after starting 'ipython' call function `mg_switch()` to turn on/off the aut
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)
 
 ## In the Browser ##
-We can run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
+We can also run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
 ![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##

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

@@ -137,7 +137,7 @@ mg.render(locals(), 'immutable2.png')
 
 
 ### Mutable Type ###
-With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy so that `a` and `b` are independent.
+With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
 
 ```python
 import memory_graph as mg
@@ -245,7 +245,7 @@ This function:
 * then blocks execution until the <Enter> key is pressed
 * finally returns the value of the `fun()` call
 
-to change it's behavior:
+to change its behavior:
 * Set `mg.block_prints_location = False` to skip printing the source location.
 * Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
 
@@ -307,7 +307,7 @@ For the best debugging experience with memory_graph set for example expression:
 ```
 mg.render(locals(), "my_graph.pdf")
 ```
-as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()`, `render()` calls to your code.
+as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
 The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
@@ -492,7 +492,7 @@ for i in range(n):
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
 - ***mg.config.max_graph_depth*** : int
-  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short.
+  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short. Dashed references indicate that there are more references to a node than are shown.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -515,8 +515,29 @@ Different aspects of memory_graph can be configured. The default configuration i
 - ***mg.config.type_to_slicer*** : dict
   - 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`.
+
+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
+import memory_graph as mg
+
+a = [100, 200, 300]
+b = a.copy()
+mg.render(locals(), 'not_node_types1.png')
+
+mg.config.not_node_types.remove(int) # now show separate nodes for int values
+
+mg.render(locals(), 'not_node_types2.png')
+```
+| ![not_node_types1](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types1.png) | ![not_node_types2](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/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.
+
 ### Temporary Configuration ###
-In addition to the global configuration, a temporary configuration can be set for a single `show()`, `render()`, `d()`, `ds()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
+In addition to the global configuration, a temporary configuration can be set for a single `show()` or `render()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
 
 ```python
 import memory_graph as mg
@@ -526,7 +547,7 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to "red"
+    colors                = {id(highlight): "red"   }, # set color to red
     vertical_orientations = {id(highlight): False   }, # set horizontal orientation
     slicers               = {id(highlight): Slicer()}  # set no slicing 
 )
@@ -717,7 +738,7 @@ display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables in
 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).
+See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
@@ -731,7 +752,7 @@ Then after starting 'ipython' call function `mg_switch()` to turn on/off the aut
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)
 
 ## In the Browser ##
-We can run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
+We can also run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
 ![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##

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

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

{memory_graph-0.3.11 → memory_graph-0.3.13}/memory_graph/html_table.py

@@ -4,20 +4,13 @@
 
 from memory_graph.node_base import Node_Base 
 import memory_graph.node_base
-
 import memory_graph.config as config
-
 import html
 
-def outer_html_table(s, border, color):
-    """ Helper function to add the outer HTML table tags to the string s setting the 'border' and 'color'. """
-    return (f'<\n<TABLE BORDER="0" CELLBORDER="{border}" CELLSPACING="0" CELLPADDING="0" BGCOLOR="{color}"><TR><TD PORT="table">\n' +
-            s + '\n</TD></TR></TABLE>\n>')
-
-def inner_html_table(s):
-    """ Helper function to add the innner HTML table tags to the string s. """
-    return ('  <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="5" CELLPADDING="0">\n    <TR>' +
-            s + '</TR>\n  </TABLE>')
+def html_table_frame(s, border, color, spacing=5):
+    """ Helper function to add the HTML table frame to the string s setting the 'border' and 'color'. """
+    return (f'<\n<TABLE BORDER="{border}" CELLBORDER="1" CELLSPACING="{spacing}" CELLPADDING="0" BGCOLOR="{color}" PORT="table">\n    <TR>' +
+            s + '</TR>\n</TABLE>\n>')
 
 def format_string(s):
     """ Helper function to format the string s to be shown in the graph. Setting the max_string_length and escaping html characters. """
@@ -37,6 +30,7 @@ class HTML_Table:
         """
         self.html = ''
         self.add_new_line_flag = False
+        self.is_empty = True
         self.col_count = 0
         self.row_count = 0
         self.ref_count = 0
@@ -61,18 +55,19 @@ class HTML_Table:
             self.html += '</TR>\n    <TR>'
             self.add_new_line_flag = False
 
-    def add_string(self, s):
-        """ Add a string s to the outer table. """
-        self.html += format_string(s)
+    def add_string(self, s, border=0):
+        """ Add a string s to the table. """
+        self.html += f'<TD BORDER="{border}">'+format_string(s)+'</TD>'
+        self.is_empty = False
 
     def add_index(self, s):
-        """ Add an index s to the inner table. """
+        """ Add an index s to the table. """
         self.check_add_new_line()
-        self.html += f'<TD><font color="#505050">{str(s)}</font></TD>'
+        self.html += f'<TD BORDER="0"><font color="#505050">{str(s)}</font></TD>'
         self.col_count += 1
 
     def add_entry(self, node, nodes, child, id_to_slices, rounded=False, border=1, dashed=False):
-        """ Add child to the inner table either as reference if it is a Node_Base or as a value otherwise. """
+        """ Add child to the table either as reference if it is a Node_Base or as a value otherwise. """
         #print('child:', child)
         child_id = id(child)
         if child_id in nodes:
@@ -85,14 +80,14 @@ class HTML_Table:
             self.add_value(child, rounded, border)
 
     def add_value(self, s, rounded=False, border=1):
-        """ Helper function to add a value s to the inner table. """
+        """ Helper function to add a value s to the table. """
         self.check_add_new_line()
         r = ' STYLE="ROUNDED"' if rounded else ''
         self.html += f'<TD BORDER="{border}"{r}> {format_string(s)} </TD>'
         self.col_count += 1
 
     def add_reference(self, node, child, rounded=False, border=1, dashed=False):
-        """ Helper function to add a reference to the inner table. """
+        """ Helper function to add a reference to the table. """
         self.check_add_new_line()
         r = ' STYLE="ROUNDED"' if rounded else ''
         self.html += f'<TD BORDER="{border}" PORT="ref{self.ref_count}"{r}> </TD>'
@@ -102,7 +97,7 @@ class HTML_Table:
         self.col_count += 1
 
     def add_dots(self, rounded=False, border=1):
-        """ Helper function to add dots to the inner table. """
+        """ Helper function to add dots to the table. """
         self.check_add_new_line()
         r = 'STYLE="ROUNDED"' if rounded else ''
         self.html += f'<TD BORDER="{border}" {r}>...</TD>'
@@ -110,26 +105,26 @@ class HTML_Table:
 
     def to_string(self, border=1, color='white'):
         """ Construct the HTML table string with the 'border' and 'color' settings. """
-        if self.col_count != 0 or self.row_count != 0:
-            self.html = inner_html_table(self.html)
-        if len(self.html) == 0:
-            self.html = ' '
-        return outer_html_table(self.html, border, color)
+        if self.col_count == 0 and self.row_count == 0:
+            if self.is_empty:
+                self.add_string(' ')
+            return html_table_frame(self.html, border, color, spacing=0)
+        return html_table_frame(self.html, border, color)
     
     def get_column(self):
-        """ Get the number of columns in the inner table. """
+        """ Get the number of columns in the table. """
         return self.col_count
     
     def get_max_column(self):
-        """ Get the maximum value of the number of columns of rows in the inner tables. """
+        """ Get the maximum value of the number of columns of rows in the table. """
         return self.max_col_count
     
     def get_row(self):
-        """ Get the number of rows in the inner table. """
+        """ Get the number of rows in the table. """
         return self.row_count
 
     def get_edges(self):
-        """ Get the edges that need to be acced t connect the table to other tables in the graph. """
+        """ Get the edges that need to be added to connect the table to other tables in the graph. """
         return self.edges
 
 if __name__ == '__main__':
@@ -138,6 +133,6 @@ if __name__ == '__main__':
     columns = 5
     for r in range(rows):
         for c in range(columns):
-            table.add_column(f'{c},{r}')
+            table.add_value(f'{c},{r}')
         table.add_new_line()
-    print(table)
+    print(table.to_string())

memory_graph-0.3.13/memory_graph/t.py

@@ -0,0 +1,6 @@
+import memory_graph as mg
+
+a= [0,10000,5]
+
+mg.render(a, 'value.svg')
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.11
+Version: 0.3.13
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -156,7 +156,7 @@ mg.render(locals(), 'immutable2.png')
 
 
 ### Mutable Type ###
-With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy so that `a` and `b` are independent.
+With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `a` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `a` also changes `b` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
 
 ```python
 import memory_graph as mg
@@ -264,7 +264,7 @@ This function:
 * then blocks execution until the <Enter> key is pressed
 * finally returns the value of the `fun()` call
 
-to change it's behavior:
+to change its behavior:
 * Set `mg.block_prints_location = False` to skip printing the source location.
 * Set `mg.press_enter_message = None` to skip printing "Press <Enter> to continue...".
 
@@ -326,7 +326,7 @@ For the best debugging experience with memory_graph set for example expression:
 ```
 mg.render(locals(), "my_graph.pdf")
 ```
-as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()`, `render()` calls to your code.
+as a *watch* in a debugger tool such as the integrated debugger in Visual Studio Code. Then open the "my_graph.pdf" output file to continuously see all the local variables while debugging. This avoids having to add any memory_graph `show()` or `render()` calls to your code.
 
 ### Call Stack in Watch Context ###
 The ```mg.get_call_stack()``` doesn't work well in *watch* context in most debuggers because debuggers introduce additional stack frames that cause problems. Use these alternative functions for various debuggers to filter out these problematic stack frames:
@@ -511,7 +511,7 @@ for i in range(n):
 Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
 - ***mg.config.max_graph_depth*** : int
-  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short.
+  - The maxium depth of the graph with default value 12. A `✂` (scissor) symbol indicates where the graph is cut short. Dashed references indicate that there are more references to a node than are shown.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -534,8 +534,29 @@ Different aspects of memory_graph can be configured. The default configuration i
 - ***mg.config.type_to_slicer*** : dict
   - 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`.
+
+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
+import memory_graph as mg
+
+a = [100, 200, 300]
+b = a.copy()
+mg.render(locals(), 'not_node_types1.png')
+
+mg.config.not_node_types.remove(int) # now show separate nodes for int values
+
+mg.render(locals(), 'not_node_types2.png')
+```
+| ![not_node_types1](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/not_node_types1.png) | ![not_node_types2](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/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.
+
 ### Temporary Configuration ###
-In addition to the global configuration, a temporary configuration can be set for a single `show()`, `render()`, `d()`, `ds()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
+In addition to the global configuration, a temporary configuration can be set for a single `show()` or `render()` call to change the colors, orientation, and slicer. This example highlights a particular list element in red, gives it a horizontal orientation, and overwrites the default slicer for lists:
 
 ```python
 import memory_graph as mg
@@ -545,7 +566,7 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to "red"
+    colors                = {id(highlight): "red"   }, # set color to red
     vertical_orientations = {id(highlight): False   }, # set horizontal orientation
     slicers               = {id(highlight): Slicer()}  # set no slicing 
 )
@@ -736,7 +757,7 @@ display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables in
 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).
+See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/src/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
 
 ## ipython ##
@@ -750,7 +771,7 @@ Then after starting 'ipython' call function `mg_switch()` to turn on/off the aut
 ![ipyton.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/ipython.png)
 
 ## In the Browser ##
-We can run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
+We can also run memory_graph in the browser: <a href="https://bterwijn.github.io/memory_graph/src/pyodide.html" target="_blank">Pyodide Example</a>
 ![pyodide.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/pyodide.png)
 
 ## Troubleshooting ##

{memory_graph-0.3.11 → memory_graph-0.3.13}/memory_graph.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ memory_graph/slicer.py
 memory_graph/slices.py
 memory_graph/slices_iterator.py
 memory_graph/slices_table_iterator.py
+memory_graph/t.py
 memory_graph/test.py
 memory_graph/test_max_graph_depth.py
 memory_graph/test_memory_graph.py

{memory_graph-0.3.11 → memory_graph-0.3.13}/setup.py

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