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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.73
+Version: 0.3.74
 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
@@ -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.74}/README.md

@@ -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.74}/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.74"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes

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

@@ -29,10 +29,13 @@ 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)
+    try:
+        data_type = type(data)
+        if data_type in type_to_string:
+            return type_to_string[data_type](data)
+        return str(data)
+    except Exception as e:
+        return f'no stringification, {type(e).__name__}: {e}'
 
 type_to_node = { }
 

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

@@ -15,6 +15,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.74}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.73
+Version: 0.3.74
 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
@@ -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.74}/pyproject.toml

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