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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.55
+Version: 0.3.56
 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
@@ -362,9 +362,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 ##

{memory_graph-0.3.55 → memory_graph-0.3.56}/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 ##

{memory_graph-0.3.55 → memory_graph-0.3.56}/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.56/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.56}/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.56"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes

{memory_graph-0.3.55 → memory_graph-0.3.56}/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': 'Courier', 'fontsize': '14'}
+    graphviz_node_attr = {'fontname': 'Courier', 'fontsize': '14', 'shape': 'plaintext'}
+    graphviz_edge_attr = {'fontname': 'Courier', 'fontsize': '14'}
     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.56}/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.56/memory_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.55
+Version: 0.3.56
 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
@@ -362,9 +362,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 ##

{memory_graph-0.3.55 → memory_graph-0.3.56}/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.56}/pyproject.toml

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