memory-graph 0.3.6__tar.gz → 0.3.8__tar.gz

{memory_graph-0.3.6/memory_graph.egg-info → memory_graph-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.3.6
+Version: 0.3.8
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -68,7 +68,7 @@ identical?: True
 A better way to understand what data is shared is to draw a graph of the data using the [memory_graph](https://pypi.org/project/memory-graph/) package.
 
 # Memory Graph #
-The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types.
+The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types, not limited to:
 
 ```python
 import memory_graph as mg
@@ -80,14 +80,15 @@ class MyClass:
         self.y = y
 
 data = [ range(1, 2), (3, 4), {5, 6}, {7:'seven', 8:'eight'},  MyClass(9, 10) ]
-mg.show(data, block=True)
+mg.show(data)
 ```
 ![many_types.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/many_types.png)
 
-By using `block=True` the program blocks until the <Enter> key is pressed so you can view the graph before continuing program execution (and possibly viewing later graphs). Instead of showing the graph you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
+Instead of showing the graph you can also render it to an output file of your choosing (see [Graphviz Output Formats](https://graphviz.org/docs/outputs/)) using for example:
 
 ```python
 mg.render(data, "my_graph.pdf")
+mg.render(data, "my_graph.svg")
 mg.render(data, "my_graph.png")
 mg.render(data, "my_graph.gv") # Graphviz DOT file
 ```
@@ -106,6 +107,8 @@ mg.render(data, "my_graph.gv") # Graphviz DOT file
 
 [Extensions](#extensions)
 
+[Introspection](#introspection)
+
 [Jupyter Notebook](#jupyter-notebook)
 
 [Troubleshooting](#troubleshooting)
@@ -190,7 +193,7 @@ mg.show(locals())
 
 
 ### Custom Copy Method ###
-We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example the copy() method of My_Class in the code below copies the `digits` but shares the `letters` between the two objects.
+We can write our own custom copy function or method in case the three "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
 
 ```python
 import memory_graph as mg
@@ -216,7 +219,7 @@ mg.show(locals())
 
 
 ## Call Stack ##
-The function `mg.get_call_stack()` returns the complete call stack, including all local variables for each function in the stack. This allows us to simultaneously visualize the local variables of all the called functions. By doing so, we can identify whether any local variables from different functions in the call stack share data with one another. Here for example we call function ```add_one()``` with arguments ```a, b, c``` that adds 1 to each of its arguments.
+The `mg.get_call_stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. Then by examining the graph, we can determine whether any local variables from different functions on the call stack share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters, `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -243,9 +246,17 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
+### Block ###
+It is often helpful to temporarily block program execution to inspect the graph. For this, you can use the `mg.block()` function:
+
+```python
+mg.block(fun, arg1, arg2, ..., loc=True) 
+```
+
+This function first executes `fun(arg1, arg2, ...)`, then prints the current source location in the program, and blocks execution until the &lt;Enter&gt; key is pressed. To skip printing the source location, set `loc=False`.
 
 ### Recursion ###
-The call stack can be used to visualize how recursion works. Here we show each step of how recursively ```factorial(3)``` is computed:
+The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
 
 ```python
 import memory_graph as mg
@@ -253,28 +264,26 @@ import memory_graph as mg
 def factorial(n):
     if n==0:
         return 1
-    mg.show( mg.get_call_stack(), block=True )
+    mg.block(mg.show, mg.get_call_stack())
     result = n * factorial(n-1)
-    mg.show( mg.get_call_stack(), block=True )
+    mg.block(mg.show, mg.get_call_stack())
     return result
 
 print(factorial(3))
 ```
 
-Execution results in:
-
 ![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
 
 and the result is: 1 x 2 x 3 = 6
 
 ### Power Set ###
-A more insteresting recursive example that shows sharing of data is power_set(). A power set is the set of all subsets of a collection of values.
+A more interesting recursive example that shows sharing of data is power_set(). A power set is the set of all subsets of a collection of values.
 
 ```python
 import memory_graph as mg
 
 def get_subsets(subsets, data, i, subset):
-    mg.show(mg.get_call_stack(), block=True)
+    mg.block(mg.show, mg.get_call_stack())
     if i == len(data):
         subsets.append(subset.copy())
         return
@@ -282,7 +291,7 @@ def get_subsets(subsets, data, i, subset):
     get_subsets(subsets, data, i+1, subset) #    do include data[i]
     subset.pop()
     get_subsets(subsets, data, i+1, subset) # don't include data[i]
-    mg.show(mg.get_call_stack(), block=True)
+    mg.block(mg.show, mg.get_call_stack())
 
 def power_set(data):
     subsets = []
@@ -292,8 +301,6 @@ def power_set(data):
 print( power_set(['a', 'b', 'c']) )
 ```
 
-Execution results in:
-
 ![power_set.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/power_set.gif)
 ```
 [['a', 'b', 'c'], ['a', 'b'], ['a', 'c'], ['a'], ['b', 'c'], ['b'], ['c'], []]
@@ -329,49 +336,28 @@ mg.get_call_stack_after_up_to(after_function, up_to_function="<module>")
 
 ### Debugging without Debugger Tool ###
 
-To make debugging without a debugger tool easier we provide these alias functions that you can add to your code where you want to view a graph:
-
-| alias | function|
-|:---|:---|
-| `d()` | `mg.show(locals(), block=True)` |
-| `ds()` | `mg.show(mg.get_call_stack(), block=True)` |
-
-These functions have the following default arguments:
-```python
-def d(data=None, graph=True, log=False, block=True):
-```
-- data: defaults to locals() and mg.get_call_stack() respectively
-- graph: if True the data is visualized as a graph
-- log: if True the data is printed
-- block: if True the function blocks until the &lt;Enter&gt; key is pressed
+To simplify debugging without a debugger tool, we offer these blocking alias functions that you can insert into your code at a specific point to visualize a graph:
 
-To print to a log file instead of standard output use:
-```python
-mg.log_file = open("my_log_file.txt", "w")
-```
+| alias | purpose | function call |
+|:---|:---|:---|
+| `mg.l()` | graph **l**ocal variables and block | `mg.block(mg.show, locals())` |
+| `mg.s()` | graph the call **s**tack and block | `mg.block(mg.show, mg.get_call_stack())` |
 
 For example, executing this program:
 
 ```python
-import memory_graph as mg
-from memory_graph import d, ds
+from memory_graph as mg
 
 squares = []
 squares_collector = []
 for i in range(1, 6):
     squares.append(i**2)
     squares_collector.append(squares.copy())
-    d(log=True)
+    mg.l() # graph local variables
 ```
-and pressing &lt;Enter&gt; a number of times, produces:
+and pressing &lt;Enter&gt; a number of times, results in:
 
 ![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.gif)
-```
-squares: [1, 4, 9, 16, 25]
-squares_collector: [[1], [1, 4], [1, 4, 9], [1, 4, 9, 16], [1, 4, 9, 16, 25]]
-i: 5
-```
-
 
 ## Datastructure Examples ##
 Module memory_graph can be very useful in a course about datastructures, some examples:
@@ -404,7 +390,7 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
-        mg.show(locals(), block=True) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw graph
 
 linked_list = LinkedList()
 n = 100
@@ -443,7 +429,7 @@ class BinTree:
                 node.larger = Node(new_value)
             else:
                 self.add_recursive(new_value, node.larger)
-        mg.show(locals(), block=True) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw graph
 
     def add(self, value):
         if self.root is None:
@@ -476,7 +462,7 @@ class HashSet:
             self.buckets[index] = []
         bucket = self.buckets[index]
         bucket.append(value)
-        mg.show(locals(), block=True) # <--- draw graph
+        mg.block(mg.show, locals()) # <--- draw graph
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -499,10 +485,10 @@ for i in range(n):
 
 
 ## Configuration ##
-Different aspects of memory_graph can be configured. The default configuration is reset by importing 'mg.config_default'.
+Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
 
-- ***mg.config.max_number_nodes*** : int
-  - The maxium number of Nodes shown in the graph. When the graph gets too big set this to a smaller number. A `★` symbol indictes where the graph is cut short.
+- ***mg.config.max_tree_depth*** : int
+  - The maxium depth of the graph. A `★` symbol indictes where the graph is cut short.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -547,7 +533,7 @@ mg.show( locals(),
 Different extensions are available for types from other Python packages. 
 
 ### Numpy ###
-Numpy types `arrray` and `matrix` and `ndarray` can be graphed with the "memory_graph.extension_numpy" extension:
+Numpy types `arrray` and `matrix` and `ndarray` can be graphed with "memory_graph.extension_numpy":
 
 ```python
 import memory_graph as mg
@@ -558,12 +544,12 @@ np.random.seed(0) # use same random numbers each run
 array = np.array([1.1, 2, 3, 4, 5])
 matrix = np.matrix([[i*20+j for j in range(20)] for i in range(20)])
 ndarray = np.random.rand(20,20)
-mg.show(locals(), block=True)
+mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_numpy.png)
 
 ### Pandas ###
-Pandas types `Series` and `DataFrame` can be graphed with the "memory_graph.extension_pandas" extension:
+Pandas types `Series` and `DataFrame` can be graphed with "memory_graph.extension_pandas":
 
 ```python
 import memory_graph as mg
@@ -577,13 +563,155 @@ dataframe2 = pd.DataFrame({  'Name'   : [ 'Tom', 'Anna', 'Steve', 'Lisa'],
                              'Age'    : [    28,     34,      29,     42],
                              'Length' : [  1.70,   1.66,    1.82,   1.73] },
                             index=['one', 'two', 'three', 'four']) # with row names
-mg.show(locals(), block=True)
+mg.show(locals())
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 
+## Introspection ##
+This section is likely to change. Sometimes the introspection fails or is not as desired. For example the `bintrees.avltree.Node` object doesn't show any attributes in the graph below:
+
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_fail.png)
+
+
+### dir() ###
+A usefull 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.
+
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node_Linear(data, 
+                                                dir(data))
+mg.config.type_to_slicer[bintrees.avltree.Node] = mg.slicer.Slicer()
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_dir.png)
+
+Next figure out what are the attributes you want to graph and choose a Node type, there are four options.
+
+### 1 Node_Base ###
+Node_base is a leaf node (with no children) and shows just a single value.
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_base.Node_Base(f"key:{data.key} value:{data.value}")
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_base.png)
+
+### 2 Node_Linear ###
+Node_Linear shows all the values in a line like a list.
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_linear.Node_Linear(data,
+                                                ['left:', data.left,
+                                                 'key:', data.key,
+                                                 'value:', data.value,
+                                                 'right:', data.right] )
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_linear.png)
+
+### 3 Node_Key_Value ###
+Node_Key_Value shows key-value pairs like a dictionary. Note the required `items()` call at the end.
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_key_value.Node_Key_Value(data,
+                                                {'left': data.left,
+                                                 'key': data.key,
+                                                 'value': data.value,
+                                                 'right': data.right}.items() )
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_key_value.png)
+
+### 4 Node_Table ###
+Node_Table shows all the values as a table.
+```python
+import memory_graph as mg
+import bintrees
+
+# Create an AVL tree
+tree = bintrees.AVLTree()
+tree.insert(10, "ten")
+tree.insert(5, "five")
+tree.insert(20, "twenty")
+tree.insert(15, "fifteen")
+
+mg.config.type_to_color[bintrees.avltree.Node] = "sandybrown"
+mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_table.Node_Table(data,
+                                                [[data.key, data.value],
+                                                 [data.left, data.right]] )
+
+
+mg.show(locals())
+```
+![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/avltree_table.png)
+
+
 ## Jupyter Notebook ##
+In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out.
+
+We can use `mg.show()` and `mg.render()` in a Jupyter Notebook, but alternatively we can also use `mg.create_graph()` to create a graph and the `display()` function to render it inline with for example:
 
-In Jupyter Notebook `locals()` has additional variables that cause problems in the graph, use `mg.locals_jupyter()` to get the local variables with these problematic variables filtered out. Use `mg.get_call_stack_jupyter()` to get the whole call stack with these variables filtered out. 
+```python
+display( mg.create_graph(mg.locals_jupyter()) ) # display the local variables inline
+mg.block(display, mg.create_graph(mg.locals_jupyter()) ) # the same but blocked
+```
 
 See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.ipynb).
 ![jupyter_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/jupyter_example.png)
@@ -591,6 +719,6 @@ See for example [jupyter_example.ipynb](https://raw.githubusercontent.com/bterwi
 
 ## Troubleshooting ##
 
-- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([Evince](https://www.fosshub.com/Evince.html) for example) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and open it manually.
+- Adobe Acrobat Reader [doesn't refresh a PDF file](https://superuser.com/questions/337011/windows-pdf-viewer-that-auto-refreshes-pdf-when-compiling-with-pdflatex) when it changes on disk and blocks updates which results in an `Could not open 'somefile.pdf' for writing : Permission denied` error. One solution is to install a PDF reader that does refresh ([Evince](https://www.fosshub.com/Evince.html), [Okular](https://okular.kde.org/), [SumatraPDF](https://www.sumatrapdfreader.org/), ...) and set it as the default PDF reader. Another solution is to `render()` the graph to a different output format and to open it manually.
 
 - 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.