memory-graph 0.3.70__tar.gz → 0.3.72__tar.gz

{memory_graph-0.3.70 → memory_graph-0.3.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.70
+Version: 0.3.72
 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
@@ -131,6 +131,8 @@ 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)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -751,7 +753,6 @@ In this configuration example we show the decimal, binary and [two's complement
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
-
 # Sliding Puzzle Solver #
 
 A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
@@ -760,6 +761,118 @@ 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 #
+
+Some examples where we focus on the flow of control of Python code.
+
+## Inheritance ##
+
+This example shows the flow of control when using inheritance with:
+- `super()`
+- class variable `message_count`
+
+```python
+from datetime import datetime
+
+class Notification_Service:
+    message_count = 0
+    
+    def __init__(self, priority):
+        self.priority = priority
+        self.log = []
+
+    def send(self, sender, receiver, message):
+        self.log.append((type(self).__name__, self.priority, sender, receiver, message))
+        Notification_Service.message_count += 1
+
+class Email_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_email):
+        super().__init__(priority)
+        self.from_email = from_email
+        
+    def send(self, to_email, message):
+        super().send(self.from_email, to_email, message)
+        print(f'sending Email from:{self.from_email} to:{to_email}')
+        print(f'priority: {self.priority} message: "{message}"')
+
+class SMS_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_nr):
+        super().__init__(priority)
+        self.from_nr = from_nr
+        
+    def send(self, to_nr, message):
+        super().send(self.from_nr, to_nr, message)
+        print(f'sending SMS from:{self.from_nr} to:{to_nr}')
+        print(f'priority: {self.priority} message: "{message}"')
+        
+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.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).
+
+## Decorator ##
+
+This example shows the flow of control when using a decorator.
+
+```python
+def log_call(function):
+    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
+    return wrapper
+
+@log_call
+def calculate_total(price, quantity, rounding=False):
+    result = price * quantity
+    return round(result) if rounding else result
+
+@log_call
+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)
+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).
+
+## Exception Handling ##
+
+This example shows the flow of control when using exception handling.
+
+```python
+def fun2():
+    try:
+        d = [0] * 3
+        for i in range(4):
+            try:
+                d[i] = i  # raises IndexError when i=3
+            except TypeError as e:
+                print(type(e), e)
+    except AssertionError as e:
+        print(type(e), e)
+            
+def fun1():
+    try:
+        return fun2()
+    except NameError as e:
+        print(type(e), e)
+    
+try:
+    fun1()
+except LookupError as e:
+    print(type(e), e)
+```
+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. 
+
+![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
 # 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).
@@ -1045,10 +1158,10 @@ import memory_graph as mg
 class MyClass:
     def __init__(self):
         self.children = {i: [i]*10 for i in range(5)}
-
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
 mg.l()
 ```
@@ -1064,10 +1177,13 @@ class MyClass:
         self.children = {i: [i]*10 for i in range(5)}
 
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
-mg.collapse_type(MyClass)  # collapse type 'MyClass' for better graph readability
+# for better graph readability in large graphs:
+mg.collapse_type(type(c))  # collapse type(c) 
+mg.collapse_type(id(d))    # collapse id(d)
 mg.l()
 ```
 ![collapse_type2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type2.png)

{memory_graph-0.3.70 → memory_graph-0.3.72}/README.md

@@ -111,6 +111,8 @@ 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)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -731,7 +733,6 @@ In this configuration example we show the decimal, binary and [two's complement
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
-
 # Sliding Puzzle Solver #
 
 A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
@@ -740,6 +741,118 @@ 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 #
+
+Some examples where we focus on the flow of control of Python code.
+
+## Inheritance ##
+
+This example shows the flow of control when using inheritance with:
+- `super()`
+- class variable `message_count`
+
+```python
+from datetime import datetime
+
+class Notification_Service:
+    message_count = 0
+    
+    def __init__(self, priority):
+        self.priority = priority
+        self.log = []
+
+    def send(self, sender, receiver, message):
+        self.log.append((type(self).__name__, self.priority, sender, receiver, message))
+        Notification_Service.message_count += 1
+
+class Email_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_email):
+        super().__init__(priority)
+        self.from_email = from_email
+        
+    def send(self, to_email, message):
+        super().send(self.from_email, to_email, message)
+        print(f'sending Email from:{self.from_email} to:{to_email}')
+        print(f'priority: {self.priority} message: "{message}"')
+
+class SMS_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_nr):
+        super().__init__(priority)
+        self.from_nr = from_nr
+        
+    def send(self, to_nr, message):
+        super().send(self.from_nr, to_nr, message)
+        print(f'sending SMS from:{self.from_nr} to:{to_nr}')
+        print(f'priority: {self.priority} message: "{message}"')
+        
+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.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).
+
+## Decorator ##
+
+This example shows the flow of control when using a decorator.
+
+```python
+def log_call(function):
+    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
+    return wrapper
+
+@log_call
+def calculate_total(price, quantity, rounding=False):
+    result = price * quantity
+    return round(result) if rounding else result
+
+@log_call
+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)
+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).
+
+## Exception Handling ##
+
+This example shows the flow of control when using exception handling.
+
+```python
+def fun2():
+    try:
+        d = [0] * 3
+        for i in range(4):
+            try:
+                d[i] = i  # raises IndexError when i=3
+            except TypeError as e:
+                print(type(e), e)
+    except AssertionError as e:
+        print(type(e), e)
+            
+def fun1():
+    try:
+        return fun2()
+    except NameError as e:
+        print(type(e), e)
+    
+try:
+    fun1()
+except LookupError as e:
+    print(type(e), e)
+```
+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. 
+
+![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
 # 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).
@@ -1025,10 +1138,10 @@ import memory_graph as mg
 class MyClass:
     def __init__(self):
         self.children = {i: [i]*10 for i in range(5)}
-
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
 mg.l()
 ```
@@ -1044,10 +1157,13 @@ class MyClass:
         self.children = {i: [i]*10 for i in range(5)}
 
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
-mg.collapse_type(MyClass)  # collapse type 'MyClass' for better graph readability
+# for better graph readability in large graphs:
+mg.collapse_type(type(c))  # collapse type(c) 
+mg.collapse_type(id(d))    # collapse id(d)
 mg.l()
 ```
 ![collapse_type2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type2.png)

{memory_graph-0.3.70 → memory_graph-0.3.72}/memory_graph/__init__.py

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

{memory_graph-0.3.70 → memory_graph-0.3.72}/memory_graph/memory_to_nodes.py

@@ -20,10 +20,15 @@ def read_nodes(data):
     - the id of 'data' as root node.
     """
 
-    def data_to_node(data_type, data):
-        """ Returns the Node for 'data' based on it's type. """
-        if data_type in config.type_to_node: # for predefined types
+    def data_to_node(data_id, data_type, 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)
         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, ...
@@ -41,7 +46,7 @@ def read_nodes(data):
             if data_id in nodes:
                 node = nodes[data_id]
             else:
-                node = data_to_node(data_type, data)
+                node = data_to_node(data_id, data_type, data)
                 if isinstance(node, Node_Key_Value):
                     nodes_key_value.append(data_id)
                 nodes[data_id] = node

{memory_graph-0.3.70 → memory_graph-0.3.72}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.70
+Version: 0.3.72
 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
@@ -131,6 +131,8 @@ 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)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -751,7 +753,6 @@ In this configuration example we show the decimal, binary and [two's complement
 
 ![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
 
-
 # Sliding Puzzle Solver #
 
 A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
@@ -760,6 +761,118 @@ 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 #
+
+Some examples where we focus on the flow of control of Python code.
+
+## Inheritance ##
+
+This example shows the flow of control when using inheritance with:
+- `super()`
+- class variable `message_count`
+
+```python
+from datetime import datetime
+
+class Notification_Service:
+    message_count = 0
+    
+    def __init__(self, priority):
+        self.priority = priority
+        self.log = []
+
+    def send(self, sender, receiver, message):
+        self.log.append((type(self).__name__, self.priority, sender, receiver, message))
+        Notification_Service.message_count += 1
+
+class Email_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_email):
+        super().__init__(priority)
+        self.from_email = from_email
+        
+    def send(self, to_email, message):
+        super().send(self.from_email, to_email, message)
+        print(f'sending Email from:{self.from_email} to:{to_email}')
+        print(f'priority: {self.priority} message: "{message}"')
+
+class SMS_Notification(Notification_Service):
+    
+    def __init__(self, priority, from_nr):
+        super().__init__(priority)
+        self.from_nr = from_nr
+        
+    def send(self, to_nr, message):
+        super().send(self.from_nr, to_nr, message)
+        print(f'sending SMS from:{self.from_nr} to:{to_nr}')
+        print(f'priority: {self.priority} message: "{message}"')
+        
+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.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).
+
+## Decorator ##
+
+This example shows the flow of control when using a decorator.
+
+```python
+def log_call(function):
+    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
+    return wrapper
+
+@log_call
+def calculate_total(price, quantity, rounding=False):
+    result = price * quantity
+    return round(result) if rounding else result
+
+@log_call
+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)
+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).
+
+## Exception Handling ##
+
+This example shows the flow of control when using exception handling.
+
+```python
+def fun2():
+    try:
+        d = [0] * 3
+        for i in range(4):
+            try:
+                d[i] = i  # raises IndexError when i=3
+            except TypeError as e:
+                print(type(e), e)
+    except AssertionError as e:
+        print(type(e), e)
+            
+def fun1():
+    try:
+        return fun2()
+    except NameError as e:
+        print(type(e), e)
+    
+try:
+    fun1()
+except LookupError as e:
+    print(type(e), e)
+```
+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. 
+
+![exception_tree.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/exception_tree.png)
 
 # 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).
@@ -1045,10 +1158,10 @@ import memory_graph as mg
 class MyClass:
     def __init__(self):
         self.children = {i: [i]*10 for i in range(5)}
-
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
 mg.l()
 ```
@@ -1064,10 +1177,13 @@ class MyClass:
         self.children = {i: [i]*10 for i in range(5)}
 
 a = 1
-b = (1,2,3)
+b = (1, 2, 3)
 c = MyClass()
+d = (4, 5, 6, 7)
 
-mg.collapse_type(MyClass)  # collapse type 'MyClass' for better graph readability
+# for better graph readability in large graphs:
+mg.collapse_type(type(c))  # collapse type(c) 
+mg.collapse_type(id(d))    # collapse id(d)
 mg.l()
 ```
 ![collapse_type2.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type2.png)

{memory_graph-0.3.70 → memory_graph-0.3.72}/memory_graph.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE.txt
 README.md
 pyproject.toml
+setup.py
 memory_graph/__init__.py
 memory_graph/call_stack.py
 memory_graph/config.py

{memory_graph-0.3.70 → memory_graph-0.3.72}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.70"
+version = "0.3.72"
 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.72/setup.py

@@ -0,0 +1,7 @@
+from setuptools import setup
+
+setup(
+    name="memory-graph",
+    version="0.3.30",
+    packages=["memory_graph"],
+)