memory-graph 0.3.69__tar.gz → 0.3.71__tar.gz

{memory_graph-0.3.69 → memory_graph-0.3.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.69
+Version: 0.3.71
 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
@@ -559,16 +559,15 @@ and pressing &lt;Enter&gt; a number of times, results in:
 
 ## Debugging using Exceptions ##
 
-To get the call stack at the point where exception `e` was thrown use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
+To get the call stack at the point where exception `e` was raised use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
 
 ``` python
 import memory_graph as mg
-import traceback;
 
 def fun3():
     d = [0] * 3
     for i in range(4):
-        d[i] = i  # throws IndexError when i = 3
+        d[i] = i  # raises IndexError when i = 3
     
 def fun2():
     fun3()
@@ -579,19 +578,22 @@ def fun1():
 try:
     fun1()
 except Exception as e:
-    traceback.print_exc()           # print trace back
-    mg.show(mg.stack_exception(e))  # graph trace back
+    mg.show(mg.stack_exception(e)) # graph traceback
+    raise e                        # reraise to print traceback
 ```
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "exception_example.py", line 16, in <module>
+  File "/home/bterwijn/temp/e.py", line 18, in <module>
+    raise e                        # raise to print traceback
+    ^^^^^^^
+  File "/home/bterwijn/temp/e.py", line 15, in <module>
     fun1()
-  File "exception_example.py", line 13, in fun1
+  File "/home/bterwijn/temp/e.py", line 12, in fun1
     fun2()
-  File "exception_example.py", line 10, in fun2
+  File "/home/bterwijn/temp/e.py", line 9, in fun2
     fun3()
-  File "exception_example.py", line 7, in fun3
+  File "/home/bterwijn/temp/e.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -1033,6 +1035,48 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 
 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_search.py&breakpoints=32&continues=1&timestep=0.5&play)
 
+## Collapse Type ##
+
+Sometimes a type has too many attributes or too many child nodes in the graph for it to stay readable. We use type 'MyClass' as an example here:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+mg.l()
+```
+![collapse_type1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type1.png)
+
+Then we can collapse this type with `mg.collapse_type(<type-name>)`. This simply sets `mg.config.type_to_node[<type-name>]` to an empty `Node_Linear` and `mg.config.type_to_color[<type-name>]` to a gray color, so that we don't introspect it's attributes which will also increase graph making performance:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+# 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)
+
+Use `mg.reset_type(<type_name>)` to remove the `type_to_node` and `type_to_color` configuration for a type and restore it's default introspection.
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.69 → memory_graph-0.3.71}/README.md

@@ -539,16 +539,15 @@ and pressing <Enter> a number of times, results in:
 
 ## Debugging using Exceptions ##
 
-To get the call stack at the point where exception `e` was thrown use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
+To get the call stack at the point where exception `e` was raised use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
 
 ``` python
 import memory_graph as mg
-import traceback;
 
 def fun3():
     d = [0] * 3
     for i in range(4):
-        d[i] = i  # throws IndexError when i = 3
+        d[i] = i  # raises IndexError when i = 3
     
 def fun2():
     fun3()
@@ -559,19 +558,22 @@ def fun1():
 try:
     fun1()
 except Exception as e:
-    traceback.print_exc()           # print trace back
-    mg.show(mg.stack_exception(e))  # graph trace back
+    mg.show(mg.stack_exception(e)) # graph traceback
+    raise e                        # reraise to print traceback
 ```
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "exception_example.py", line 16, in <module>
+  File "/home/bterwijn/temp/e.py", line 18, in <module>
+    raise e                        # raise to print traceback
+    ^^^^^^^
+  File "/home/bterwijn/temp/e.py", line 15, in <module>
     fun1()
-  File "exception_example.py", line 13, in fun1
+  File "/home/bterwijn/temp/e.py", line 12, in fun1
     fun2()
-  File "exception_example.py", line 10, in fun2
+  File "/home/bterwijn/temp/e.py", line 9, in fun2
     fun3()
-  File "exception_example.py", line 7, in fun3
+  File "/home/bterwijn/temp/e.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -1013,6 +1015,48 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 
 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_search.py&breakpoints=32&continues=1&timestep=0.5&play)
 
+## Collapse Type ##
+
+Sometimes a type has too many attributes or too many child nodes in the graph for it to stay readable. We use type 'MyClass' as an example here:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+mg.l()
+```
+![collapse_type1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type1.png)
+
+Then we can collapse this type with `mg.collapse_type(<type-name>)`. This simply sets `mg.config.type_to_node[<type-name>]` to an empty `Node_Linear` and `mg.config.type_to_color[<type-name>]` to a gray color, so that we don't introspect it's attributes which will also increase graph making performance:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+# 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)
+
+Use `mg.reset_type(<type_name>)` to remove the `type_to_node` and `type_to_color` configuration for a type and restore it's default introspection.
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.69 → memory_graph-0.3.71}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.69"
+__version__ = "0.3.71"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes
@@ -525,3 +525,14 @@ def extend_torch(on=True):
         ext_torch.extend_torch()
     else:
         ext_torch.unextend_torch()
+
+
+# ------------ collapse type
+    
+def collapse_type(type_name):
+    mg.config.type_to_node[type_name] = lambda data: mg.Node_Linear(data, [])
+    mg.config.type_to_color[type_name] = "azure3"
+
+def reset_type(type_name):
+    del mg.config.type_to_node[type_name]
+    del mg.config.type_to_color[type_name]

{memory_graph-0.3.69 → memory_graph-0.3.71}/memory_graph/memory_to_nodes.py

@@ -20,9 +20,11 @@ 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 utils.has_dict_attributes(data): # for user defined classes
             return Node_Key_Value(data, utils.filter_dict(utils.get_dict_attributes(data)) )
@@ -41,7 +43,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.69 → memory_graph-0.3.71}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.69
+Version: 0.3.71
 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
@@ -559,16 +559,15 @@ and pressing &lt;Enter&gt; a number of times, results in:
 
 ## Debugging using Exceptions ##
 
-To get the call stack at the point where exception `e` was thrown use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
+To get the call stack at the point where exception `e` was raised use `mg.stack_exception(e)`. This allows you to graph the trace back for easier debugging, for example:
 
 ``` python
 import memory_graph as mg
-import traceback;
 
 def fun3():
     d = [0] * 3
     for i in range(4):
-        d[i] = i  # throws IndexError when i = 3
+        d[i] = i  # raises IndexError when i = 3
     
 def fun2():
     fun3()
@@ -579,19 +578,22 @@ def fun1():
 try:
     fun1()
 except Exception as e:
-    traceback.print_exc()           # print trace back
-    mg.show(mg.stack_exception(e))  # graph trace back
+    mg.show(mg.stack_exception(e)) # graph traceback
+    raise e                        # reraise to print traceback
 ```
 ```
 $ python exception_example.py
 Traceback (most recent call last):
-  File "exception_example.py", line 16, in <module>
+  File "/home/bterwijn/temp/e.py", line 18, in <module>
+    raise e                        # raise to print traceback
+    ^^^^^^^
+  File "/home/bterwijn/temp/e.py", line 15, in <module>
     fun1()
-  File "exception_example.py", line 13, in fun1
+  File "/home/bterwijn/temp/e.py", line 12, in fun1
     fun2()
-  File "exception_example.py", line 10, in fun2
+  File "/home/bterwijn/temp/e.py", line 9, in fun2
     fun3()
-  File "exception_example.py", line 7, in fun3
+  File "/home/bterwijn/temp/e.py", line 6, in fun3
     d[i] = i  # throws IndexError when i = 3
     ~^^^
 IndexError: list assignment index out of range
@@ -1033,6 +1035,48 @@ mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
 
 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_search.py&breakpoints=32&continues=1&timestep=0.5&play)
 
+## Collapse Type ##
+
+Sometimes a type has too many attributes or too many child nodes in the graph for it to stay readable. We use type 'MyClass' as an example here:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+mg.l()
+```
+![collapse_type1.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/collapse_type1.png)
+
+Then we can collapse this type with `mg.collapse_type(<type-name>)`. This simply sets `mg.config.type_to_node[<type-name>]` to an empty `Node_Linear` and `mg.config.type_to_color[<type-name>]` to a gray color, so that we don't introspect it's attributes which will also increase graph making performance:
+
+```python
+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)
+c = MyClass()
+d = (4, 5, 6, 7)
+
+# 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)
+
+Use `mg.reset_type(<type_name>)` to remove the `type_to_node` and `type_to_color` configuration for a type and restore it's default introspection.
+
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.69 → memory_graph-0.3.71}/pyproject.toml

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