memory-graph 0.3.37__tar.gz → 0.3.39__tar.gz

{memory_graph-0.3.37/memory_graph.egg-info → memory_graph-0.3.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.37
+Version: 0.3.39
 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
@@ -57,11 +57,11 @@ mg.render(data, "my_graph.pdf")
 mg.render(data, "my_graph.svg")
 mg.render(data, "my_graph.png")
 mg.render(data, "my_graph.gv") # Graphviz DOT file
-mg.render(data) # renders to 'mg.render_filename' with default value: 'memory_graph.pdf'
+mg.render(data) # renders to default: 'memory_graph.pdf'
 ```
 
 # Sharing Values #
-In Python, assigning the 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.
+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> 
 
@@ -100,7 +100,7 @@ b: 4, 3, 2, 1
 ids: 126432214913216 126432214913216
 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.
+A better way to understand what data is shared is to draw a graph using [memory_graph](https://pypi.org/project/memory-graph/).
 
 # Chapters #
 
@@ -108,20 +108,18 @@ A better way to understand what data is shared is to draw a graph of the data us
 
 [Call Stack](#call-stack)
 
-[Global Import Trick](#global-import-trick)
-
 [Debugging](#debugging)
 
 [Data Structure Examples](#data-structure-examples)
 
 [Configuration](#configuration)
 
-[Extensions](#extensions)
-
 [Introspection](#introspection)
 
 [Graph Depth](#graph-depth)
 
+[Extensions](#extensions)
+
 [Jupyter Notebook](#jupyter-notebook)
 
 [ipython](#ipython)
@@ -182,7 +180,7 @@ a = [4, 3, 2]
 b = a
 mg.render(locals(), 'mutable1.png')
 
-b += [1] # equivalent to:  b.append(1)
+b += [1]  # equivalent to:  b.append(1)
 mg.render(locals(), 'mutable2.png')
 ```
 | ![mutable1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/mutable1.png) | ![mutable2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/mutable2.png) |
@@ -198,11 +196,11 @@ Python offers three different "copy" options that we will demonstrate using a ne
 import memory_graph as mg
 import copy
 
-a = [ [1, 2], ['x', 'y'] ] # a nested list (a list containing lists)
+a = [ [1, 2], ['x', 'y'] ]  # a nested list (a list containing lists)
 
 # three different ways to make a "copy" of 'a':
 c1 = a
-c2 = copy.copy(a) # equivalent to:  a.copy() a[:] list(a)
+c2 = copy.copy(a)  # equivalent to:  a.copy() a[:] list(a)
 c3 = copy.deepcopy(a)
 
 mg.show(locals())
@@ -300,10 +298,6 @@ This function:
 * then blocks execution until the &lt;Enter&gt; key is pressed
 * finally returns the value of the `fun()` call
 
-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 &lt;Enter&gt; to continue...".
-
 ## Recursion ##
 The call stack is also helpful to visualize how recursion works. Here we use `mg.block()` to show each step of how recursively ```factorial(3)``` is computed:
 
@@ -337,9 +331,9 @@ def get_subsets(subsets, data, i, subset):
         subsets.append(subset.copy())
         return
     subset.append(data[i])
-    get_subsets(subsets, data, i+1, subset) #    do include data[i]
+    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]
+    get_subsets(subsets, data, i+1, subset)  # don't include data[i]
     mg.block(mg.show, mg.stack())
 
 def power_set(data):
@@ -375,6 +369,7 @@ The ```mg.stack()``` doesn't work well in *watch* context in most debuggers beca
 | [Wing](https://wingware.com/) | `mg.stack_wing()` |
 
 ![vscode_copying.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/vscode_copying.gif)
+See the [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) video for the setup.
 
 ## Other Debuggers ##
 For other debuggers, invoke this function within the *watch* context. Then, in the "call_stack.txt" file, identify the slice of functions you wish to include as stack frames in the call stack.
@@ -432,7 +427,7 @@ Package memory_graph can be very useful in a data structures course, some exampl
 ```python
 import memory_graph as mg
 import random
-random.seed(0) # use same random numbers each run
+random.seed(0)  # use same random numbers each run
 
 class Linked_List:
     """ Circular doubly linked list """
@@ -458,7 +453,7 @@ n = 100
 for i in range(n):
     value = random.randrange(n)
     linked_list.add_back(value)
-    mg.block(mg.show, locals()) # <--- draw locals
+    mg.block(mg.show, locals())  # <--- draw locals
 ```
 ![linked_list.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/linked_list.png)
 
@@ -492,7 +487,7 @@ class BinTree:
                 self.larger = BinTree(value)
             else:
                 self.larger.add(value)
-        mg.block(mg.show, mg.stack()) # <--- draw stack
+        mg.block(mg.show, mg.stack())  # <--- draw stack
 
 tree = BinTree()
 n = 100
@@ -511,7 +506,7 @@ Here we show values being inserted in a Binary Tree in Visual Studio Code. When
 ```python
 import memory_graph as mg
 import random
-random.seed(0) # use same random numbers each run
+random.seed(0)  # use same random numbers each run
 
 class HashSet:
 
@@ -524,7 +519,7 @@ class HashSet:
             self.buckets[index] = []
         bucket = self.buckets[index]
         bucket.append(value)
-        mg.block(mg.show, locals()) # <--- draw locals
+        mg.block(mg.show, locals())  # <--- draw locals
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -549,9 +544,20 @@ for i in range(n):
 Here we show values being inserted in a HashSet in PyCharm. When inserting the last value '44' we "Step Into" the code to show more of the details.
 ![images/hash_set.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/hash_set.gif)
 
-
 # Configuration #
-Different aspects of memory_graph can be configured. The default configuration is reset by importing 'memory_graph.config_default'.
+Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'.
+
+- ***mg.reopen_viewer*** : bool
+  - If True the viewer is reopened each time show() is called, this might change window focus, default True.
+
+- ***mg.config.render_filename*** : str
+  - The default filename to render to, default 'memory_graph.pdf'.
+
+- ***mg.config.block_prints_location*** : bool
+  - If True the source location is printed in block(), default True.
+  
+- ***mg.config.press_enter_message*** : str
+  - Message to ask user to press &lt;Enter&gt; in block(), set to None to disable.
 
 - ***mg.config.max_string_length*** : int
   - The maximum length of strings shown in the graph. Longer strings will be truncated.
@@ -598,7 +604,7 @@ 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.config.not_node_types.remove(int)  # now show separate nodes for int values
 
 mg.render(locals(), 'not_node_types2.png')
 ```
@@ -619,51 +625,13 @@ data = [ list(range(20)) for i in range(1,5)]
 highlight = data[2]
 
 mg.show( locals(),
-    colors                = {id(highlight): "red"   }, # set color to red
-    vertical_orientations = {id(highlight): False   }, # set horizontal orientation
-    slicers               = {id(highlight): Slicer()}  # set no slicing 
+    colors                = {id(highlight): "red"   },  # set color to red
+    vertical_orientations = {id(highlight): False   },  # set horizontal orientation
+    slicers               = {id(highlight): Slicer()}   # set no slicing
 )
 ```
 ![highlight.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/highlight.png)
 
-# Extensions #
-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":
-
-```python
-import memory_graph as mg
-import numpy as np
-import memory_graph.extension_numpy
-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())
-```
-![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 "memory_graph.extension_pandas":
-
-```python
-import memory_graph as mg
-import pandas as pd
-import memory_graph.extension_pandas
-
-series = pd.Series( [i for i in range(20)] )
-dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
-                             "duration": [50, 40, 45] })
-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())
-```
-![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.
 
@@ -795,11 +763,62 @@ mg.config.type_to_node[bintrees.avltree.Node] = lambda data: mg.node_table.Node_
                                                 [[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)
 
+## Binary Search ##
+For binary search we can use a List_View class to represent a particular sublist without making a list copy.
+
+```python
+import memory_graph as mg
+import random
+random.seed(2)  # same random numbers each run
+
+class List_View:
+
+    def __init__(self, lst, begin, end):
+        self.lst = lst
+        self.begin = begin
+        self.end = end
+
+    def __getitem__(self, index):
+        return self.lst[index]
+
+    def get_mid(self):
+        return (self.begin + self.end) // 2
+
+def bin_search(view, value):
+    mid = view.get_mid()
+    if view.begin == mid:
+        mg.show(mg.stack())  # <--- show stack
+        return view.begin
+    if value < view[mid]:
+        return bin_search(List_View(view.lst, view.begin, mid), value)
+    else:
+        return bin_search(List_View(view.lst, mid, view.end), value)
+
+# create sorted list
+n = 15
+data = [random.randrange(1000) for _ in range(n)]
+data.sort()
+
+# search 'value'
+value = data[random.randrange(n)]
+index = bin_search(List_View(data, 0, len(data)), value)
+print(f'{index=} {data[index]=}')
+```
+![bin_search.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search.png)
+
+Arguably the visualization is then more clear when we show a List_View object as an actual sublist using a Node_linear node:
+
+```python
+mg.config.type_to_color[List_View] = 'hotpink'
+mg.config.type_to_node[List_View] = lambda data: mg.node_linear.Node_Linear(data,
+                                                    data.lst[data.begin:data.end])
+```
+![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
+
 
 # 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`.
@@ -823,7 +842,7 @@ class Base:
         while len(iter)>1:
             iter = iter[-1]
         return iter
-            
+
 class A(Base):
 
     def __init__(self, n):
@@ -869,6 +888,44 @@ mg.show(locals())
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/hidden_edges.png)
 
+# Extensions #
+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":
+
+```python
+import memory_graph as mg
+import numpy as np
+import memory_graph.extension_numpy
+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())
+```
+![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 "memory_graph.extension_pandas":
+
+```python
+import memory_graph as mg
+import pandas as pd
+import memory_graph.extension_pandas
+
+series = pd.Series( [i for i in range(20)] )
+dataframe1 = pd.DataFrame({  "calories": [420, 380, 390],
+                             "duration": [50, 40, 45] })
+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())
+```
+![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.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.stack_jupyter()` to get the whole call stack with these variables filtered out.