memory-graph 0.3.86__tar.gz → 0.3.88__tar.gz

{memory_graph-0.3.86 → memory_graph-0.3.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.86
+Version: 0.3.88
 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.
@@ -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,17 +869,58 @@ 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.
 
 ```python
-def log_call(function):
+def log_call(function):  # decorator example
     def wrapper(*args, **kwargs):
-        print(f"Calling {function.__name__} with: {args}, {kwargs}")
-        returned = function(*args, **kwargs)
-        print(f"Finished {function.__name__} with return value: {returned}")
-        return returned
+        print(f"log: '{function.__name__}' called with: {args}, {kwargs}")
+        return_value = function(*args, **kwargs)
+        print(f"log: '{function.__name__}' returned with: {return_value}")
+        return return_value
     return wrapper
 
 @log_call
@@ -891,11 +932,11 @@ def calculate_total(price, quantity, rounding=False):
 def send_email(receiver, message, sender="support@company.com"):
     print(f"Sending email to:{receiver} from:{sender}, {message}")
 
-total = calculate_total(7.5, 3, rounding=True)
+total = calculate_total(2.4, 3, rounding=True)
 print(total)
 send_email("alice@example.com", "Your order is ready")
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=18&continues=1&play).
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=19&continues=1&play).
 
 ## Exception Handling ##
 
@@ -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.86 → memory_graph-0.3.88}/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.
@@ -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,17 +849,58 @@ 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.
 
 ```python
-def log_call(function):
+def log_call(function):  # decorator example
     def wrapper(*args, **kwargs):
-        print(f"Calling {function.__name__} with: {args}, {kwargs}")
-        returned = function(*args, **kwargs)
-        print(f"Finished {function.__name__} with return value: {returned}")
-        return returned
+        print(f"log: '{function.__name__}' called with: {args}, {kwargs}")
+        return_value = function(*args, **kwargs)
+        print(f"log: '{function.__name__}' returned with: {return_value}")
+        return return_value
     return wrapper
 
 @log_call
@@ -871,11 +912,11 @@ def calculate_total(price, quantity, rounding=False):
 def send_email(receiver, message, sender="support@company.com"):
     print(f"Sending email to:{receiver} from:{sender}, {message}")
 
-total = calculate_total(7.5, 3, rounding=True)
+total = calculate_total(2.4, 3, rounding=True)
 print(total)
 send_email("alice@example.com", "Your order is ready")
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=18&continues=1&play).
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=19&continues=1&play).
 
 ## Exception Handling ##
 
@@ -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.86 → memory_graph-0.3.88}/memory_graph/__init__.py

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

{memory_graph-0.3.86 → memory_graph-0.3.88}/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.88/memory_graph/extension_pandas.py

@@ -0,0 +1,142 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""Extension to add memory graph configuration for public Pandas values."""
+import reprlib
+
+from memory_graph.node_leaf import Node_Leaf
+from memory_graph.node_table import Node_Table
+
+import memory_graph.config as config
+import memory_graph.config_default as config_default
+
+
+def _display_value(value):
+    """Keep object references, but display Pandas scalar values without internals."""
+    import pandas as pd
+
+    if value is pd.NA or value is pd.NaT:
+        return str(value)
+    if isinstance(value, (pd.Timestamp, pd.Timedelta, pd.Period, pd.Interval)):
+        return str(value)
+    return value
+
+
+def _column_name(name, default="value"):
+    return default if name is None else str(name)
+
+
+def _dataframe_to_node(data):
+    # Unlike .values, itertuples does not coerce all numeric columns to one dtype.
+    return Node_Table(
+        data,
+        [[_display_value(value) for value in row]
+         for row in data.itertuples(index=False, name=None)],
+        col_names=[str(name) for name in data.columns],
+        row_names=[str(name) for name in data.index],
+    )
+
+
+def _series_to_node(data):
+    return Node_Table(
+        data,
+        [[_display_value(value)] for value in data.tolist()],
+        col_names=[_column_name(data.name)],
+        row_names=[str(name) for name in data.index],
+    )
+
+
+def _index_to_node(data):
+    # Also handles RangeIndex, DatetimeIndex, TimedeltaIndex and PeriodIndex
+    # through config's base-class lookup.
+    return Node_Table(
+        data,
+        [[_display_value(value)] for value in data.tolist()],
+        col_names=[_column_name(data.name)],
+    )
+
+
+def _multiindex_to_node(data):
+    # Use the actual row labels, not .levels (which includes unused labels).
+    return Node_Table(
+        data,
+        [[_display_value(value) for value in row] for row in data.tolist()],
+        col_names=[_column_name(name, f"level_{i}")
+                   for i, name in enumerate(data.names)],
+    )
+
+
+class _Categorical_Table(Node_Table):
+    """Show values as a table, with category order as compact metadata."""
+
+    def get_label(self, slices):
+        data = self.get_data()
+        return (super().get_label(slices)
+                + f"\ncategories={reprlib.repr(data.categories.tolist())}"
+                + f"\nordered={data.ordered}")
+
+
+def _categorical_to_node(data):
+    return _Categorical_Table(
+        data,
+        [[_display_value(value)] for value in data.tolist()],
+        col_names=[_column_name(getattr(data, "name", None))],
+    )
+
+
+def _intervalindex_to_node(data):
+    return Node_Table(
+        data,
+        [[_display_value(left), _display_value(right), data.closed]
+         for left, right in zip(data.left.tolist(), data.right.tolist())],
+        col_names=["left", "right", "closed"],
+    )
+
+
+def _scalar_to_node(data):
+    return Node_Leaf(data, str(data))
+
+
+def _pandas_types():
+    """Keep optional Pandas imports inside the extension, as before."""
+    import pandas as pd
+
+    return {
+        pd.DataFrame: (_dataframe_to_node, "olivedrab1", "#3a4d13"),
+        pd.Series: (_series_to_node, "olivedrab2", "#3a4d13"),
+        pd.Index: (_index_to_node, "olivedrab3", "#384d24"),
+        pd.MultiIndex: (_multiindex_to_node, "palegreen2", "#244d32"),
+        pd.CategoricalIndex: (_categorical_to_node, "darkseagreen2", "#324d39"),
+        pd.Categorical: (_categorical_to_node, "darkseagreen2", "#324d39"),
+        pd.IntervalIndex: (_intervalindex_to_node, "lightgoldenrod1", "#5c5125"),
+        # IndexSlice is an instance, not a public class or a table. Obtain its
+        # type from the public singleton instead of importing a private type.
+        type(pd.IndexSlice): (
+            lambda data: Node_Leaf(data, "pd.IndexSlice (slice helper)"),
+            "lightsteelblue1", "#30465c",
+        ),
+        pd.Timestamp: (_scalar_to_node, "olivedrab2", "#3a4d13"),
+        pd.Timedelta: (_scalar_to_node, "olivedrab2", "#3a4d13"),
+        pd.Period: (_scalar_to_node, "olivedrab2", "#3a4d13"),
+        pd.Interval: (_scalar_to_node, "lightgoldenrod1", "#5c5125"),
+        type(pd.NA): (_scalar_to_node, "gray85", "#454545"),
+        type(pd.NaT): (_scalar_to_node, "gray85", "#454545"),
+    }
+
+
+def extend_pandas():
+    for data_type, (to_node, light, dark) in _pandas_types().items():
+        config.type_to_node[data_type] = to_node
+        config_default.type_to_color_light[data_type] = light
+        config_default.type_to_color_dark[data_type] = dark
+        config.type_to_color[data_type] = dark if config.color_mode_dark else light
+
+
+def unextend_pandas():
+    for data_type in _pandas_types():
+        config.type_to_node.pop(data_type, None)
+        config.type_to_color.pop(data_type, None)
+        # Remove theme defaults too, so changing theme cannot re-enable colors.
+        config_default.type_to_color_light.pop(data_type, None)
+        config_default.type_to_color_dark.pop(data_type, None)

{memory_graph-0.3.86 → memory_graph-0.3.88}/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.86 → memory_graph-0.3.88}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.86
+Version: 0.3.88
 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.
@@ -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,17 +869,58 @@ 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.
 
 ```python
-def log_call(function):
+def log_call(function):  # decorator example
     def wrapper(*args, **kwargs):
-        print(f"Calling {function.__name__} with: {args}, {kwargs}")
-        returned = function(*args, **kwargs)
-        print(f"Finished {function.__name__} with return value: {returned}")
-        return returned
+        print(f"log: '{function.__name__}' called with: {args}, {kwargs}")
+        return_value = function(*args, **kwargs)
+        print(f"log: '{function.__name__}' returned with: {return_value}")
+        return return_value
     return wrapper
 
 @log_call
@@ -891,11 +932,11 @@ def calculate_total(price, quantity, rounding=False):
 def send_email(receiver, message, sender="support@company.com"):
     print(f"Sending email to:{receiver} from:{sender}, {message}")
 
-total = calculate_total(7.5, 3, rounding=True)
+total = calculate_total(2.4, 3, rounding=True)
 print(total)
 send_email("alice@example.com", "Your order is ready")
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=18&continues=1&play).
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/decorator.py&breakpoints=19&continues=1&play).
 
 ## Exception Handling ##
 
@@ -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.86 → memory_graph-0.3.88}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.86"
+version = "0.3.88"
 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"}

memory_graph-0.3.86/memory_graph/extension_pandas.py

@@ -1,36 +0,0 @@
-# This file is part of memory_graph.
-# Copyright (c) 2023, Bas Terwijn.
-# SPDX-License-Identifier: BSD-2-Clause
-
-""" Extension to add the memory graph configuration for Pandas types. """
-from memory_graph.node_linear import Node_Linear
-from memory_graph.node_table import Node_Table
-
-import memory_graph.config as config
-
-def extend_pandas():
-    import pandas as pd
-    
-    config.type_to_node[pd.DataFrame] = lambda data : (
-        Node_Table(data, 
-                data.values.tolist(),
-                col_names = data.columns.tolist(),
-                row_names = [ str(i) for i in data.index.tolist()]
-                )
-    )
-
-    config.type_to_node[pd.Series] = lambda data : (
-        Node_Linear(data, data.tolist())
-    )
-
-    config.type_to_color[pd.DataFrame] = "olivedrab1"
-    config.type_to_color[pd.Series] = "olivedrab2"
-
-def unextend_pandas():
-    import pandas as pd
-
-    del config.type_to_node[pd.DataFrame]
-    del config.type_to_node[pd.Series]
-
-    del config.type_to_color[pd.DataFrame]
-    del config.type_to_color[pd.Series]