memory-graph 0.3.73__tar.gz → 0.3.75__tar.gz

{memory_graph-0.3.73 → memory_graph-0.3.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.73
+Version: 0.3.75
 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
@@ -34,7 +34,7 @@ Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
+![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah 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 #
@@ -433,12 +433,12 @@ import memory_graph as mg
 mg.config.type_to_horizontal[list] = True  # horizontal lists
 
 def binary(value: int) -> list[int]:
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     if value == 0:
         return []
     quotient, remainder = divmod(value, 2)
     result = binary(quotient) + [remainder]
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print( binary(100) )
@@ -586,16 +586,16 @@ except Exception as e:
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "/home/bterwijn/temp/e.py", line 18, in <module>
+  File "exception_example.py", line 18, in <module>
     raise e                        # raise to print traceback
     ^^^^^^^
-  File "/home/bterwijn/temp/e.py", line 15, in <module>
+  File "exception_example.py", line 15, in <module>
     fun1()
-  File "/home/bterwijn/temp/e.py", line 12, in fun1
+  File "exception_example.py", line 12, in fun1
     fun2()
-  File "/home/bterwijn/temp/e.py", line 9, in fun2
+  File "exception_example.py", line 9, in fun2
     fun3()
-  File "/home/bterwijn/temp/e.py", line 6, in fun3
+  File "exception_example.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -772,7 +772,6 @@ This example shows the flow of control when using inheritance with:
 - class variable `message_count`
 
 ```python
-from datetime import datetime
 
 class Notification_Service:
     message_count = 0
@@ -810,14 +809,14 @@ class SMS_Notification(Notification_Service):
 email = Email_Notification(3, 'support@company.com')
 email.send('customer@email.com', 'Your report is ready')
 email.send('customer@email.com', 'Update to Privacy Policy')
-sms = Email_Notification(3, '0123456789')
+sms = SMS_Notification(3, '0123456789')
 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=36&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/inheritance.py&breakpoints=35&continues=1&play).
 
 ## Decorator ##
 
-This example shows the flow of control when using a 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):
@@ -851,29 +850,135 @@ This example shows the flow of control when using exception handling.
 def fun2():
     try:
         d = [0] * 3
-        for i in range(4):
+        for i in range(6):
             try:
-                d[i] = i  # raises IndexError when i=3
-            except TypeError as e:
+                print(f'{i=}')
+                d[i] = i  # raises IndexError when i>=3
+            except ZeroDivisionError as e:
                 print(type(e), e)
     except AssertionError as e:
         print(type(e), e)
-            
+    print('fun2() returns')
+
 def fun1():
     try:
         return fun2()
     except NameError as e:
         print(type(e), e)
-    
+    print('fun1() returns')
+
 try:
     fun1()
 except LookupError as e:
     print(type(e), e)
+print('program ended cleanly')
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=19&continues=1&play). In the program an `IndexError` is raise and matched with various exceptions in the exception hierarchy below. It matches with the 'LookupError' exception and is handled there by just printing it. Exceptions that are not handled stop the execution of a program. 
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=22&continues=1&play). In the program an `IndexError` exception is raised which propagates up the call stack until it reaches an except clause that matches its type where it is handled. Here, it is handled by the `LookupError` except clause because `IndexError` is a subclass of `LookupError`. Exceptions that are not handled terminate the execution of a program while its traceback is shown for analyses.
 
 ![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
+## Lazy Evaluation ##
+
+In the following Eager and Lazy ealuation examples, we use this `pr()` function to print in what order things are created and used.
+
+```python
+def pr(tag, v):
+    print(tag, v)
+    return v
+```
+
+With eager evaluation, the function creates all three elements up front and stores them in a list before iteration begins. With lazy evaluation, the function returns a generator that creates each element only when it is needed.
+
+<table>
+    <tr> <td width="50%" valign="top"><strong>Eager</strong></td> <td width="50%" valign="top"><strong>Lazy</strong></td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    result = []
+    for i in range(3):
+        result.append(pr('create:', i))
+    return result
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_return.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    for i in range(3):
+        yield pr('create:', i)
+
+
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_yield.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    return [
+        pr('create:', i)
+        for i in range(3)
+    ]
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_compri.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    return (
+        pr('create:', i)
+        for i in range(3)
+    )
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_express.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```text
+create: 0
+create: 1
+create: 2
+use: 0
+use: 1
+use: 2
+```
+
+  </td><td width="50%" valign="top">
+
+```text
+create: 0
+use: 0
+create: 1
+use: 1
+create: 2
+use: 2
+```
+
+  </td></tr>
+</table>
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 

{memory_graph-0.3.73 → memory_graph-0.3.75}/README.md

@@ -14,7 +14,7 @@ Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
+![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah 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 #
@@ -413,12 +413,12 @@ import memory_graph as mg
 mg.config.type_to_horizontal[list] = True  # horizontal lists
 
 def binary(value: int) -> list[int]:
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     if value == 0:
         return []
     quotient, remainder = divmod(value, 2)
     result = binary(quotient) + [remainder]
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print( binary(100) )
@@ -566,16 +566,16 @@ except Exception as e:
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "/home/bterwijn/temp/e.py", line 18, in <module>
+  File "exception_example.py", line 18, in <module>
     raise e                        # raise to print traceback
     ^^^^^^^
-  File "/home/bterwijn/temp/e.py", line 15, in <module>
+  File "exception_example.py", line 15, in <module>
     fun1()
-  File "/home/bterwijn/temp/e.py", line 12, in fun1
+  File "exception_example.py", line 12, in fun1
     fun2()
-  File "/home/bterwijn/temp/e.py", line 9, in fun2
+  File "exception_example.py", line 9, in fun2
     fun3()
-  File "/home/bterwijn/temp/e.py", line 6, in fun3
+  File "exception_example.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -752,7 +752,6 @@ This example shows the flow of control when using inheritance with:
 - class variable `message_count`
 
 ```python
-from datetime import datetime
 
 class Notification_Service:
     message_count = 0
@@ -790,14 +789,14 @@ class SMS_Notification(Notification_Service):
 email = Email_Notification(3, 'support@company.com')
 email.send('customer@email.com', 'Your report is ready')
 email.send('customer@email.com', 'Update to Privacy Policy')
-sms = Email_Notification(3, '0123456789')
+sms = SMS_Notification(3, '0123456789')
 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=36&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/inheritance.py&breakpoints=35&continues=1&play).
 
 ## Decorator ##
 
-This example shows the flow of control when using a 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):
@@ -831,29 +830,135 @@ This example shows the flow of control when using exception handling.
 def fun2():
     try:
         d = [0] * 3
-        for i in range(4):
+        for i in range(6):
             try:
-                d[i] = i  # raises IndexError when i=3
-            except TypeError as e:
+                print(f'{i=}')
+                d[i] = i  # raises IndexError when i>=3
+            except ZeroDivisionError as e:
                 print(type(e), e)
     except AssertionError as e:
         print(type(e), e)
-            
+    print('fun2() returns')
+
 def fun1():
     try:
         return fun2()
     except NameError as e:
         print(type(e), e)
-    
+    print('fun1() returns')
+
 try:
     fun1()
 except LookupError as e:
     print(type(e), e)
+print('program ended cleanly')
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=19&continues=1&play). In the program an `IndexError` is raise and matched with various exceptions in the exception hierarchy below. It matches with the 'LookupError' exception and is handled there by just printing it. Exceptions that are not handled stop the execution of a program. 
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=22&continues=1&play). In the program an `IndexError` exception is raised which propagates up the call stack until it reaches an except clause that matches its type where it is handled. Here, it is handled by the `LookupError` except clause because `IndexError` is a subclass of `LookupError`. Exceptions that are not handled terminate the execution of a program while its traceback is shown for analyses.
 
 ![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
+## Lazy Evaluation ##
+
+In the following Eager and Lazy ealuation examples, we use this `pr()` function to print in what order things are created and used.
+
+```python
+def pr(tag, v):
+    print(tag, v)
+    return v
+```
+
+With eager evaluation, the function creates all three elements up front and stores them in a list before iteration begins. With lazy evaluation, the function returns a generator that creates each element only when it is needed.
+
+<table>
+    <tr> <td width="50%" valign="top"><strong>Eager</strong></td> <td width="50%" valign="top"><strong>Lazy</strong></td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    result = []
+    for i in range(3):
+        result.append(pr('create:', i))
+    return result
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_return.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    for i in range(3):
+        yield pr('create:', i)
+
+
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_yield.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    return [
+        pr('create:', i)
+        for i in range(3)
+    ]
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_compri.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    return (
+        pr('create:', i)
+        for i in range(3)
+    )
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_express.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```text
+create: 0
+create: 1
+create: 2
+use: 0
+use: 1
+use: 2
+```
+
+  </td><td width="50%" valign="top">
+
+```text
+create: 0
+use: 0
+create: 1
+use: 1
+create: 2
+use: 2
+```
+
+  </td></tr>
+</table>
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/__init__.py

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

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/config.py

@@ -27,13 +27,6 @@ no_index_types = {}
 
 type_to_string = { }
 
-def to_string(data):
-    """ Convert data to string. """
-    data_type = type(data)
-    if data_type in type_to_string:
-        return type_to_string[data_type](data)
-    return str(data)
-
 type_to_node = { }
 
 type_to_color = { }

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/config_default.py

@@ -60,11 +60,12 @@ def reset():
 
     """ Types that need a special conversion """
     config.type_to_string = {
-        types.FunctionType: lambda data: data.__qualname__,
-        types.MethodType: lambda data: data.__qualname__,
-        classmethod: lambda data: data.__qualname__,
-        staticmethod: lambda data: data.__qualname__,
-        type(len): lambda data: data.__qualname__,
+        types.FunctionType: lambda data: utils.limit_string(data.__qualname__),
+        types.MethodType: lambda data: utils.limit_string(data.__qualname__),
+        classmethod: lambda data: utils.limit_string(data.__qualname__),
+        staticmethod: lambda data: utils.limit_string(data.__qualname__),
+        type(len): lambda data: utils.limit_string(data.__qualname__),
+        BaseException: lambda data: utils.exception_to_string(data),
     }
     
     """ Conversion from type to Node objects. """
@@ -78,6 +79,7 @@ def reset():
             if dict in config.embedding_types else 
             Node_Linear(data, utils.filter_dict(data) )
         ),
+        BaseException: lambda data: Node_Leaf(data, data),
     }
     
     """ Colors of different types in the graph. """
@@ -103,6 +105,8 @@ def reset():
         dict : "#60a5ff",
         types.MappingProxyType : "dodgerblue2", # not used
         range : "cornsilk2",
+        # ================= exception
+        BaseException : "#ff5555",
     }
 
 

memory_graph-0.3.75/memory_graph/config_helpers.py

@@ -0,0 +1,72 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+""" This module provides helper functions to access the configuration of the memory graph. """
+import memory_graph.utils as utils
+from memory_graph.slicer import Slicer
+import memory_graph.config as config
+import memory_graph.utils as utils
+
+def get_property(data_id, data_types, node_type, dictionary, default):
+    if data_id in dictionary:
+        return dictionary[data_id]
+    for data_type in data_types:
+        if data_type in dictionary:
+            return dictionary[data_type]
+    if node_type in dictionary:
+        return dictionary[node_type]
+    return default
+
+def get_data_to_node(data, default=None):
+    return get_property(id(data),
+                        utils.get_all_types(data),
+                        None,
+                        config.type_to_node, 
+                        default )
+
+def default_to_string(data):
+    """ Convert data to string. """
+    try:
+        if isinstance(data, str):
+            s = data
+        else:
+            s = str(data)
+        return utils.limit_string(s)
+    except Exception as e:
+        return f'no stringification, {type(e).__name__}: {e}'
+
+def get_to_string(data, default=lambda s: default_to_string(s)):
+    return get_property(id(data),
+                        utils.get_all_types(data),
+                        None,
+                        config.type_to_string, 
+                        default )
+
+def get_node_color(node, default='white'):
+    return get_property(node.get_id(),
+                        utils.get_all_types(node.get_data()),
+                        type(node),
+                        config.type_to_color, 
+                        default)
+    
+def get_node_vertical(node, default):
+    horizontal = get_property(node.get_id(),
+                              utils.get_all_types(node.get_data()),
+                              type(node),
+                              config.type_to_horizontal,
+                              None)
+    if isinstance(horizontal, bool):
+        return not horizontal
+    return get_property(node.get_id(),
+                        utils.get_all_types(node.get_data()),
+                        type(node),
+                        config.type_to_vertical,
+                        default)
+
+def get_node_slicer(node, data, default=Slicer(3,2,3)):
+    return get_property(id(data),
+                        utils.get_all_types(node.get_data()),
+                        type(node), 
+                        config.type_to_slicer, 
+                        default)

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/html_table.py

@@ -5,6 +5,7 @@
 from memory_graph.node_base import Node_Base 
 import memory_graph.node_base
 import memory_graph.config as config
+import memory_graph.config_helpers as config_helpers
 import html
 
 def html_table_frame(s, border, color, spacing=5):
@@ -12,11 +13,11 @@ def html_table_frame(s, border, color, spacing=5):
     return (f'<\n<TABLE BORDER="{border}" CELLBORDER="1" CELLSPACING="{spacing}" CELLPADDING="0" BGCOLOR="{color}" PORT="table">\n    <TR>' +
             s + '</TR>\n</TABLE>\n>')
 
-def format_string(s):
-    """ Helper function to format the string s to be shown in the graph. Setting the max_string_length and escaping html characters. """
-    s = config.to_string(s)
-    s = (s[:config.max_string_length] + '...') if len(s) > config.max_string_length else s
-    return html.escape(s)
+def format_string(value):
+    """ Helper function to format 'value' to be shown in the graph. We escape html characters and convert newlines to <BR/> tags. """
+    to_string = config_helpers.get_to_string(value)
+    s = html.escape(to_string(value))
+    return s.replace('\n', ' <BR/> ')
 
 class HTML_Table:
     """
@@ -54,11 +55,6 @@ class HTML_Table:
             self.html += '</TR>\n    <TR>'
             self.add_new_line_flag = False
 
-    def add_string(self, s, border=0):
-        """ Add a string s to the table. """
-        self.html += f'<TD BORDER="{border}">'+format_string(s)+'</TD>'
-        self.is_empty = False
-
     def add_index(self, s):
         """ Add an index s to the table. """
         self.check_add_new_line()
@@ -67,7 +63,6 @@ class HTML_Table:
 
     def add_entry(self, node, nodes, child, id_to_slices, rounded=False, border=1, dashed=False, embed=False):
         """ Add child to the table either as reference if it is a Node_Base or as a value otherwise. """
-        #print('child:', child)
         child_id = id(child)
         if not embed and child_id in nodes:
             child = nodes[child_id] 
@@ -78,11 +73,12 @@ class HTML_Table:
         else:
             self.add_value(child, rounded, border)
 
-    def add_value(self, s, rounded=False, border=1):
-        """ Helper function to add a value s to the table. """
+    def add_value(self, value, rounded=False, border=1):
+        """ Helper function to add 'value' to the table. """
         self.check_add_new_line()
         r = ' STYLE="ROUNDED"' if rounded else ''
-        self.html += f'<TD BORDER="{border}"{r}> {format_string(s)} </TD>'
+        self.html += f'<TD BORDER="{border}"{r}> {format_string(value)} </TD>'
+        self.is_empty = False
         self.col_count += 1
 
     def add_reference(self, node, child, rounded=False, border=1, dashed=False):
@@ -106,7 +102,7 @@ class HTML_Table:
         """ Construct the HTML table string with the 'border' and 'color' settings. """
         if self.col_count == 0 and self.row_count == 0:
             if self.is_empty:
-                self.add_string(' ')
+                self.add_value('', border=0)
             return html_table_frame(self.html, border, color, spacing=0)
         return html_table_frame(self.html, border, color)
     

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/memory_to_nodes.py

@@ -20,15 +20,11 @@ def read_nodes(data):
     - the id of 'data' as root node.
     """
 
-    def data_to_node(data_id, data_type, data):
+    def data_to_node(data):
         """ Returns the Node for 'data' based on it's id or type. """
-        if data_id in config.type_to_node: # for ids
-            return config.type_to_node[data_id](data)
-        elif data_type in config.type_to_node: # for predefined types
-            return config.type_to_node[data_type](data)
-        elif isinstance(data, type) and type in config.type_to_node:
-            # Handle classes with custom metaclasses (for example abc.ABCMeta).
-            return config.type_to_node[type](data)
+        to_node = config_helpers.get_data_to_node(data)
+        if (to_node):
+            return to_node(data)
         elif utils.has_dict_attributes(data): # for user defined classes
             return Node_Key_Value(data, utils.filter_dict(utils.get_dict_attributes(data)) )
         elif utils.is_finite_iterable(data): # for lists, tuples, sets, ...
@@ -46,7 +42,7 @@ def read_nodes(data):
             if data_id in nodes:
                 node = nodes[data_id]
             else:
-                node = data_to_node(data_id, data_type, data)
+                node = data_to_node(data)
                 if isinstance(node, Node_Key_Value):
                     nodes_key_value.append(data_id)
                 nodes[data_id] = node
@@ -219,7 +215,7 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
         """ Adds 'node' to 'graphviz_graph' with its children and edges. """
         html_table = node.get_html_table(nodes, slices, id_to_slices)
         edges = html_table.get_edges()
-        color = config_helpers.get_color(node)
+        color = config_helpers.get_node_color(node)
         border = 3 if node.is_root() else 1
         if config.type_labels:
             graphviz_graph.node(node.get_name(),

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/node_base.py

@@ -105,7 +105,7 @@ class Node_Base(ABC):
         return html_table
     
     def get_slicer(self):
-        return config_helpers.get_slicer(self, self.get_data())
+        return config_helpers.get_node_slicer(self, self.get_data())
     
     def is_hidden_node(self):
         """

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/node_key_value.py

@@ -46,7 +46,7 @@ class Node_Key_Value(Node_Base):
         """
         Return if the node is vertical or horizontal based on the orientation of the children.
         """
-        vertical = config_helpers.get_vertical(self, None)
+        vertical = config_helpers.get_node_vertical(self, None)
         if vertical is None:
             vertical = not self.has_references(nodes, slices, id_to_slices)
         return vertical

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/node_linear.py

@@ -37,7 +37,7 @@ class Node_Linear(Node_Base):
         """
         Return if the node is vertical or horizontal based on the orientation of the children.
         """
-        vertical = config_helpers.get_vertical(self, None)
+        vertical = config_helpers.get_node_vertical(self, None)
         if vertical is None:
             vertical = not self.has_references(nodes, slices)
         return vertical

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph/utils.py

@@ -5,6 +5,42 @@
 import math 
 import types
 import functools
+import traceback
+import re
+
+import memory_graph.config as config
+
+def limit_string(s):
+    """ Helper function to limit the length of a string s to the 'max_string_length' in the config. """
+    if len(s) > config.max_string_length:
+        return s[:config.max_string_length] + '...'
+    return s
+
+def exception_to_string(e):
+    """ Helper function to convert the traceback of an exception to a string. """
+    return ''.join(traceback.format_exception(type(e), e, e.__traceback__)).strip()
+
+def exception_to_string_no_path(e):
+    """ Helper function to convert the traceback of an exception to a string without file paths. """
+    s = exception_to_string(e)
+    # Convert traceback file paths like File "/a/b/c.py" to File "c.py".
+    return re.sub(
+        r'(^\s*File ")(.*?)(")',
+        lambda m: f'{m.group(1)}{m.group(2).replace("\\", "/").rsplit("/", 1)[-1]}{m.group(3)}',
+        s,
+        flags=re.MULTILINE,
+    )
+
+def exception_to_string_short(e):
+    """ Helper function to convert an exception to a short string. """
+    return f'{type(e).__name__}: {e}'
+
+def get_all_types(obj):
+    cls = type(obj)
+    if hasattr(cls, '__mro__'):
+        return cls.__mro__
+    else:
+        return [cls]
 
 def has_dict_attributes(value):
     """ Returns 'True' if 'value' has a '__dict__' attribute. """
@@ -15,6 +51,7 @@ def get_dict_attributes(value):
     return getattr(value,"__dict__")
 
 def is_not_state(obj):
+    """ Returns 'True' if 'obj' is not considered state, e.g. a function or method. """
     if isinstance(obj, (types.FunctionType, types.MethodType,
                         types.BuiltinFunctionType, types.BuiltinMethodType,
                         classmethod, staticmethod,

{memory_graph-0.3.73 → memory_graph-0.3.75}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.73
+Version: 0.3.75
 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
@@ -34,7 +34,7 @@ Run a live demo in the 👉 [**Memory Graph Web Debugger**](https://memory-graph
 - understand function calls, variable scope, and the **complete program state** through call stack visualization
 
 An example Binary Tree data structure:
-![images/bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
+![bin_tree_vs.gif](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_tree_vs.gif)
 Or see it in the [Memory Grah 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 #
@@ -433,12 +433,12 @@ import memory_graph as mg
 mg.config.type_to_horizontal[list] = True  # horizontal lists
 
 def binary(value: int) -> list[int]:
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     if value == 0:
         return []
     quotient, remainder = divmod(value, 2)
     result = binary(quotient) + [remainder]
-    mg.block(mg.show(), mg.stack())
+    mg.block(mg.show, mg.stack())
     return result
 
 print( binary(100) )
@@ -586,16 +586,16 @@ except Exception as e:
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "/home/bterwijn/temp/e.py", line 18, in <module>
+  File "exception_example.py", line 18, in <module>
     raise e                        # raise to print traceback
     ^^^^^^^
-  File "/home/bterwijn/temp/e.py", line 15, in <module>
+  File "exception_example.py", line 15, in <module>
     fun1()
-  File "/home/bterwijn/temp/e.py", line 12, in fun1
+  File "exception_example.py", line 12, in fun1
     fun2()
-  File "/home/bterwijn/temp/e.py", line 9, in fun2
+  File "exception_example.py", line 9, in fun2
     fun3()
-  File "/home/bterwijn/temp/e.py", line 6, in fun3
+  File "exception_example.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -772,7 +772,6 @@ This example shows the flow of control when using inheritance with:
 - class variable `message_count`
 
 ```python
-from datetime import datetime
 
 class Notification_Service:
     message_count = 0
@@ -810,14 +809,14 @@ class SMS_Notification(Notification_Service):
 email = Email_Notification(3, 'support@company.com')
 email.send('customer@email.com', 'Your report is ready')
 email.send('customer@email.com', 'Update to Privacy Policy')
-sms = Email_Notification(3, '0123456789')
+sms = SMS_Notification(3, '0123456789')
 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=36&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/inheritance.py&breakpoints=35&continues=1&play).
 
 ## Decorator ##
 
-This example shows the flow of control when using a 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):
@@ -851,29 +850,135 @@ This example shows the flow of control when using exception handling.
 def fun2():
     try:
         d = [0] * 3
-        for i in range(4):
+        for i in range(6):
             try:
-                d[i] = i  # raises IndexError when i=3
-            except TypeError as e:
+                print(f'{i=}')
+                d[i] = i  # raises IndexError when i>=3
+            except ZeroDivisionError as e:
                 print(type(e), e)
     except AssertionError as e:
         print(type(e), e)
-            
+    print('fun2() returns')
+
 def fun1():
     try:
         return fun2()
     except NameError as e:
         print(type(e), e)
-    
+    print('fun1() returns')
+
 try:
     fun1()
 except LookupError as e:
     print(type(e), e)
+print('program ended cleanly')
 ```
-Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=19&continues=1&play). In the program an `IndexError` is raise and matched with various exceptions in the exception hierarchy below. It matches with the 'LookupError' exception and is handled there by just printing it. Exceptions that are not handled stop the execution of a program. 
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/exceptions.py&breakpoints=22&continues=1&play). In the program an `IndexError` exception is raised which propagates up the call stack until it reaches an except clause that matches its type where it is handled. Here, it is handled by the `LookupError` except clause because `IndexError` is a subclass of `LookupError`. Exceptions that are not handled terminate the execution of a program while its traceback is shown for analyses.
 
 ![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
+## Lazy Evaluation ##
+
+In the following Eager and Lazy ealuation examples, we use this `pr()` function to print in what order things are created and used.
+
+```python
+def pr(tag, v):
+    print(tag, v)
+    return v
+```
+
+With eager evaluation, the function creates all three elements up front and stores them in a list before iteration begins. With lazy evaluation, the function returns a generator that creates each element only when it is needed.
+
+<table>
+    <tr> <td width="50%" valign="top"><strong>Eager</strong></td> <td width="50%" valign="top"><strong>Lazy</strong></td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    result = []
+    for i in range(3):
+        result.append(pr('create:', i))
+    return result
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_return.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    for i in range(3):
+        yield pr('create:', i)
+
+
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_yield.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```python
+def fun():
+    return [
+        pr('create:', i)
+        for i in range(3)
+    ]
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/eager_compri.py&play)
+
+  </td><td width="50%" valign="top">
+
+```python
+def fun():
+    return (
+        pr('create:', i)
+        for i in range(3)
+    )
+
+for i in fun():
+    pr('use:', i)
+```
+
+Run in [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/lazy_express.py&play)
+
+  </td></tr>
+    <tr><td width="50%" valign="top">
+
+```text
+create: 0
+create: 1
+create: 2
+use: 0
+use: 1
+use: 2
+```
+
+  </td><td width="50%" valign="top">
+
+```text
+create: 0
+use: 0
+create: 1
+use: 1
+create: 2
+use: 2
+```
+
+  </td></tr>
+</table>
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 

{memory_graph-0.3.73 → memory_graph-0.3.75}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.73"
+version = "0.3.75"
 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.73/memory_graph/config_helpers.py

@@ -1,44 +0,0 @@
-# This file is part of memory_graph.
-# Copyright (c) 2023, Bas Terwijn.
-# SPDX-License-Identifier: BSD-2-Clause
-
-""" This module provides helper functions to access the configuration of the memory graph. """
-from memory_graph.slicer import Slicer
-import memory_graph.config as config
-
-def get_property(data_id, data_type, node_type, dictionary, default):
-    if data_id in dictionary:
-        return dictionary[data_id]
-    if data_type in dictionary:
-        return dictionary[data_type]
-    if node_type in dictionary:
-        return dictionary[node_type]
-    return default
-
-def get_color(node, default='white'):
-    return get_property(node.get_id(),
-                        node.get_type(),
-                        type(node),
-                        config.type_to_color, 
-                        default)
-    
-def get_vertical(node, default):
-    horizontal = get_property(node.get_id(),
-                              node.get_type(),
-                              type(node),
-                              config.type_to_horizontal,
-                              None)
-    if isinstance(horizontal, bool):
-        return not horizontal
-    return get_property(node.get_id(),
-                        node.get_type(),
-                        type(node),
-                        config.type_to_vertical,
-                        default)
-
-def get_slicer(node, data, default=Slicer(3,2,3)):
-    return get_property(id(data),
-                        type(data),
-                        type(node), 
-                        config.type_to_slicer, 
-                        default)