memory-graph 0.3.82__tar.gz → 0.3.84__tar.gz

{memory_graph-0.3.82 → memory_graph-0.3.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.82
+Version: 0.3.84
 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
@@ -366,7 +366,7 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
-## Function Call That Changes 'int' Value ##
+## Function Call Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
 
 ```python
@@ -767,7 +767,58 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 # Control Flow #
 
-Some examples where we focus on the flow of control of Python code.
+Some examples where we focus on the flow of control and access to state in Python code.
+
+## Different Methods ##
+
+This example shows the difference between 'instance', 'class' and 'static' methods:
+
+```python
+class My_Class:
+
+    # class variables:
+    count = 0
+    unique_value = 0
+
+    def __init__(self):
+        print("__init__ called, initialize instance variables of object")
+        self.my_instance_variable = []  # create instance variable
+        My_Class.count += 1  # also change class variable
+
+    def my_instance_method(self):
+        print("my_instance_method called, access to instance variables via 'self'")
+        self.my_instance_variable.append(My_Class.unique_value)
+        My_Class.unique_value += 1  # also change class variable
+
+    @classmethod
+    def my_class_method(cls):
+        print("my_class_method called, access to class variables via 'cls', no instance variables")
+        print(f"{cls.count=}")
+
+    @staticmethod
+    def my_static_method():
+        print("my_static_method called, no 'self' or 'cls'")
+        print(f"{My_Class.count=}")  # but still access to class variables
+
+obj1 = My_Class()
+obj2 = My_Class()
+
+obj1.my_instance_method()
+obj1.my_class_method()
+obj1.my_static_method()
+
+for _ in range(2):
+    obj1.my_instance_method()
+    obj2.my_instance_method()
+
+print(f"{obj1.count=}")     # reading class variable if no instance variable found
+obj1.count = 100            # creating instance variable
+print(f"{obj1.count=}")     # now finding and reading instance variable
+print(f"{My_Class.count}")  # class variable still available via class name
+print(f"{obj2.count=}")     # obj2 still reads the class variable
+```
+
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/different_methods.py&play).
 
 ## Inheritance ##
 
@@ -1048,6 +1099,9 @@ Different aspects of memory_graph can be configured. The default configuration c
 
 ## Functions ##
 
+- **mg.layout(horizontal: bool = None)**
+  - Set graph layout to 'True' for horizontal, 'False' for vertical, or 'None' to toggle.
+
 - **mg.dark_mode(b: bool = None)**
   - Set dark mode to 'True' or 'False', or 'None' to toggle.
 
@@ -1301,6 +1355,8 @@ mg.show(locals())
 ```
 ![html_str_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/html_str_example.png)
 
+### Images
+
 Including the `<IMG>` tag that allows for showing local image files only, but that currently doesn't work in the Memory Graph Web Debugger, that uses 'Viz.js' for graph rendering, unfortunately.
 
 ```python

{memory_graph-0.3.82 → memory_graph-0.3.84}/README.md

@@ -346,7 +346,7 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
-## Function Call That Changes 'int' Value ##
+## Function Call Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
 
 ```python
@@ -747,7 +747,58 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 # Control Flow #
 
-Some examples where we focus on the flow of control of Python code.
+Some examples where we focus on the flow of control and access to state in Python code.
+
+## Different Methods ##
+
+This example shows the difference between 'instance', 'class' and 'static' methods:
+
+```python
+class My_Class:
+
+    # class variables:
+    count = 0
+    unique_value = 0
+
+    def __init__(self):
+        print("__init__ called, initialize instance variables of object")
+        self.my_instance_variable = []  # create instance variable
+        My_Class.count += 1  # also change class variable
+
+    def my_instance_method(self):
+        print("my_instance_method called, access to instance variables via 'self'")
+        self.my_instance_variable.append(My_Class.unique_value)
+        My_Class.unique_value += 1  # also change class variable
+
+    @classmethod
+    def my_class_method(cls):
+        print("my_class_method called, access to class variables via 'cls', no instance variables")
+        print(f"{cls.count=}")
+
+    @staticmethod
+    def my_static_method():
+        print("my_static_method called, no 'self' or 'cls'")
+        print(f"{My_Class.count=}")  # but still access to class variables
+
+obj1 = My_Class()
+obj2 = My_Class()
+
+obj1.my_instance_method()
+obj1.my_class_method()
+obj1.my_static_method()
+
+for _ in range(2):
+    obj1.my_instance_method()
+    obj2.my_instance_method()
+
+print(f"{obj1.count=}")     # reading class variable if no instance variable found
+obj1.count = 100            # creating instance variable
+print(f"{obj1.count=}")     # now finding and reading instance variable
+print(f"{My_Class.count}")  # class variable still available via class name
+print(f"{obj2.count=}")     # obj2 still reads the class variable
+```
+
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/different_methods.py&play).
 
 ## Inheritance ##
 
@@ -1028,6 +1079,9 @@ Different aspects of memory_graph can be configured. The default configuration c
 
 ## Functions ##
 
+- **mg.layout(horizontal: bool = None)**
+  - Set graph layout to 'True' for horizontal, 'False' for vertical, or 'None' to toggle.
+
 - **mg.dark_mode(b: bool = None)**
   - Set dark mode to 'True' or 'False', or 'None' to toggle.
 
@@ -1281,6 +1335,8 @@ mg.show(locals())
 ```
 ![html_str_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/html_str_example.png)
 
+### Images
+
 Including the `<IMG>` tag that allows for showing local image files only, but that currently doesn't work in the Memory Graph Web Debugger, that uses 'Viz.js' for graph rendering, unfortunately.
 
 ```python

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.82"
+__version__ = "0.3.84"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes
@@ -26,7 +26,7 @@ if not hasattr(builtins, "mg"):
     builtins.mg = mg
 
 # re-exports for shorter names
-from .config_default  import dark_mode, transparent_background, set_colors
+from .config_default  import layout, dark_mode, transparent_background, set_colors
 from .slicer          import Slicer
 from .node_leaf       import Node_Leaf
 from .node_linear     import Node_Linear

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/config.py

@@ -29,6 +29,7 @@ type_to_string = { }
 
 type_to_node = { }
 
+horizontal = False
 color_mode_dark = False
 transparent_background = False
 foreground_color = None

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/config_default.py

@@ -109,6 +109,12 @@ def dark_mode(dark = None):
         config.color_mode_dark = dark
     set_colors(config.color_mode_dark, config.transparent_background)
 
+def layout(horizontal = None):
+    if horizontal is None:
+        config.horizontal = not config.horizontal
+    else:
+        config.horizontal = horizontal
+
 def reset():
 
     set_colors(config.color_mode_dark, config.transparent_background)

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/html_table.py

@@ -6,11 +6,6 @@ import memory_graph.config as config
 import memory_graph.config_helpers as config_helpers
 import memory_graph.utils as utils
 
-def html_table_frame(s, border, color, line_color='black', spacing=5):
-    """ Helper function to add the HTML table frame to the string s setting the 'border' and 'color'. """
-    return (f'<\n<TABLE BORDER="{border}" CELLBORDER="1" CELLSPACING="{spacing}" CELLPADDING="0" BGCOLOR="{color}" COLOR="{line_color}" PORT="table">\n    <TR>' +
-            s + '</TR>\n</TABLE>\n>')
-
 def format_string(value, quote_str):
     """ 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)
@@ -30,7 +25,7 @@ class HTML_Table:
         """
         Create an HTML_Table object.
         """
-        self.html = ''
+        self.rows = [[]]
         self.add_new_line_flag = False
         self.is_empty = True
         self.col_count = 0
@@ -38,10 +33,24 @@ class HTML_Table:
         self.ref_count = 0
         self.max_col_count = 0
         self.edges = []
+        self.rows_reversed = False
+        self.columns_reversed = False
 
     def __repr__(self):
         """ Get the string representation of the HTML_Table object. """
-        return self.html
+        return str(self.rows)
+
+    def add_row(self):
+        self.rows.append([])
+
+    def add_column(self, s):
+        self.rows[-1].append(s)
+
+    def reverse_rows(self, reversed=True):
+        self.rows_reversed = reversed
+
+    def reverse_columns(self, reversed=True):
+        self.columns_reversed = reversed
 
     def add_new_line(self):
         """ Set the 'add_new_line_flag' to add a new line to the table when adding the next table element. """
@@ -54,13 +63,13 @@ class HTML_Table:
     def check_add_new_line(self):
         """ Check if a new line should be added to the table, and if so add it and sets the 'add_new_line_flag' to False."""
         if self.add_new_line_flag:
-            self.html += '</TR>\n    <TR>'
+            self.add_row()
             self.add_new_line_flag = False
 
     def add_index(self, s):
         """ Add an index s to the table. """
         self.check_add_new_line()
-        self.html += f'<TD BORDER="0"><font color="{config.index_color}">{str(s)}</font></TD>'
+        self.add_column(f'<TD BORDER="0"><font color="{config.index_color}">{str(s)}</font></TD>')
         self.col_count += 1
 
     def add_entry(self, node, nodes, child, id_to_slices, rounded=False, border=1, dashed=False, embed=False):
@@ -79,7 +88,7 @@ class HTML_Table:
         """ 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(value, not rounded)}</TD>'
+        self.add_column(f'<TD BORDER="{border}"{r}>{format_string(value, not rounded)}</TD>')
         self.is_empty = False
         self.col_count += 1
 
@@ -87,7 +96,7 @@ class HTML_Table:
         """ Helper function to add a reference to the table. """
         self.check_add_new_line()
         r = ' STYLE="ROUNDED"' if rounded else ''
-        self.html += f'<TD BORDER="{border}" PORT="ref{self.ref_count}"{r}> </TD>'
+        self.add_column(f'<TD BORDER="{border}" PORT="ref{self.ref_count}"{r}> </TD>')
         self.edges.append( (f'{node.get_name()}:ref{self.ref_count}',
                             child.get_name(), dashed) )
         self.ref_count += 1
@@ -97,17 +106,25 @@ class HTML_Table:
         """ Helper function to add dots to the table. """
         self.check_add_new_line()
         r = 'STYLE="ROUNDED"' if rounded else ''
-        self.html += f'<TD BORDER="{border}" {r}>...</TD>'
+        self.add_column(f'<TD BORDER="{border}" {r}>...</TD>')
         self.col_count += 1
 
+    def html_table_frame(self, border, color, line_color='black', spacing=5):
+        """ Helper function to add the HTML table frame to the string s setting the 'border' and 'color'. """
+        s = f'<\n<TABLE BORDER="{border}" CELLBORDER="1" CELLSPACING="{spacing}" CELLPADDING="0" BGCOLOR="{color}" COLOR="{line_color}" PORT="table">\n'
+        s += ''.join('<TR>' + ''.join(cell for cell in (reversed(row) if self.columns_reversed else row)) + '</TR>\n' 
+                for row in (reversed(self.rows) if self.rows_reversed else self.rows))
+        s += '</TABLE>\n>'
+        return s
+
     def to_string(self, border=1, color='white', line_color='black'):
         """ 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_value(utils.unquoted_str(''), border=0)
-            return html_table_frame(self.html, border, color, line_color, spacing=0)
-        return html_table_frame(self.html, border, color, line_color)
-    
+            return self.html_table_frame(border, color, line_color, spacing=0)
+        return self.html_table_frame(border, color, line_color)
+
     def get_column(self):
         """ Get the number of columns in the table. """
         return self.col_count
@@ -128,6 +145,7 @@ if __name__ == '__main__':
     table = HTML_Table()
     rows = 4
     columns = 5
+    #table.reverse_columns()
     for r in range(rows):
         for c in range(columns):
             table.add_value(f'{c},{r}')

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/memory_to_nodes.py

@@ -239,7 +239,8 @@ def build_graph(graphviz_graph, nodes, root_id, id_to_slices):
             if node_id in id_to_slices:
                 slices = id_to_slices[node_id]
                 if not slices is None:
-                    for index in slices:
+                    slices_iter = slices.reverse_iter() if config.horizontal else iter(slices)
+                    for index in slices_iter:
                         child_id = id(children[index])
                         build_graph_depth_first(graphviz_graph, nodes, child_id, id_to_slices, nodes_at_depth, subgraphed_nodes, depth+1)
             if not node.is_hidden_node():
@@ -268,5 +269,7 @@ def memory_to_nodes(data):
                                     graph_attr=graphviz_graph_attr,
                                     node_attr=graphviz_node_attr,
                                     edge_attr=graphviz_edge_attr)
+    if config.horizontal:
+        graphviz_graph.attr(rankdir='LR')
     build_graph(graphviz_graph, nodes, root_id, id_to_slices)
     return graphviz_graph

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/node_key_value.py

@@ -58,6 +58,10 @@ class Node_Key_Value(Node_Base):
         if slices is None:
             return
         vertical = self.is_vertical(nodes, slices, id_to_slices)
+        if config.horizontal:
+            vertical = not vertical
+            if vertical:
+                html_table.reverse_rows()
         if vertical:
             self.fill_html_table_vertical(html_table, nodes, slices, id_to_slices)
         else:

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/node_linear.py

@@ -49,7 +49,12 @@ class Node_Linear(Node_Base):
         """
         if slices is None:
             return
-        if self.is_vertical(nodes, slices, id_to_slices):
+        vertical = self.is_vertical(nodes, slices, id_to_slices)
+        if config.horizontal:
+            vertical = not vertical  # flip orientation if horizontal layout is set
+            if vertical:
+                html_table.reverse_rows()
+        if vertical:
             self.fill_html_table_vertical(html_table, nodes, slices, id_to_slices)
         else:
             self.fill_html_table_horizontal(html_table, nodes, slices, id_to_slices)

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/node_table.py

@@ -6,6 +6,7 @@ from memory_graph.node_base import Node_Base
 from memory_graph.sequence  import Sequence2D
 from memory_graph.list_view import List_View
 
+import memory_graph.config as config
 import memory_graph.utils as utils
 
 class Node_Table(Node_Base):
@@ -44,6 +45,9 @@ class Node_Table(Node_Base):
         children_width = children_size[1]
         col_slices = slices.get_col_slices()
 
+        if config.horizontal:
+            html_table.reverse_rows()
+
         # use column indices for header row
         html_table.add_value(utils.unquoted_str(''), border=0)
         for coli in col_slices.table_iter(children_width):

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/slices.py

@@ -107,6 +107,9 @@ class Slices1D(Slices):
     def __iter__(self):
         return Slices_Iterator1D(self)
 
+    def reverse_iter(self):
+        return Slices_Iterator1D(self, reverse=True)
+
     def has_index(self, index):
         insert = bisect.bisect_right([s[0] for s in self.slices], index)
         # print('insert:',insert,'index:',index,'slices:',self.slices)
@@ -150,6 +153,9 @@ class Slices2D(Slices):
     def __iter__(self):
         return Slices_Iterator2D(self)
 
+    def reverse_iter(self):
+        return Slices_Iterator2D(self, reverse=True)
+
     def has_index(self, index):
         i0, i1 = index
         return self.row_slices.has_index(i0) and self.col_slices.has_index(i1)

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph/slices_iterator.py

@@ -17,9 +17,9 @@ class Slices_Iterator(ABC):
 
 class Slices_Iterator1D(Slices_Iterator):
 
-    def __init__(self, slices1d):
+    def __init__(self, slices1d, reverse=False):
         self.slices = slices1d
-        self.gen = self.generate()
+        self.gen = self.reverse_generate() if reverse else self.generate()
 
     def __iter__(self):
         return self
@@ -30,14 +30,20 @@ class Slices_Iterator1D(Slices_Iterator):
             for i in range(slices[si][0], slices[si][1]):
                 yield i
 
+    def reverse_generate(self):
+        slices = self.slices.get_slices()
+        for si in range(len(slices)-1, -1, -1):
+            for i in range(slices[si][1]-1, slices[si][0]-1, -1):
+                yield i
+
     def __next__(self):
         return next(self.gen)
     
 class Slices_Iterator2D(Slices_Iterator):
 
-    def __init__(self, slices2d):
+    def __init__(self, slices2d, reverse=False):
         self.slices = slices2d
-        self.gen = self.generate()
+        self.gen = self.reverse_generate() if reverse else self.generate()
 
     def __iter__(self):
         return self
@@ -51,5 +57,14 @@ class Slices_Iterator2D(Slices_Iterator):
                     for col_i in range(col_slice[0], col_slice[1]):
                         yield (row_i, col_i)
 
+    def reverse_generate(self):
+        row_slices = self.slices.get_row_slices().get_slices()
+        col_slices = self.slices.get_col_slices().get_slices()
+        for row_slice in reversed(row_slices):
+            for row_i in range(row_slice[1]-1, row_slice[0]-1, -1):
+                for col_slice in reversed(col_slices):
+                    for col_i in range(col_slice[1]-1, col_slice[0]-1, -1):
+                        yield (row_i, col_i)
+
     def __next__(self):
         return next(self.gen)

{memory_graph-0.3.82 → memory_graph-0.3.84}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.82
+Version: 0.3.84
 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
@@ -366,7 +366,7 @@ a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
 This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
-## Function Call That Changes 'int' Value ##
+## Function Call Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
 
 ```python
@@ -767,7 +767,58 @@ A sliding puzzle solver as a challenging example showing how memory_graph deals
 
 # Control Flow #
 
-Some examples where we focus on the flow of control of Python code.
+Some examples where we focus on the flow of control and access to state in Python code.
+
+## Different Methods ##
+
+This example shows the difference between 'instance', 'class' and 'static' methods:
+
+```python
+class My_Class:
+
+    # class variables:
+    count = 0
+    unique_value = 0
+
+    def __init__(self):
+        print("__init__ called, initialize instance variables of object")
+        self.my_instance_variable = []  # create instance variable
+        My_Class.count += 1  # also change class variable
+
+    def my_instance_method(self):
+        print("my_instance_method called, access to instance variables via 'self'")
+        self.my_instance_variable.append(My_Class.unique_value)
+        My_Class.unique_value += 1  # also change class variable
+
+    @classmethod
+    def my_class_method(cls):
+        print("my_class_method called, access to class variables via 'cls', no instance variables")
+        print(f"{cls.count=}")
+
+    @staticmethod
+    def my_static_method():
+        print("my_static_method called, no 'self' or 'cls'")
+        print(f"{My_Class.count=}")  # but still access to class variables
+
+obj1 = My_Class()
+obj2 = My_Class()
+
+obj1.my_instance_method()
+obj1.my_class_method()
+obj1.my_static_method()
+
+for _ in range(2):
+    obj1.my_instance_method()
+    obj2.my_instance_method()
+
+print(f"{obj1.count=}")     # reading class variable if no instance variable found
+obj1.count = 100            # creating instance variable
+print(f"{obj1.count=}")     # now finding and reading instance variable
+print(f"{My_Class.count}")  # class variable still available via class name
+print(f"{obj2.count=}")     # obj2 still reads the class variable
+```
+
+Run it in the [Memory Graph Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/different_methods.py&play).
 
 ## Inheritance ##
 
@@ -1048,6 +1099,9 @@ Different aspects of memory_graph can be configured. The default configuration c
 
 ## Functions ##
 
+- **mg.layout(horizontal: bool = None)**
+  - Set graph layout to 'True' for horizontal, 'False' for vertical, or 'None' to toggle.
+
 - **mg.dark_mode(b: bool = None)**
   - Set dark mode to 'True' or 'False', or 'None' to toggle.
 
@@ -1301,6 +1355,8 @@ mg.show(locals())
 ```
 ![html_str_example.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/html_str_example.png)
 
+### Images
+
 Including the `<IMG>` tag that allows for showing local image files only, but that currently doesn't work in the Memory Graph Web Debugger, that uses 'Viz.js' for graph rendering, unfortunately.
 
 ```python

{memory_graph-0.3.82 → memory_graph-0.3.84}/pyproject.toml

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