invocation-tree 0.0.28__tar.gz → 0.0.30__tar.gz

{invocation_tree-0.0.28/invocation_tree.egg-info → invocation_tree-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invocation_tree
-Version: 0.0.28
+Version: 0.0.30
 Summary: Generates an invocation tree of functions calls.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License: BSD 2-Clause License
@@ -57,7 +57,7 @@ Run a live demo in the 👉 [**Invocation Tree Web Debugger**](https://invocatio
 - shows the invocation tree (call tree) of a program **in real time**
 - helps to **understand recursion** and its depth-first nature
 
-# Chapters #
+# Topics #
 
 [Iteration and Recursion](#iteration-and-recursion)
 
@@ -92,7 +92,7 @@ ___
 
 # Iteration and Recursion #
 
-Repetion can be implemented with recursion and iteration. Lets first look at computing the factorial of 4.
+Repetion can be implemented with **iteration** and **recursion**. As an example we compute the factorial of 4.
 
 ``` python
 import math
@@ -102,7 +102,7 @@ print(math.factorial(4))
 ```
 24
 ```
-The result is `1 * 2 * 3 * 4 = 24`.
+The result is computed with repeated multiplication: `1 * 2 * 3 * 4 = 24`.
 
 To implement our own factorial function we can use iteration, a for-loop or while-loop, like so:
 
@@ -119,7 +119,7 @@ print(factorial(4))
 24
 ```
 
-Or we can use recursion, a function that calls itself. Then we also need a stop condition to prevent the function from calling itself indefinitely, like so:
+Or we can use recursion, a function that calls itself. Then we also need a **base case** as **stop condition** to prevent the function from calling itself indefinitely, like so:
 
 ```python
 def factorial(n):
@@ -287,7 +287,7 @@ CBC
 ![permutations](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_neighbor.gif)
 Or see it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_neighbor.py)
 
-With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require more complex program.
+With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require a more complex program.
 
 **exercise3:** Print all permutations with replacements of elements 'A', 'B', and 'C' of length 5 that are palindrome ('ABABA' is palindrome because if you read it backwards it's the same).
 
@@ -353,7 +353,7 @@ Adding temporarely debug print statements is in general a good technique to unde
 
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/print_paths_print_1.py&breakpoints=33&continues=1&timestep=0.2&play)
 
-Add temporary debug prints wherever behavior isn’t clear. Experiment with what/how you print to maximize clarity.
+Add temporary debug prints wherever behavior isn’t clear. Experiment with what and how you print to maximize clarity.
 
 **exercise4:** In this larger bidirectional graph, print all the paths of length 7 that connect node `a` to node `b` where going over the same node multiple times is allowed (`avjxbxb` is one such path, there are 114 such paths in total).
 
@@ -392,7 +392,7 @@ print(tree(permutations, 'LR', '', 3))
 <!-- ![permutations_return](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_return.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_return.py&timestep=0.5&play)
 
-However, sometimes it is easier to pass a list (or other mutable container type) as an extra argument in the recursion to collect the results in. This can also be faster as it avoids many list copies as a result of the '+=' list concatenations.
+However, sometimes it is easier to pass a list (or any other mutable container type) as an extra argument in the recursion to collect the results in. This is also faster because now just one list is used instead of each function call having to create its own `results` list.
 
 ```python
 import invocation_tree as ivt
@@ -432,7 +432,7 @@ edges =  [('a', 's'), ('i', 'z'), ('c', 'p'), ('d', 'p'), ('d', 'u'), ('b', 'e')
 
 # Quick Sort #
 
-Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists, so here we do need to use the return to get the result.
+Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists. Here we use the return value to get the sorted result.
 
 ```python
 import invocation_tree as ivt
@@ -459,9 +459,11 @@ unsorted values: [7, 4, 10, 11, 2, 6, 9, 1, 5, 3, 8, 12]
 <!-- ![quick_sort](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/quick_sort.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/quick_sort.py&timestep=0.5&play)
 
+**exercise6:** Rewrite this quick sort program so that we can pass in a list to collect the sorted result and we don't need to use a return value. This would make the program faster as it avoids having to use the `+` list concatenation operator that creates a new list each time we use it, whereas `+=` or `append()` only add to an existing list.
+
 # Jugs Puzzle #
 
-In the Jugs puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
+In the Jugs Puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
 
 - fill one jug until it is full
 - empty one jug until it is empty
@@ -515,12 +517,14 @@ Where:
 
 The breadth-first algorithm works and gives us the shortest path to a goal state, but to do that it uses a lot of memory to store each generation and all jugs states it has seen. Now we also want an algorithm that uses much less memory.
 
-**exercise6:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
+**exercise7:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
 
 - A solution may not have the same jugs state multiple times (this also avoids infinite loops).
 - It is not necessary to find the shortest path to a goal state (like breadth-first does).
 
-**solution exercise6:** First try it yourself, but we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
+If you want to use the Invocation Tree Web Debugger, you can look at these [configuration examples](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py) to keep the tree small and readable.
+
+**solution exercise7:** First try it yourself, we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
 
 A harder more fun instance of this puzzle is with jugs with capacity 3, 5, 34 and 107 liter and the goal of getting to a jug with 51 liters.
 
@@ -529,12 +533,14 @@ $ python jugs_breadth_first.py 51 3,5,34,107
 ```
 
 # Configuration #
+The Invocation Tree Web Debugger gives examples of the [most important configurations](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py).
 
 ## Hidding ##
 It can be useful to hide certian variables or functions to avoid unnecessary complexity. This can be done with:
 
 ```python
 tree = ivt.blocking()
+tree.hide_vars.add('functionname.variablename')  # or:
 tree.hide_vars.add('namespace.functionname.variablename')
 ```
 
@@ -542,6 +548,7 @@ Or hide certain function calls:
 
 ```python
 tree = ivt.blocking()
+tree.hide_calls.add('functionname')  # or:
 tree.hide_calls.add('namespace.functionname')
 ```
 
@@ -556,10 +563,10 @@ With the `re:` prefix we can use regular expresssions, for example:
 
 ```python
 tree = ivt.blocking()
-tree.ignore_calls.add('re:namespace\..*')
+tree.ignore_calls.add(r're:namespace\..*')
 ```
 
-to hide all function of `namespace`.
+ignores all function of `namespace`.
 
 ## Blocking ##
 

{invocation_tree-0.0.28 → invocation_tree-0.0.30}/README.md

@@ -12,7 +12,7 @@ Run a live demo in the 👉 [**Invocation Tree Web Debugger**](https://invocatio
 - shows the invocation tree (call tree) of a program **in real time**
 - helps to **understand recursion** and its depth-first nature
 
-# Chapters #
+# Topics #
 
 [Iteration and Recursion](#iteration-and-recursion)
 
@@ -47,7 +47,7 @@ ___
 
 # Iteration and Recursion #
 
-Repetion can be implemented with recursion and iteration. Lets first look at computing the factorial of 4.
+Repetion can be implemented with **iteration** and **recursion**. As an example we compute the factorial of 4.
 
 ``` python
 import math
@@ -57,7 +57,7 @@ print(math.factorial(4))
 ```
 24
 ```
-The result is `1 * 2 * 3 * 4 = 24`.
+The result is computed with repeated multiplication: `1 * 2 * 3 * 4 = 24`.
 
 To implement our own factorial function we can use iteration, a for-loop or while-loop, like so:
 
@@ -74,7 +74,7 @@ print(factorial(4))
 24
 ```
 
-Or we can use recursion, a function that calls itself. Then we also need a stop condition to prevent the function from calling itself indefinitely, like so:
+Or we can use recursion, a function that calls itself. Then we also need a **base case** as **stop condition** to prevent the function from calling itself indefinitely, like so:
 
 ```python
 def factorial(n):
@@ -242,7 +242,7 @@ CBC
 ![permutations](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_neighbor.gif)
 Or see it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_neighbor.py)
 
-With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require more complex program.
+With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require a more complex program.
 
 **exercise3:** Print all permutations with replacements of elements 'A', 'B', and 'C' of length 5 that are palindrome ('ABABA' is palindrome because if you read it backwards it's the same).
 
@@ -308,7 +308,7 @@ Adding temporarely debug print statements is in general a good technique to unde
 
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/print_paths_print_1.py&breakpoints=33&continues=1&timestep=0.2&play)
 
-Add temporary debug prints wherever behavior isn’t clear. Experiment with what/how you print to maximize clarity.
+Add temporary debug prints wherever behavior isn’t clear. Experiment with what and how you print to maximize clarity.
 
 **exercise4:** In this larger bidirectional graph, print all the paths of length 7 that connect node `a` to node `b` where going over the same node multiple times is allowed (`avjxbxb` is one such path, there are 114 such paths in total).
 
@@ -347,7 +347,7 @@ print(tree(permutations, 'LR', '', 3))
 <!-- ![permutations_return](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_return.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_return.py&timestep=0.5&play)
 
-However, sometimes it is easier to pass a list (or other mutable container type) as an extra argument in the recursion to collect the results in. This can also be faster as it avoids many list copies as a result of the '+=' list concatenations.
+However, sometimes it is easier to pass a list (or any other mutable container type) as an extra argument in the recursion to collect the results in. This is also faster because now just one list is used instead of each function call having to create its own `results` list.
 
 ```python
 import invocation_tree as ivt
@@ -387,7 +387,7 @@ edges =  [('a', 's'), ('i', 'z'), ('c', 'p'), ('d', 'p'), ('d', 'u'), ('b', 'e')
 
 # Quick Sort #
 
-Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists, so here we do need to use the return to get the result.
+Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists. Here we use the return value to get the sorted result.
 
 ```python
 import invocation_tree as ivt
@@ -414,9 +414,11 @@ unsorted values: [7, 4, 10, 11, 2, 6, 9, 1, 5, 3, 8, 12]
 <!-- ![quick_sort](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/quick_sort.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/quick_sort.py&timestep=0.5&play)
 
+**exercise6:** Rewrite this quick sort program so that we can pass in a list to collect the sorted result and we don't need to use a return value. This would make the program faster as it avoids having to use the `+` list concatenation operator that creates a new list each time we use it, whereas `+=` or `append()` only add to an existing list.
+
 # Jugs Puzzle #
 
-In the Jugs puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
+In the Jugs Puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
 
 - fill one jug until it is full
 - empty one jug until it is empty
@@ -470,12 +472,14 @@ Where:
 
 The breadth-first algorithm works and gives us the shortest path to a goal state, but to do that it uses a lot of memory to store each generation and all jugs states it has seen. Now we also want an algorithm that uses much less memory.
 
-**exercise6:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
+**exercise7:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
 
 - A solution may not have the same jugs state multiple times (this also avoids infinite loops).
 - It is not necessary to find the shortest path to a goal state (like breadth-first does).
 
-**solution exercise6:** First try it yourself, but we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
+If you want to use the Invocation Tree Web Debugger, you can look at these [configuration examples](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py) to keep the tree small and readable.
+
+**solution exercise7:** First try it yourself, we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
 
 A harder more fun instance of this puzzle is with jugs with capacity 3, 5, 34 and 107 liter and the goal of getting to a jug with 51 liters.
 
@@ -484,12 +488,14 @@ $ python jugs_breadth_first.py 51 3,5,34,107
 ```
 
 # Configuration #
+The Invocation Tree Web Debugger gives examples of the [most important configurations](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py).
 
 ## Hidding ##
 It can be useful to hide certian variables or functions to avoid unnecessary complexity. This can be done with:
 
 ```python
 tree = ivt.blocking()
+tree.hide_vars.add('functionname.variablename')  # or:
 tree.hide_vars.add('namespace.functionname.variablename')
 ```
 
@@ -497,6 +503,7 @@ Or hide certain function calls:
 
 ```python
 tree = ivt.blocking()
+tree.hide_calls.add('functionname')  # or:
 tree.hide_calls.add('namespace.functionname')
 ```
 
@@ -511,10 +518,10 @@ With the `re:` prefix we can use regular expresssions, for example:
 
 ```python
 tree = ivt.blocking()
-tree.ignore_calls.add('re:namespace\..*')
+tree.ignore_calls.add(r're:namespace\..*')
 ```
 
-to hide all function of `namespace`.
+ignores all function of `namespace`.
 
 ## Blocking ##
 

{invocation_tree-0.0.28 → invocation_tree-0.0.30}/invocation_tree/__init__.py

@@ -9,7 +9,7 @@ import difflib
 
 import invocation_tree.regex_set as regset
 
-__version__ = "0.0.28"
+__version__ = "0.0.30"
 __author__ = 'Bas Terwijn'
 
 def highlight_diff(str1, str2):
@@ -112,7 +112,7 @@ class Invocation_Tree:
         self.is_highlighted = False
         self.graph = None
         self.prev_global_tracer = None
-        self.hide_calls = {'Invocation_Tree.__exit__', 'Invocation_Tree.stop_trace'}
+        self.hide_calls = {'Invocation_Tree.__exit__', 'Invocation_Tree.stop_trace', '<genexpr>'}
         self.ignore_calls = set()
         self.ignoring_call = None
         self.regset_hide_vars = regset.Regex_Set(self.hide_vars)
@@ -293,17 +293,17 @@ class Invocation_Tree:
         if self.is_external(frame):
             return
         class_fun_name = get_class_function_name(frame)
-        if not self.regset_hide_calls.match(class_fun_name, self.hide_calls):
-            if event == 'return':
-                if class_fun_name == self.ignoring_call:
-                    self.ignoring_call = None
-                    return
-            if self.ignoring_call is not None:
+        if event == 'return':
+            if class_fun_name == self.ignoring_call:
+                self.ignoring_call = None
                 return
-            if event == 'call':
-                if self.regset_ignore_calls.match(class_fun_name, self.ignore_calls):
-                    self.ignoring_call = class_fun_name
-                    return
+        if self.ignoring_call is not None:
+            return
+        if event == 'call':
+            if self.regset_ignore_calls.match(class_fun_name, self.ignore_calls):
+                self.ignoring_call = class_fun_name
+                return
+        if not self.regset_hide_calls.match(class_fun_name, self.hide_calls):
             if event == 'call':
                 # update previous active node with its current frame now
                 if len(self.stack)>0:

{invocation_tree-0.0.28 → invocation_tree-0.0.30/invocation_tree.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invocation_tree
-Version: 0.0.28
+Version: 0.0.30
 Summary: Generates an invocation tree of functions calls.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License: BSD 2-Clause License
@@ -57,7 +57,7 @@ Run a live demo in the 👉 [**Invocation Tree Web Debugger**](https://invocatio
 - shows the invocation tree (call tree) of a program **in real time**
 - helps to **understand recursion** and its depth-first nature
 
-# Chapters #
+# Topics #
 
 [Iteration and Recursion](#iteration-and-recursion)
 
@@ -92,7 +92,7 @@ ___
 
 # Iteration and Recursion #
 
-Repetion can be implemented with recursion and iteration. Lets first look at computing the factorial of 4.
+Repetion can be implemented with **iteration** and **recursion**. As an example we compute the factorial of 4.
 
 ``` python
 import math
@@ -102,7 +102,7 @@ print(math.factorial(4))
 ```
 24
 ```
-The result is `1 * 2 * 3 * 4 = 24`.
+The result is computed with repeated multiplication: `1 * 2 * 3 * 4 = 24`.
 
 To implement our own factorial function we can use iteration, a for-loop or while-loop, like so:
 
@@ -119,7 +119,7 @@ print(factorial(4))
 24
 ```
 
-Or we can use recursion, a function that calls itself. Then we also need a stop condition to prevent the function from calling itself indefinitely, like so:
+Or we can use recursion, a function that calls itself. Then we also need a **base case** as **stop condition** to prevent the function from calling itself indefinitely, like so:
 
 ```python
 def factorial(n):
@@ -287,7 +287,7 @@ CBC
 ![permutations](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_neighbor.gif)
 Or see it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_neighbor.py)
 
-With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require more complex program.
+With recursion we can stop neighbors from being equal early, in contrast to iteration, where we would have had to filter out a permutation with equal neighbors after it was fully generated, which could be much slower and would require a more complex program.
 
 **exercise3:** Print all permutations with replacements of elements 'A', 'B', and 'C' of length 5 that are palindrome ('ABABA' is palindrome because if you read it backwards it's the same).
 
@@ -353,7 +353,7 @@ Adding temporarely debug print statements is in general a good technique to unde
 
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/print_paths_print_1.py&breakpoints=33&continues=1&timestep=0.2&play)
 
-Add temporary debug prints wherever behavior isn’t clear. Experiment with what/how you print to maximize clarity.
+Add temporary debug prints wherever behavior isn’t clear. Experiment with what and how you print to maximize clarity.
 
 **exercise4:** In this larger bidirectional graph, print all the paths of length 7 that connect node `a` to node `b` where going over the same node multiple times is allowed (`avjxbxb` is one such path, there are 114 such paths in total).
 
@@ -392,7 +392,7 @@ print(tree(permutations, 'LR', '', 3))
 <!-- ![permutations_return](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/permutations_return.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/permutations_return.py&timestep=0.5&play)
 
-However, sometimes it is easier to pass a list (or other mutable container type) as an extra argument in the recursion to collect the results in. This can also be faster as it avoids many list copies as a result of the '+=' list concatenations.
+However, sometimes it is easier to pass a list (or any other mutable container type) as an extra argument in the recursion to collect the results in. This is also faster because now just one list is used instead of each function call having to create its own `results` list.
 
 ```python
 import invocation_tree as ivt
@@ -432,7 +432,7 @@ edges =  [('a', 's'), ('i', 'z'), ('c', 'p'), ('d', 'p'), ('d', 'u'), ('b', 'e')
 
 # Quick Sort #
 
-Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists, so here we do need to use the return to get the result.
+Another nice example of divide-and-conquer is the recursive quicksort algorithm. It works by choosing a pivot element and dividing the list into elements smaller than the pivot and elements larger than the pivot. Each of these sublists is then quicksorted in the same way. When we get to the point a sublist has zero or one element, it is already sorted. When returning, these sorted sublists are then combined with the pivot to produce a larger sorted lists. Here we use the return value to get the sorted result.
 
 ```python
 import invocation_tree as ivt
@@ -459,9 +459,11 @@ unsorted values: [7, 4, 10, 11, 2, 6, 9, 1, 5, 3, 8, 12]
 <!-- ![quick_sort](https://raw.githubusercontent.com/bterwijn/invocation_tree/main/images/quick_sort.gif) -->
 See it in the [Invocation Tree Web Debugger](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/quick_sort.py&timestep=0.5&play)
 
+**exercise6:** Rewrite this quick sort program so that we can pass in a list to collect the sorted result and we don't need to use a return value. This would make the program faster as it avoids having to use the `+` list concatenation operator that creates a new list each time we use it, whereas `+=` or `append()` only add to an existing list.
+
 # Jugs Puzzle #
 
-In the Jugs puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
+In the Jugs Puzzle we have a set of jugs of various capacities. Our goal is to get a jug with a certain amount of liquid in it. In each step we can take one of these actions:
 
 - fill one jug until it is full
 - empty one jug until it is empty
@@ -515,12 +517,14 @@ Where:
 
 The breadth-first algorithm works and gives us the shortest path to a goal state, but to do that it uses a lot of memory to store each generation and all jugs states it has seen. Now we also want an algorithm that uses much less memory.
 
-**exercise6:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
+**exercise7:** Write a recursive solver for the Jugs Puzzle that uses less memory by searching for the solution in a depth-first manner.
 
 - A solution may not have the same jugs state multiple times (this also avoids infinite loops).
 - It is not necessary to find the shortest path to a goal state (like breadth-first does).
 
-**solution exercise6:** First try it yourself, but we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
+If you want to use the Invocation Tree Web Debugger, you can look at these [configuration examples](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py) to keep the tree small and readable.
+
+**solution exercise7:** First try it yourself, we give the [solution](https://www.invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/jugs_depth_first.py&breakpoints=136&continues=1) here for comparison.
 
 A harder more fun instance of this puzzle is with jugs with capacity 3, 5, 34 and 107 liter and the goal of getting to a jug with 51 liters.
 
@@ -529,12 +533,14 @@ $ python jugs_breadth_first.py 51 3,5,34,107
 ```
 
 # Configuration #
+The Invocation Tree Web Debugger gives examples of the [most important configurations](https://invocation-tree.com/#codeurl=https://raw.githubusercontent.com/bterwijn/invocation_tree/refs/heads/main/src/config.py).
 
 ## Hidding ##
 It can be useful to hide certian variables or functions to avoid unnecessary complexity. This can be done with:
 
 ```python
 tree = ivt.blocking()
+tree.hide_vars.add('functionname.variablename')  # or:
 tree.hide_vars.add('namespace.functionname.variablename')
 ```
 
@@ -542,6 +548,7 @@ Or hide certain function calls:
 
 ```python
 tree = ivt.blocking()
+tree.hide_calls.add('functionname')  # or:
 tree.hide_calls.add('namespace.functionname')
 ```
 
@@ -556,10 +563,10 @@ With the `re:` prefix we can use regular expresssions, for example:
 
 ```python
 tree = ivt.blocking()
-tree.ignore_calls.add('re:namespace\..*')
+tree.ignore_calls.add(r're:namespace\..*')
 ```
 
-to hide all function of `namespace`.
+ignores all function of `namespace`.
 
 ## Blocking ##
 

{invocation_tree-0.0.28 → invocation_tree-0.0.30}/invocation_tree.egg-info/SOURCES.txt

@@ -45,9 +45,9 @@ images/test.py
 images/tree.pdf
 images/tree_problem.gv
 images/vscode.png
+images/__pycache__/graph.cpython-313.pyc
 invocation_tree/__init__.py
 invocation_tree/regex_set.py
-invocation_tree/test_regex_fix.py
 invocation_tree.egg-info/PKG-INFO
 invocation_tree.egg-info/SOURCES.txt
 invocation_tree.egg-info/dependency_links.txt

{invocation_tree-0.0.28 → invocation_tree-0.0.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "invocation_tree"
-version = "0.0.28"
+version = "0.0.30"
 description = "Generates an invocation tree of functions calls."
 authors = [
     {name = "Bas Terwijn", email = "bterwijn@gmail.com"}

invocation_tree-0.0.28/invocation_tree/test_regex_fix.py

@@ -1,31 +0,0 @@
-import sys
-sys.path.append('/home/bterwijn/projects/invocation_tree/invocation_tree')
-from regex_set import Regex_Set
-
-# Test the fix
-class_fun_name = 'Jugs.copy'
-ignore_calls = {'J.*'}
-
-regset_ignore_calls = Regex_Set(ignore_calls)
-result = regset_ignore_calls.match(class_fun_name, ignore_calls)
-
-print(f"class_fun_name: '{class_fun_name}'")
-print(f"ignore_calls: {ignore_calls}")
-print(f"match result: {result}")
-
-# Let's also test the compiled pattern
-print(f"compiled pattern: {regset_ignore_calls.compiled_pattern.pattern}")
-
-# Test a few more cases
-test_cases = [
-    ('Jugs.copy', True),
-    ('J.test', True), 
-    ('Something.else', False),
-    ('AnotherClass.method', False)
-]
-
-print("\nTest cases:")
-for test_string, expected in test_cases:
-    result = regset_ignore_calls.match(test_string, ignore_calls)
-    status = "✓" if result == expected else "✗"
-    print(f"  {status} '{test_string}' -> {result} (expected {expected})")