memory-graph 0.3.55__tar.gz → 0.3.57__tar.gz

{memory_graph-0.3.55/memory_graph.egg-info → memory_graph-0.3.57}/PKG-INFO

@@ -1,34 +1,9 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.55
+Version: 0.3.57
 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: BSD 2-Clause License
-        
-        Copyright (c) 2017, pyexample
-        All rights reserved.
-        
-        Redistribution and use in source and binary forms, with or without
-        modification, are permitted provided that the following conditions are met:
-        
-        * Redistributions of source code must retain the above copyright notice, this
-          list of conditions and the following disclaimer.
-        
-        * Redistributions in binary form must reproduce the above copyright notice,
-          this list of conditions and the following disclaimer in the documentation
-          and/or other materials provided with the distribution.
-        
-        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-        
+License-Expression: BSD-2-Clause
 Project-URL: Homepage, https://github.com/bterwijn/memory_graph
 Project-URL: Repository, https://github.com/bterwijn/memory_graph.git
 Classifier: Development Status :: 4 - Beta
@@ -362,9 +337,33 @@ In the printed output only `a` is changed as a result of the function call:
 ```
 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 so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
+## Function Call That 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
+import memory_graph as mg
+
+def add_one(a, b):
+    a += 1     # change remains confined to 'a' in the add_one function
+    b[0] += 1  # change also effects 'b' outside of the add_one function
+    mg.show(mg.stack())
+
+a = 10
+b = [10]  # wrap in a value of mutable type list
+add_one(a, b)
+
+print(f"a:{a} b:{b[0]}")
+```
+![wap_int.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/wrap_int.png)
+```
+a:10 b:11
+```
+Calling `add_one()` does not effect the `int` value of `a` but does effect the `int` value of `b` because it's wrapped in a mutable container.
+
+## Exercises ##
+
 Now is a good time to practice the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
@@ -712,6 +711,12 @@ Different aspects of memory_graph can be configured. The default configuration c
 - ***mg.config.max_missing_edges*** : int
   - Maximum number of missing edges that are shown with default value 2. Dashed references are used to indicate that there are more references to a node than are shown.
 
+- ***mg.config.fontname*** : str
+  - The font used in the graph, default 'Courier' (as widely available monospace).
+
+- ***mg.config.fontsize*** : str
+  - The font size used in the graph, default '14'.
+
 
 ## Simplified Graph ##
 Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.

{memory_graph-0.3.55 → memory_graph-0.3.57}/README.md

@@ -317,9 +317,33 @@ In the printed output only `a` is changed as a result of the function call:
 ```
 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 so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
+## Function Call That 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
+import memory_graph as mg
+
+def add_one(a, b):
+    a += 1     # change remains confined to 'a' in the add_one function
+    b[0] += 1  # change also effects 'b' outside of the add_one function
+    mg.show(mg.stack())
+
+a = 10
+b = [10]  # wrap in a value of mutable type list
+add_one(a, b)
+
+print(f"a:{a} b:{b[0]}")
+```
+![wap_int.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/wrap_int.png)
+```
+a:10 b:11
+```
+Calling `add_one()` does not effect the `int` value of `a` but does effect the `int` value of `b` because it's wrapped in a mutable container.
+
+## Exercises ##
+
 Now is a good time to practice the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
@@ -667,6 +691,12 @@ Different aspects of memory_graph can be configured. The default configuration c
 - ***mg.config.max_missing_edges*** : int
   - Maximum number of missing edges that are shown with default value 2. Dashed references are used to indicate that there are more references to a node than are shown.
 
+- ***mg.config.fontname*** : str
+  - The font used in the graph, default 'Courier' (as widely available monospace).
+
+- ***mg.config.fontsize*** : str
+  - The font size used in the graph, default '14'.
+
 
 ## Simplified Graph ##
 Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.

{memory_graph-0.3.55 → memory_graph-0.3.57}/images/create_images.sh

@@ -16,6 +16,7 @@ python name_rebinding.py
 
 # call stack
 python add_one.py
+python wrap_int.py
 python factorial.py
 bash create_gif.sh factorial -d
 python binary.py

memory_graph-0.3.57/images/wrap_int.py

@@ -0,0 +1,16 @@
+# This file is part of memory_graph.
+# Copyright (c) 2023, Bas Terwijn.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import memory_graph as mg
+
+def add_one(a, b):
+    a += 1
+    b[0] += 1
+    mg.render( mg.stack(), "wrap_int.png")
+
+a = 10
+b = [10]
+
+add_one(a, b)
+print(f"a:{a} b:{b[0]}")

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph/__init__.py

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

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph/config.py

@@ -46,3 +46,6 @@ graph_cut_symbol = None
 max_missing_edges = None
 
 type_to_depth = { }
+
+fontname = 'Courier'
+fontsize = '14'

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph/config_default.py

@@ -129,5 +129,8 @@ def reset():
     """ Maximum number of missing edges that are shown. """
     config.max_missing_edges = 2
 
+    """ Font name and size used in the graph. """
+    config.fontname = 'Courier'
+    config.fontsize = '14'
 
 reset()

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph/memory_to_nodes.py

@@ -257,9 +257,9 @@ def memory_to_nodes(data):
     id_to_slices = add_missing_edges(nodes, id_to_slices, config.max_missing_edges)
     #print('id_to_slices:',id_to_slices)
     embed_keys_in_key_value_nodes(nodes, nodes_key_value, id_to_slices)
-    graphviz_graph_attr = {}
-    graphviz_node_attr = {'shape':'plaintext'}
-    graphviz_edge_attr = {}
+    graphviz_graph_attr = {'fontname': config.fontname, 'fontsize': config.fontsize}
+    graphviz_node_attr = {'fontname': config.fontname, 'fontsize': config.fontsize, 'shape': 'plaintext'}
+    graphviz_edge_attr = {'fontname': config.fontname, 'fontsize': config.fontsize}
     graphviz_graph=graphviz.Digraph('memory_graph',
                                     graph_attr=graphviz_graph_attr,
                                     node_attr=graphviz_node_attr,

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph/utils.py

@@ -20,7 +20,7 @@ def is_function(obj):
 
 def filter_dict(dictionary):
     """ Filters out the unwanted dict attributes. """
-    if '__name__' in dictionary: # only filter stack frames, for example locals()
+    if '__name__' in dictionary: # filter stack frames in global scope
         return [
             (k,v) for k, v in dictionary.items() if
             not (type(k) is str and k.startswith('__')) and

{memory_graph-0.3.55 → memory_graph-0.3.57/memory_graph.egg-info}/PKG-INFO

@@ -1,34 +1,9 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.55
+Version: 0.3.57
 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: BSD 2-Clause License
-        
-        Copyright (c) 2017, pyexample
-        All rights reserved.
-        
-        Redistribution and use in source and binary forms, with or without
-        modification, are permitted provided that the following conditions are met:
-        
-        * Redistributions of source code must retain the above copyright notice, this
-          list of conditions and the following disclaimer.
-        
-        * Redistributions in binary form must reproduce the above copyright notice,
-          this list of conditions and the following disclaimer in the documentation
-          and/or other materials provided with the distribution.
-        
-        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-        
+License-Expression: BSD-2-Clause
 Project-URL: Homepage, https://github.com/bterwijn/memory_graph
 Project-URL: Repository, https://github.com/bterwijn/memory_graph.git
 Classifier: Development Status :: 4 - Beta
@@ -362,9 +337,33 @@ In the printed output only `a` is changed as a result of the function call:
 ```
 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 so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
 
+## Function Call That 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
+import memory_graph as mg
+
+def add_one(a, b):
+    a += 1     # change remains confined to 'a' in the add_one function
+    b[0] += 1  # change also effects 'b' outside of the add_one function
+    mg.show(mg.stack())
+
+a = 10
+b = [10]  # wrap in a value of mutable type list
+add_one(a, b)
+
+print(f"a:{a} b:{b[0]}")
+```
+![wap_int.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/wrap_int.png)
+```
+a:10 b:11
+```
+Calling `add_one()` does not effect the `int` value of `a` but does effect the `int` value of `b` because it's wrapped in a mutable container.
+
+## Exercises ##
+
 Now is a good time to practice the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
@@ -712,6 +711,12 @@ Different aspects of memory_graph can be configured. The default configuration c
 - ***mg.config.max_missing_edges*** : int
   - Maximum number of missing edges that are shown with default value 2. Dashed references are used to indicate that there are more references to a node than are shown.
 
+- ***mg.config.fontname*** : str
+  - The font used in the graph, default 'Courier' (as widely available monospace).
+
+- ***mg.config.fontsize*** : str
+  - The font size used in the graph, default '14'.
+
 
 ## Simplified Graph ##
 Memory_graph simplifies the visualization (and the viewer's mental model) by **not** showing separate nodes for immutable types like `bool`, `int`, `float`, `complex`, and `str` by default. This simplification can sometimes be slightly misleading. As in the example below, after a shallow copy, lists `a` and `b` technically share their `int` values, but the graph makes it appear as though `a` and `b` each have their own copies. However, since `int` is immutable, this simplification will never lead to unexpected changes (changing `a` won’t affect `b`) so will never result in bugs.

{memory_graph-0.3.55 → memory_graph-0.3.57}/memory_graph.egg-info/SOURCES.txt

@@ -74,6 +74,8 @@ images/rebinding1.png
 images/rebinding2.png
 images/uva.png
 images/vscode_copying.gif
+images/wrap_int.png
+images/wrap_int.py
 memory_graph/__init__.py
 memory_graph/call_stack.py
 memory_graph/config.py

{memory_graph-0.3.55 → memory_graph-0.3.57}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.55"
+version = "0.3.57"
 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"}
 ]
-#license = { text = "BSD-2-Clause" } # needed for python <=3.8
-license = { file = "LICENSE.txt" }
+license = "BSD-2-Clause"
+license-files = ["LICENSE.txt"]
 readme = "README.md"
 requires-python = ">=3.7"
 classifiers = [