memory-graph 0.3.85__tar.gz → 0.3.87__tar.gz

{memory_graph-0.3.85 → memory_graph-0.3.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.85
+Version: 0.3.87
 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
@@ -37,10 +37,10 @@ An example Binary Tree data structure:
 ![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
-# Videos #
-| [![Quick Intro](https://img.youtube.com/vi/23_bHcr7hqo/0.jpg)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [![Mutability](https://img.youtube.com/vi/pvIJgHCaXhU/0.jpg)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+# Videos
+| [![Quick Intro](https://www.dailymotion.com/thumbnail/video/xb2u52e)](https://dai.ly/xb2u52e) | [![Mutability](https://www.dailymotion.com/thumbnail/video/xb2u4eq)](https://dai.ly/xb2u4eq) |
 |:--:|:--:|
-| [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+| [Quick Intro (3:49)](https://dai.ly/xb2u52e) | [Mutability (17:29)](https://dai.ly/xb2u4eq) |
 
 # Memory Graph #
 For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
@@ -131,7 +131,7 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Sliding Puzzle Solver](#sliding-puzzle-solver)
 
-[Control Flow](#control-flow)
+[Flow Control](#flow-control)
 
 [Configuration](#configuration)
 
@@ -393,7 +393,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://dai.ly/xb2u4eq?start=891).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -512,7 +512,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 | [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.
+See the [Quick Intro (3:49)](https://dai.ly/xb2u52e?start=124) 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.
@@ -753,7 +753,7 @@ Visualization of different sorting algorithms in Memory Graph Web Debugger.
 # Bitwise Operators #
 In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
 
-- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=23&continues=1&play)
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
@@ -765,9 +765,9 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 ![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
 
-# Control Flow #
+# Flow Control #
 
-Some examples where we focus on the flow of control and access to state in Python code.
+Some examples where we focus more on the flow of execution in Python code.
 
 ## Different Methods ##
 
@@ -869,6 +869,47 @@ sms.send('001122334455', 'Update to Privacy Policy')
 ```
 Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/inheritance.py&breakpoints=35&continues=1&play).
 
+## Iterators ##
+
+What actually happens when Python executes a for-loop?
+
+```python
+for value in container:
+    print(value)
+```
+
+Behind the scenes, Python uses the [iterator protocol](https://docs.python.org/3/glossary.html#term-iterator):
+
+```python
+iterator = iter(container)
+while True: 
+    try: 
+        value = next(iterator)
+        print(value)
+    except StopIteration:
+        break
+```
+
+- `iter(container)`: creates an iterator.
+- `next(iterator)`: retrieves one value at a time.
+
+When there are no more values, the iterator raises StopIteration. The for-loop catches this exception automatically and ends the loop. For containers that support backward iteration, Python also provides:
+
+- `reversed(container)`: creates a backward iterator.
+
+We can support these operations in our own classes by implementing:
+
+```python
+def __iter__(self):
+def __next__(self):
+def __reversed__(self):
+```
+
+This provides a powerful abstraction: an algorithm can process values without needing to know how a container stores them internally. The same algorithm can therefore work with lists, sets, dictionaries, linked lists, trees, and many other containers.
+
+Run a Linked_List iterator example in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/list_iter.py&timestep=0.2&play).
+
+
 ## Decorator ##
 
 This example shows the flow of control when using a decorator. A decorator wraps a function and is active before and after the function is called.
@@ -1030,6 +1071,8 @@ create: 2
 use: 2
 ```
 
+Lazy evaluation is critical when you want to quickly start to process the first elements of a large stream of data, that may not even fit in your RAM entirely, or process just a section of an infite stream.
+
   </td></tr>
 </table>
 

{memory_graph-0.3.85 → memory_graph-0.3.87}/README.md

@@ -17,10 +17,10 @@ An example Binary Tree data structure:
 ![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
-# Videos #
-| [![Quick Intro](https://img.youtube.com/vi/23_bHcr7hqo/0.jpg)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [![Mutability](https://img.youtube.com/vi/pvIJgHCaXhU/0.jpg)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+# Videos
+| [![Quick Intro](https://www.dailymotion.com/thumbnail/video/xb2u52e)](https://dai.ly/xb2u52e) | [![Mutability](https://www.dailymotion.com/thumbnail/video/xb2u4eq)](https://dai.ly/xb2u4eq) |
 |:--:|:--:|
-| [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+| [Quick Intro (3:49)](https://dai.ly/xb2u52e) | [Mutability (17:29)](https://dai.ly/xb2u4eq) |
 
 # Memory Graph #
 For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
@@ -111,7 +111,7 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Sliding Puzzle Solver](#sliding-puzzle-solver)
 
-[Control Flow](#control-flow)
+[Flow Control](#flow-control)
 
 [Configuration](#configuration)
 
@@ -373,7 +373,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://dai.ly/xb2u4eq?start=891).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -492,7 +492,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 | [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.
+See the [Quick Intro (3:49)](https://dai.ly/xb2u52e?start=124) 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.
@@ -733,7 +733,7 @@ Visualization of different sorting algorithms in Memory Graph Web Debugger.
 # Bitwise Operators #
 In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
 
-- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=23&continues=1&play)
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
@@ -745,9 +745,9 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 ![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
 
-# Control Flow #
+# Flow Control #
 
-Some examples where we focus on the flow of control and access to state in Python code.
+Some examples where we focus more on the flow of execution in Python code.
 
 ## Different Methods ##
 
@@ -849,6 +849,47 @@ sms.send('001122334455', 'Update to Privacy Policy')
 ```
 Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/inheritance.py&breakpoints=35&continues=1&play).
 
+## Iterators ##
+
+What actually happens when Python executes a for-loop?
+
+```python
+for value in container:
+    print(value)
+```
+
+Behind the scenes, Python uses the [iterator protocol](https://docs.python.org/3/glossary.html#term-iterator):
+
+```python
+iterator = iter(container)
+while True: 
+    try: 
+        value = next(iterator)
+        print(value)
+    except StopIteration:
+        break
+```
+
+- `iter(container)`: creates an iterator.
+- `next(iterator)`: retrieves one value at a time.
+
+When there are no more values, the iterator raises StopIteration. The for-loop catches this exception automatically and ends the loop. For containers that support backward iteration, Python also provides:
+
+- `reversed(container)`: creates a backward iterator.
+
+We can support these operations in our own classes by implementing:
+
+```python
+def __iter__(self):
+def __next__(self):
+def __reversed__(self):
+```
+
+This provides a powerful abstraction: an algorithm can process values without needing to know how a container stores them internally. The same algorithm can therefore work with lists, sets, dictionaries, linked lists, trees, and many other containers.
+
+Run a Linked_List iterator example in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/list_iter.py&timestep=0.2&play).
+
+
 ## Decorator ##
 
 This example shows the flow of control when using a decorator. A decorator wraps a function and is active before and after the function is called.
@@ -1010,6 +1051,8 @@ create: 2
 use: 2
 ```
 
+Lazy evaluation is critical when you want to quickly start to process the first elements of a large stream of data, that may not even fit in your RAM entirely, or process just a section of an infite stream.
+
   </td></tr>
 </table>
 

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.85"
+__version__ = "0.3.87"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/extension_numpy.py

@@ -7,6 +7,7 @@ from memory_graph.node_linear import Node_Linear
 from memory_graph.node_table import Node_Table
 
 import memory_graph.config as config
+import memory_graph.config_default as config_default
 
 def ndarray_to_node(data, ndarray_data):
     dim = len(ndarray_data.shape)
@@ -34,8 +35,18 @@ def extend_numpy():
     config.type_to_node[np.matrix] = lambda data : Node_Table(data, np.asarray(data)) # convert to ndarray to avoid infinite recursion due to index issue
     config.type_to_node[np.ndarray] = lambda data : ndarray_to_node(data, data)
 
-    config.type_to_color[np.ndarray] = "hotpink1"
-    config.type_to_color[np.matrix] = "hotpink2"
+    config_default.type_to_color_light[np.ndarray] = "hotpink1"
+    config_default.type_to_color_light[np.matrix] = "hotpink2"
+
+    config_default.type_to_color_dark[np.ndarray] = "#652c47"
+    config_default.type_to_color_dark[np.matrix] = "#652c47"
+
+    if not config.color_mode_dark:
+        config.type_to_color[np.ndarray] = config_default.type_to_color_light[np.ndarray]
+        config.type_to_color[np.matrix] = config_default.type_to_color_light[np.matrix]
+    else:
+        config.type_to_color[np.ndarray] = config_default.type_to_color_dark[np.ndarray]
+        config.type_to_color[np.matrix] = config_default.type_to_color_dark[np.matrix]
 
 def unextend_numpy():
     import numpy as np

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/extension_pandas.py

@@ -7,6 +7,7 @@ from memory_graph.node_linear import Node_Linear
 from memory_graph.node_table import Node_Table
 
 import memory_graph.config as config
+import memory_graph.config_default as config_default
 
 def extend_pandas():
     import pandas as pd
@@ -23,8 +24,19 @@ def extend_pandas():
         Node_Linear(data, data.tolist())
     )
 
-    config.type_to_color[pd.DataFrame] = "olivedrab1"
-    config.type_to_color[pd.Series] = "olivedrab2"
+    config_default.type_to_color_light[pd.DataFrame] = "olivedrab1"
+    config_default.type_to_color_light[pd.Series] = "olivedrab2"
+
+    config_default.type_to_color_dark[pd.DataFrame] = "#3a4d13"
+    config_default.type_to_color_dark[pd.Series] = "#3a4d13"
+
+    if not config.color_mode_dark:
+        config.type_to_color[pd.DataFrame] = config_default.type_to_color_light[pd.DataFrame]
+        config.type_to_color[pd.Series] = config_default.type_to_color_light[pd.Series]
+    else:
+        config.type_to_color[pd.DataFrame] = config_default.type_to_color_dark[pd.DataFrame]
+        config.type_to_color[pd.Series] = config_default.type_to_color_dark[pd.Series]
+
 
 def unextend_pandas():
     import pandas as pd

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/extension_torch.py

@@ -5,12 +5,21 @@
 """ Extension to add the memory graph configuration for Pandas types. """
 import memory_graph.extension_numpy as ext_np
 import memory_graph.config as config
+import memory_graph.config_default as config_default
 
 def extend_torch():
     import torch
 
     config.type_to_node[torch.Tensor] = lambda data : ext_np.ndarray_to_node(data, data.numpy())
-    config.type_to_color[torch.Tensor] = "darkolivegreen1"
+
+    config_default.type_to_color_light[torch.Tensor] = "darkolivegreen1"
+
+    config_default.type_to_color_dark[torch.Tensor] = "darkolivegreen"
+
+    if not config.color_mode_dark:
+        config.type_to_color[torch.Tensor] = config_default.type_to_color_light[torch.Tensor]
+    else:
+        config.type_to_color[torch.Tensor] = config_default.type_to_color_dark[torch.Tensor]
 
 def unextend_torch():
     import torch

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/memory_to_nodes.py

@@ -208,6 +208,8 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
         """ Adds a subgraph to 'graphviz_graph' for 'nodes_to_subgraph'. """
         new_node_names = [node.get_name() for node in nodes_to_subgraph]
         if len(new_node_names) > 1:
+            if config.horizontal:
+                new_node_names.reverse() # reverse order for horizontal layout
             graphviz_graph.body.append('subgraph { rank=same; '+ ' -> '.join(new_node_names) + '[weight='+str(config.graph_stability)+', style=invis]; }\n')
 
     def add_to_graphviz_graph(graphviz_graph, nodes, node, slices, id_to_slices):
@@ -223,7 +225,6 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
         else:
             graphviz_graph.node(node.get_name(),
                                 html_table.to_string(border, color, config.foreground_color))
-            # ------------ edges
         for parent,child,dashed in edges:
             graphviz_graph.edge(parent, child+':table', style='dashed' if dashed else 'solid')
 
@@ -239,8 +240,7 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
             if node_id in id_to_slices:
                 slices = id_to_slices[node_id]
                 if not slices is None:
-                    slices_iter = slices.reverse_iter() if config.horizontal else iter(slices)
-                    for index in slices_iter:
+                    for index in slices:
                         child_id = id(children[index])
                         build_graph_depth_first(graphviz_graph, nodes, child_id, id_to_slices, nodes_at_depth, subgraphed_nodes, depth+1)
             if not node.is_hidden_node():

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph/slices_iterator.py

@@ -30,12 +30,6 @@ class Slices_Iterator1D(Slices_Iterator):
             for i in range(slices[si][0], slices[si][1]):
                 yield i
 
-    def reverse_generate(self):
-        slices = self.slices.get_slices()
-        for si in range(len(slices)-1, -1, -1):
-            for i in range(slices[si][1]-1, slices[si][0]-1, -1):
-                yield i
-
     def __next__(self):
         return next(self.gen)
     
@@ -57,14 +51,5 @@ class Slices_Iterator2D(Slices_Iterator):
                     for col_i in range(col_slice[0], col_slice[1]):
                         yield (row_i, col_i)
 
-    def reverse_generate(self):
-        row_slices = self.slices.get_row_slices().get_slices()
-        col_slices = self.slices.get_col_slices().get_slices()
-        for row_slice in reversed(row_slices):
-            for row_i in range(row_slice[1]-1, row_slice[0]-1, -1):
-                for col_slice in reversed(col_slices):
-                    for col_i in range(col_slice[1]-1, col_slice[0]-1, -1):
-                        yield (row_i, col_i)
-
     def __next__(self):
         return next(self.gen)

{memory_graph-0.3.85 → memory_graph-0.3.87}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.85
+Version: 0.3.87
 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
@@ -37,10 +37,10 @@ An example Binary Tree data structure:
 ![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bin_tree.py&timestep=0.2&play).
 
-# Videos #
-| [![Quick Intro](https://img.youtube.com/vi/23_bHcr7hqo/0.jpg)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [![Mutability](https://img.youtube.com/vi/pvIJgHCaXhU/0.jpg)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+# Videos
+| [![Quick Intro](https://www.dailymotion.com/thumbnail/video/xb2u52e)](https://dai.ly/xb2u52e) | [![Mutability](https://www.dailymotion.com/thumbnail/video/xb2u4eq)](https://dai.ly/xb2u4eq) |
 |:--:|:--:|
-| [Quick Intro (3:49)](https://www.youtube.com/watch?v=23_bHcr7hqo) | [Mutability (17:29)](https://www.youtube.com/watch?v=pvIJgHCaXhU) |
+| [Quick Intro (3:49)](https://dai.ly/xb2u52e) | [Mutability (17:29)](https://dai.ly/xb2u4eq) |
 
 # Memory Graph #
 For program understanding and debugging, the [memory_graph](https://github.com/bterwijn/memory_graph) package can visualize your data, supporting many different data types, including but not limited to:
@@ -131,7 +131,7 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Sliding Puzzle Solver](#sliding-puzzle-solver)
 
-[Control Flow](#control-flow)
+[Flow Control](#flow-control)
 
 [Configuration](#configuration)
 
@@ -393,7 +393,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 # Data Model Exercises #
 
-Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://www.youtube.com/watch?v=pvIJgHCaXhU&t=891s).
+Now is a good time to practice with these Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls. Also see the programming exercises at [the end of the Mutability video](https://dai.ly/xb2u4eq?start=891).
 
 # Block #
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -512,7 +512,7 @@ The ```mg.stack()``` doesn't work well in **watch** context in most debuggers be
 | [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.
+See the [Quick Intro (3:49)](https://dai.ly/xb2u52e?start=124) 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.
@@ -753,7 +753,7 @@ Visualization of different sorting algorithms in Memory Graph Web Debugger.
 # Bitwise Operators #
 In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
 
-- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=23&continues=1&play)
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
@@ -765,9 +765,9 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 ![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
 
-# Control Flow #
+# Flow Control #
 
-Some examples where we focus on the flow of control and access to state in Python code.
+Some examples where we focus more on the flow of execution in Python code.
 
 ## Different Methods ##
 
@@ -869,6 +869,47 @@ sms.send('001122334455', 'Update to Privacy Policy')
 ```
 Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/inheritance.py&breakpoints=35&continues=1&play).
 
+## Iterators ##
+
+What actually happens when Python executes a for-loop?
+
+```python
+for value in container:
+    print(value)
+```
+
+Behind the scenes, Python uses the [iterator protocol](https://docs.python.org/3/glossary.html#term-iterator):
+
+```python
+iterator = iter(container)
+while True: 
+    try: 
+        value = next(iterator)
+        print(value)
+    except StopIteration:
+        break
+```
+
+- `iter(container)`: creates an iterator.
+- `next(iterator)`: retrieves one value at a time.
+
+When there are no more values, the iterator raises StopIteration. The for-loop catches this exception automatically and ends the loop. For containers that support backward iteration, Python also provides:
+
+- `reversed(container)`: creates a backward iterator.
+
+We can support these operations in our own classes by implementing:
+
+```python
+def __iter__(self):
+def __next__(self):
+def __reversed__(self):
+```
+
+This provides a powerful abstraction: an algorithm can process values without needing to know how a container stores them internally. The same algorithm can therefore work with lists, sets, dictionaries, linked lists, trees, and many other containers.
+
+Run a Linked_List iterator example in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/list_iter.py&timestep=0.2&play).
+
+
 ## Decorator ##
 
 This example shows the flow of control when using a decorator. A decorator wraps a function and is active before and after the function is called.
@@ -1030,6 +1071,8 @@ create: 2
 use: 2
 ```
 
+Lazy evaluation is critical when you want to quickly start to process the first elements of a large stream of data, that may not even fit in your RAM entirely, or process just a section of an infite stream.
+
   </td></tr>
 </table>
 

{memory_graph-0.3.85 → memory_graph-0.3.87}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.85"
+version = "0.3.87"
 description = "Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy."
 authors = [
     {name = "Bas Terwijn", email = "bterwijn@gmail.com"}