memory-graph 0.2.2__tar.gz → 0.2.4__tar.gz

{memory_graph-0.2.2 → memory_graph-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory_graph
-Version: 0.2.2
+Version: 0.2.4
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -67,7 +67,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 Packge #
+# Memory Graph #
 The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types.
 
 ```python
@@ -222,24 +222,22 @@ memory_graph.show(locals(), block=True)
 
 So much so that function `d()` is available as alias for this for easier debugging. Additionally it can optionally log the data by printing them. For example:
 ```python
-from memory_graph import d
+import memory_graph
 
-my_squares = []
-my_squares_ref = my_squares
-for i in range(5):
-    my_squares.append(i**2)
-    d(log=True)
-my_squares_copy = my_squares.copy()
-d(log=True)
+squares = []
+squares_collector = []
+for i in range(1,6):
+    squares.append(i**2)
+    squares_collector.append(squares.copy())
+    memory_graph.d(log=True)
 ```
 which after pressing ENTER a number of times results in:
 
-![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.png)
+![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.gif)
 ```
-my_squares: [0, 1, 4, 9, 16]
-my_squares_ref: [0, 1, 4, 9, 16]
-i: 4
-my_squares_copy: [0, 1, 4, 9, 16]
+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
 ```
 
 Function `d()` has these default arguments:
@@ -287,7 +285,7 @@ print(f"a:{a} b:{b} c:{c}")
 
 As `a` is of immutable type 'int' and as we call the function with a copy of `c`, only `b` is shared so only `b` is changed in the calling stack frame as reflected in the printed output:
 ```
-a:0 b:[4, 3, 2, 1] c:[4, 3, 2]
+a:10 b:[4, 3, 2, 1] c:[4, 3, 2]
 ```
 
 ### Recursion ###
@@ -306,12 +304,8 @@ def factorial(n):
 
 factorial(3)
 ```
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial1.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial2.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial3.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial4.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial5.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial6.png" /></div>
+![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
+
 and the final result is: 1 x 2 x 3 = 6
 
 ### Call Stack in Watchpoint ###
@@ -339,7 +333,7 @@ Module memory_graph can be very useful in a course about datastructures, some ex
 
 ### Doubly Linked List ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -365,19 +359,19 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
+        memory_graph.d() # <--- draw graph
 
 linked_list = LinkedList()
 n = 100
 for i in range(n):
     new_value = random.randrange(n)
     linked_list.add_front(new_value)
-    d() # <--- draw linked list
 ```
 ![linked_list.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/linked_list.png)
 
 ### Binary Tree ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -394,7 +388,6 @@ class BinTree:
         self.root = None
 
     def add_recursive(self, new_value, node):
-        d() # <--- draw tree when adding recursively
         if new_value < node.value:
             if node.smaller is None:
                 node.smaller = Node(new_value)
@@ -405,6 +398,7 @@ class BinTree:
                 node.larger = Node(new_value)
             else:
                 self.add_recursive(new_value, node.larger)
+        memory_graph.d() # <--- draw graph
 
     def add(self, value):
         if self.root is None:
@@ -417,27 +411,27 @@ n = 100
 for i in range(n):
     new_value = random.randrange(100)
     tree.add(new_value)
-    d()  # <--- draw tree after adding
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
 
 ### Hash Set ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
 class HashSet:
 
-    def __init__(self, capacity=20):
+    def __init__(self, capacity=15):
         self.buckets = [None] * capacity
 
     def add(self, value):
         index = hash(value) % len(self.buckets)
         if self.buckets[index] is None:
-            self.buckets[index] = [value]
-        else:
-            self.buckets[index].append(value)
+            self.buckets[index] = []
+        bucket = self.buckets[index]
+        bucket.append(value)
+        memory_graph.d() # <--- draw graph
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -455,7 +449,6 @@ n = 100
 for i in range(n):
     new_value = random.randrange(n)
     hash_set.add(new_value)
-    d() # <--- draw hash set
 ```
 ![hash_set.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/hash_set.png)
 
@@ -512,14 +505,15 @@ Different extensions are available for types from other Python packages.
 Numpy types `arrray` and `matrix` and `ndarray` can be graphed with the "memory_graph.extension_numpy" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 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)
-d()
+memory_graph.d()
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_numpy.png)
 
@@ -527,7 +521,7 @@ d()
 Pandas types `Series` and `DataFrame` can be graphed with the "memory_graph.extension_pandas" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 import pandas as pd
 import memory_graph.extension_pandas
 
@@ -538,7 +532,7 @@ 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
-d()
+memory_graph.d()
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 

{memory_graph-0.2.2 → memory_graph-0.2.4}/README.md

@@ -48,7 +48,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 Packge #
+# Memory Graph #
 The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types.
 
 ```python
@@ -203,24 +203,22 @@ memory_graph.show(locals(), block=True)
 
 So much so that function `d()` is available as alias for this for easier debugging. Additionally it can optionally log the data by printing them. For example:
 ```python
-from memory_graph import d
+import memory_graph
 
-my_squares = []
-my_squares_ref = my_squares
-for i in range(5):
-    my_squares.append(i**2)
-    d(log=True)
-my_squares_copy = my_squares.copy()
-d(log=True)
+squares = []
+squares_collector = []
+for i in range(1,6):
+    squares.append(i**2)
+    squares_collector.append(squares.copy())
+    memory_graph.d(log=True)
 ```
 which after pressing ENTER a number of times results in:
 
-![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.png)
+![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.gif)
 ```
-my_squares: [0, 1, 4, 9, 16]
-my_squares_ref: [0, 1, 4, 9, 16]
-i: 4
-my_squares_copy: [0, 1, 4, 9, 16]
+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
 ```
 
 Function `d()` has these default arguments:
@@ -268,7 +266,7 @@ print(f"a:{a} b:{b} c:{c}")
 
 As `a` is of immutable type 'int' and as we call the function with a copy of `c`, only `b` is shared so only `b` is changed in the calling stack frame as reflected in the printed output:
 ```
-a:0 b:[4, 3, 2, 1] c:[4, 3, 2]
+a:10 b:[4, 3, 2, 1] c:[4, 3, 2]
 ```
 
 ### Recursion ###
@@ -287,12 +285,8 @@ def factorial(n):
 
 factorial(3)
 ```
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial1.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial2.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial3.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial4.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial5.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial6.png" /></div>
+![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
+
 and the final result is: 1 x 2 x 3 = 6
 
 ### Call Stack in Watchpoint ###
@@ -320,7 +314,7 @@ Module memory_graph can be very useful in a course about datastructures, some ex
 
 ### Doubly Linked List ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -346,19 +340,19 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
+        memory_graph.d() # <--- draw graph
 
 linked_list = LinkedList()
 n = 100
 for i in range(n):
     new_value = random.randrange(n)
     linked_list.add_front(new_value)
-    d() # <--- draw linked list
 ```
 ![linked_list.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/linked_list.png)
 
 ### Binary Tree ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -375,7 +369,6 @@ class BinTree:
         self.root = None
 
     def add_recursive(self, new_value, node):
-        d() # <--- draw tree when adding recursively
         if new_value < node.value:
             if node.smaller is None:
                 node.smaller = Node(new_value)
@@ -386,6 +379,7 @@ class BinTree:
                 node.larger = Node(new_value)
             else:
                 self.add_recursive(new_value, node.larger)
+        memory_graph.d() # <--- draw graph
 
     def add(self, value):
         if self.root is None:
@@ -398,27 +392,27 @@ n = 100
 for i in range(n):
     new_value = random.randrange(100)
     tree.add(new_value)
-    d()  # <--- draw tree after adding
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
 
 ### Hash Set ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
 class HashSet:
 
-    def __init__(self, capacity=20):
+    def __init__(self, capacity=15):
         self.buckets = [None] * capacity
 
     def add(self, value):
         index = hash(value) % len(self.buckets)
         if self.buckets[index] is None:
-            self.buckets[index] = [value]
-        else:
-            self.buckets[index].append(value)
+            self.buckets[index] = []
+        bucket = self.buckets[index]
+        bucket.append(value)
+        memory_graph.d() # <--- draw graph
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -436,7 +430,6 @@ n = 100
 for i in range(n):
     new_value = random.randrange(n)
     hash_set.add(new_value)
-    d() # <--- draw hash set
 ```
 ![hash_set.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/hash_set.png)
 
@@ -493,14 +486,15 @@ Different extensions are available for types from other Python packages.
 Numpy types `arrray` and `matrix` and `ndarray` can be graphed with the "memory_graph.extension_numpy" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 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)
-d()
+memory_graph.d()
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_numpy.png)
 
@@ -508,7 +502,7 @@ d()
 Pandas types `Series` and `DataFrame` can be graphed with the "memory_graph.extension_pandas" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 import pandas as pd
 import memory_graph.extension_pandas
 
@@ -519,7 +513,7 @@ 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
-d()
+memory_graph.d()
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/Node.py

@@ -15,11 +15,10 @@ class Node:
         children (list): The children of the node.
         size (string): The size of the node to be shown in the graph.
     """
-    def __init__(self, data, children=None, size=None):
+    def __init__(self, data, children=None):
         self.node_id = Node.node_id
         Node.node_id += 1
         self.data = data
-        self.size = size
         self.parent = None
         self.children = children
 
@@ -34,6 +33,18 @@ class Node:
         Return the original data represented by the node.
         """
         return self.data
+    
+    def get_type(self):
+        """
+        Return the type of the data represented by the node.
+        """
+        return type(self.data)
+    
+    def get_type_name(self):
+        """
+        Return the name of the type of the data represented by the node.
+        """
+        return utils.get_type_name(self.data)
 
     def set_parent(self, parent):
         """
@@ -47,12 +58,6 @@ class Node:
         """    
         return self.parent
 
-    def get_size(self):
-        """
-        Return the size of the node to be shown in the graph.
-        """
-        return self.size
-
     def get_children(self):
         """
         Return the children of the node. Initially the children are raw data, but 
@@ -78,17 +83,6 @@ class Node:
             self.fill_html_table(html_table)
         return html_table
     
-    def get_label(self):
-        """
-        Return a label for the node to be shown in the graph next to the HTML table, the size 
-        is included in the label if available.
-        """
-        label = utils.get_type_name(self.data)
-        size = self.get_size()
-        if not size is None:
-            label +=f' ({size})'
-        return label
-    
     # -------------------- Node interface, overriden by subclasses --------------------
 
     def do_backtrack_callback(self):
@@ -109,3 +103,9 @@ class Node:
         Fill the HTML_Table object with each child of the node.
         """
         pass
+
+    def get_label(self):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        return self.get_type_name()

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/Node_Key_Value.py

@@ -37,9 +37,10 @@ class Node_Key_Value(Node):
         """
         #print('Node_Key_Value children:', children)
         hidden_children = [ Node_Hidden(i,list(i)) for i in children ]
+        self.size = len(hidden_children)
         slicer = config_helpers.get_slicer_1d(self, data)
         sliced_children = slicer.slice(hidden_children)
-        super().__init__(data, sliced_children, sliced_children.get_original_length())
+        super().__init__(data, sliced_children)
         
     def transform(self, fun):
         """
@@ -91,3 +92,12 @@ class Node_Key_Value(Node):
             if value is not None:
                 key_value = value.get_children() # add the key-value pair of Hidden_Node, not the tuple
                 html_table.add_entry(self, key_value[1])
+
+    def get_label(self):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        if self.get_children().has_all_data():
+            return f'{self.get_type_name()}'
+        return f'{self.get_type_name()} {self.size}'
+    

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/Node_Linear.py

@@ -16,7 +16,7 @@ class Node_Linear(Node):
         """
         slicer = config_helpers.get_slicer_1d(self, data)
         sliced_children = slicer.slice(children)
-        super().__init__(data, sliced_children, sliced_children.get_original_length())
+        super().__init__(data, sliced_children)
 
     def transform(self, fun):
         """

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/Node_Table.py

@@ -38,7 +38,7 @@ class Node_Table(Node):
 
         self.row_names = row_names
         self.column_names = column_names
-        super().__init__(data, sliced_children, f'{self.data_height}⨯{self.data_width}')
+        super().__init__(data, sliced_children)
 
     def transform(self, fun):
         """
@@ -82,3 +82,9 @@ class Node_Table(Node):
                         html_table.add_entry(self, value)
                 html_table.add_new_line()
 
+    def get_label(self):
+        """
+        Return a label for the node to be shown in the graph next to the HTML table.
+        """
+        return f'{self.get_type_name()} {self.data_height}⨯{self.data_width}'
+    

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/Sliced.py

@@ -108,4 +108,7 @@ class Sliced:
     def last_slice_empty(self):
         """ Return True if the last slice of the Sliced object is empty. """
         return len(self.slices) > 0 and len(self.slices[-1].data) == 0
-    
+    
+    def has_all_data(self):
+        """ Return True if the Sliced object has all the data. """
+        return len(self.slices) == 1 and len(self.slices[0].data) == self.original_length

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph/__init__.py

@@ -6,7 +6,7 @@ import memory_graph.utils as utils
 import inspect
 import sys
 
-__version__ = "0.2.02"
+__version__ = "0.2.04"
 __author__ = 'Bas Terwijn'
 
 log_file=sys.stdout

{memory_graph-0.2.2 → memory_graph-0.2.4}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memory-graph
-Version: 0.2.2
+Version: 0.2.4
 Summary: Draws a graph of your data to analyze its structure.
 Home-page: https://github.com/bterwijn/memory_graph
 Author: Bas Terwijn
@@ -67,7 +67,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 Packge #
+# Memory Graph #
 The [memory_graph](https://pypi.org/project/memory-graph/) package can graph many different data types.
 
 ```python
@@ -222,24 +222,22 @@ memory_graph.show(locals(), block=True)
 
 So much so that function `d()` is available as alias for this for easier debugging. Additionally it can optionally log the data by printing them. For example:
 ```python
-from memory_graph import d
+import memory_graph
 
-my_squares = []
-my_squares_ref = my_squares
-for i in range(5):
-    my_squares.append(i**2)
-    d(log=True)
-my_squares_copy = my_squares.copy()
-d(log=True)
+squares = []
+squares_collector = []
+for i in range(1,6):
+    squares.append(i**2)
+    squares_collector.append(squares.copy())
+    memory_graph.d(log=True)
 ```
 which after pressing ENTER a number of times results in:
 
-![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.png)
+![debugging.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/debugging.gif)
 ```
-my_squares: [0, 1, 4, 9, 16]
-my_squares_ref: [0, 1, 4, 9, 16]
-i: 4
-my_squares_copy: [0, 1, 4, 9, 16]
+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
 ```
 
 Function `d()` has these default arguments:
@@ -287,7 +285,7 @@ print(f"a:{a} b:{b} c:{c}")
 
 As `a` is of immutable type 'int' and as we call the function with a copy of `c`, only `b` is shared so only `b` is changed in the calling stack frame as reflected in the printed output:
 ```
-a:0 b:[4, 3, 2, 1] c:[4, 3, 2]
+a:10 b:[4, 3, 2, 1] c:[4, 3, 2]
 ```
 
 ### Recursion ###
@@ -306,12 +304,8 @@ def factorial(n):
 
 factorial(3)
 ```
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial1.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial2.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial3.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial4.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial5.png" /></div>
-  <div><img src="https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial6.png" /></div>
+![factorial.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/factorial.gif)
+
 and the final result is: 1 x 2 x 3 = 6
 
 ### Call Stack in Watchpoint ###
@@ -339,7 +333,7 @@ Module memory_graph can be very useful in a course about datastructures, some ex
 
 ### Doubly Linked List ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -365,19 +359,19 @@ class LinkedList:
             new_node.next = self.head
             self.head.prev = new_node
             self.head = new_node
+        memory_graph.d() # <--- draw graph
 
 linked_list = LinkedList()
 n = 100
 for i in range(n):
     new_value = random.randrange(n)
     linked_list.add_front(new_value)
-    d() # <--- draw linked list
 ```
 ![linked_list.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/linked_list.png)
 
 ### Binary Tree ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
@@ -394,7 +388,6 @@ class BinTree:
         self.root = None
 
     def add_recursive(self, new_value, node):
-        d() # <--- draw tree when adding recursively
         if new_value < node.value:
             if node.smaller is None:
                 node.smaller = Node(new_value)
@@ -405,6 +398,7 @@ class BinTree:
                 node.larger = Node(new_value)
             else:
                 self.add_recursive(new_value, node.larger)
+        memory_graph.d() # <--- draw graph
 
     def add(self, value):
         if self.root is None:
@@ -417,27 +411,27 @@ n = 100
 for i in range(n):
     new_value = random.randrange(100)
     tree.add(new_value)
-    d()  # <--- draw tree after adding
 ```
 ![bin_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree.png)
 
 ### Hash Set ###
 ```python
-from memory_graph import d
+import memory_graph
 import random
 random.seed(0) # use same random numbers each run
 
 class HashSet:
 
-    def __init__(self, capacity=20):
+    def __init__(self, capacity=15):
         self.buckets = [None] * capacity
 
     def add(self, value):
         index = hash(value) % len(self.buckets)
         if self.buckets[index] is None:
-            self.buckets[index] = [value]
-        else:
-            self.buckets[index].append(value)
+            self.buckets[index] = []
+        bucket = self.buckets[index]
+        bucket.append(value)
+        memory_graph.d() # <--- draw graph
 
     def contains(self, value):
         index = hash(value) % len(self.buckets)
@@ -455,7 +449,6 @@ n = 100
 for i in range(n):
     new_value = random.randrange(n)
     hash_set.add(new_value)
-    d() # <--- draw hash set
 ```
 ![hash_set.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/hash_set.png)
 
@@ -512,14 +505,15 @@ Different extensions are available for types from other Python packages.
 Numpy types `arrray` and `matrix` and `ndarray` can be graphed with the "memory_graph.extension_numpy" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 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)
-d()
+memory_graph.d()
 ```
 ![extension_numpy.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_numpy.png)
 
@@ -527,7 +521,7 @@ d()
 Pandas types `Series` and `DataFrame` can be graphed with the "memory_graph.extension_pandas" extension:
 
 ```python
-from memory_graph import d
+import memory_graph
 import pandas as pd
 import memory_graph.extension_pandas
 
@@ -538,7 +532,7 @@ 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
-d()
+memory_graph.d()
 ```
 ![extension_pandas.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/extension_pandas.png)
 

{memory_graph-0.2.2 → memory_graph-0.2.4}/setup.py

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