memory-graph 0.3.75__tar.gz → 0.3.77__tar.gz

{memory_graph-0.3.75 → memory_graph-0.3.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.75
+Version: 0.3.77
 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
@@ -1245,7 +1245,7 @@ Arguably the visualization is then more clear when we show a List_View object as
 
 ```python
 mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
-    [v if l.begin <= i < l.end else '' for i, v in enumerate(l.lst)]
+    [v if l.begin <= i < l.end else mg.unquoted('') for i, v in enumerate(l.lst)]
     if hasattr(l, 'end') else [])
 )
 ```

{memory_graph-0.3.75 → memory_graph-0.3.77}/README.md

@@ -1225,7 +1225,7 @@ Arguably the visualization is then more clear when we show a List_View object as
 
 ```python
 mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
-    [v if l.begin <= i < l.end else '' for i, v in enumerate(l.lst)]
+    [v if l.begin <= i < l.end else mg.unquoted('') for i, v in enumerate(l.lst)]
     if hasattr(l, 'end') else [])
 )
 ```

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.75"
+__version__ = "0.3.77"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes
@@ -31,7 +31,7 @@ from .node_leaf       import Node_Leaf
 from .node_linear     import Node_Linear
 from .node_key_value  import Node_Key_Value
 from .node_table      import Node_Table
-
+from .utils           import unquoted_str, full_str, html_str
 
 last_show_filename = None
 render_filename_count = 0

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/config_default.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 """ Sets the default configuration values for the memory graph. """
+from memory_graph.utils          import unquoted_str, full_str, html_str
 from memory_graph.node_leaf      import Node_Leaf
 from memory_graph.node_linear    import Node_Linear
 from memory_graph.node_key_value import Node_Key_Value
@@ -41,7 +42,7 @@ def reset():
 
     """ Types that by default will be embedded in the node of their parent. """
     config.embedded_types = {
-        type(None), bool, int, float, complex, str,
+        type(None), bool, int, float, complex, str, unquoted_str, html_str,
         types.FunctionType,
         types.MethodType,
         classmethod,
@@ -60,12 +61,15 @@ def reset():
 
     """ Types that need a special conversion """
     config.type_to_string = {
-        types.FunctionType: lambda data: utils.limit_string(data.__qualname__),
-        types.MethodType: lambda data: utils.limit_string(data.__qualname__),
-        classmethod: lambda data: utils.limit_string(data.__qualname__),
-        staticmethod: lambda data: utils.limit_string(data.__qualname__),
-        type(len): lambda data: utils.limit_string(data.__qualname__),
-        BaseException: lambda data: utils.exception_to_string(data),
+        types.FunctionType: lambda data: utils.prep_str(data.__qualname__),
+        types.MethodType: lambda data: utils.prep_str(data.__qualname__),
+        classmethod: lambda data: utils.prep_str(data.__qualname__),
+        staticmethod: lambda data: utils.prep_str(data.__qualname__),
+        type(len): lambda data: utils.prep_str(data.__qualname__),
+        BaseException: lambda data: utils.prep_exception_str(utils.exception_to_string(data)),
+        unquoted_str: lambda data: utils.newlines_to_br(utils.html_escape(str(data))),
+        full_str: lambda data: utils.newlines_to_br(utils.html_escape(str(data))),
+        html_str: lambda data: str(data),
     }
     
     """ Conversion from type to Node objects. """

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/config_helpers.py

@@ -25,6 +25,22 @@ def get_data_to_node(data, default=None):
                         config.type_to_node, 
                         default )
 
+def is_property(data_id, data_types, node_type, types_set):
+    if data_id in types_set:
+        return True
+    for data_type in data_types:
+        if data_type in types_set:
+            return True
+    if node_type in types_set:
+        return True
+    return False
+
+def is_embedded_type(data):
+    return is_property(id(data),
+                       utils.get_all_types(data),
+                       None,
+                       config.embedded_types )
+
 def default_to_string(data):
     """ Convert data to string. """
     try:
@@ -32,11 +48,13 @@ def default_to_string(data):
             s = data
         else:
             s = str(data)
-        return utils.limit_string(s)
+        return 
     except Exception as e:
-        return f'no stringification, {type(e).__name__}: {e}'
+        s = 'no stringification, '+ type(e).__name__ +': '+ str(e)
+    finally:
+        return utils.prep_str(s)
 
-def get_to_string(data, default=lambda s: default_to_string(s)):
+def get_to_string(data, default=lambda d: default_to_string(d)):
     return get_property(id(data),
                         utils.get_all_types(data),
                         None,

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/html_table.py

@@ -2,22 +2,22 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-from memory_graph.node_base import Node_Base 
-import memory_graph.node_base
 import memory_graph.config as config
 import memory_graph.config_helpers as config_helpers
-import html
+import memory_graph.utils as utils
 
 def html_table_frame(s, border, color, 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}" PORT="table">\n    <TR>' +
             s + '</TR>\n</TABLE>\n>')
 
-def format_string(value):
+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)
-    s = html.escape(to_string(value))
-    return s.replace('\n', ' <BR/> ')
+    s = to_string(value)
+    if quote_str and isinstance(value, str) or isinstance(value, utils.full_str):
+        s = utils.quote_string(s)
+    return s
 
 class HTML_Table:
     """
@@ -69,7 +69,7 @@ class HTML_Table:
             if child_id in id_to_slices:
                 self.add_reference(node, child, rounded, border, dashed)
             else:
-                self.add_value(config.graph_cut_symbol, rounded, border)
+                self.add_value(utils.unquoted_str(config.graph_cut_symbol), rounded, border)
         else:
             self.add_value(child, rounded, border)
 
@@ -77,7 +77,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)} </TD>'
+        self.html += f'<TD BORDER="{border}"{r}> {format_string(value, not rounded)} </TD>'
         self.is_empty = False
         self.col_count += 1
 
@@ -102,7 +102,7 @@ class HTML_Table:
         """ 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('', border=0)
+                self.add_value(utils.unquoted_str(''), border=0)
             return html_table_frame(self.html, border, color, spacing=0)
         return html_table_frame(self.html, border, color)
     

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/memory_to_nodes.py

@@ -36,8 +36,7 @@ def read_nodes(data):
         """ Recursively reads through each reference found in 'data', creates a node for
         it and adds, and adds it to 'nodes'.
         """
-        data_type = type(data)
-        if not data_type in config.embedded_types or parent is None:
+        if not config_helpers.is_embedded_type(data) or parent is None:
             data_id = id(data)
             if data_id in nodes:
                 node = nodes[data_id]

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/node_linear.py

@@ -7,6 +7,7 @@ from memory_graph.sequence import Sequence1D
 
 import memory_graph.config_helpers as config_helpers
 import memory_graph.config as config
+import memory_graph.utils as utils
 
 class Node_Linear(Node_Base):
     """
@@ -66,7 +67,7 @@ class Node_Linear(Node_Base):
                 html_table.add_entry(self, nodes, child, id_to_slices, dashed=slices.is_dashed(index))
                 html_table.add_new_line()
             else:
-                html_table.add_value('', border=0)
+                html_table.add_value(utils.unquoted_str(''), border=0)
                 html_table.add_dots()
                 html_table.add_new_line()
 
@@ -80,7 +81,7 @@ class Node_Linear(Node_Base):
                 if index>=0:
                     html_table.add_index(index)
                 else:
-                    html_table.add_value('', border=0)
+                    html_table.add_value(utils.unquoted_str(''), border=0)
             html_table.add_new_line()
         for index in slices.table_iter(self.children.size()):
             if index>=0:

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/node_table.py

@@ -3,9 +3,11 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 from memory_graph.node_base import Node_Base
-from memory_graph.sequence import Sequence2D
+from memory_graph.sequence  import Sequence2D
 from memory_graph.list_view import List_View
 
+import memory_graph.utils as utils
+
 class Node_Table(Node_Base):
     """
     Node_Table (subclass of Node_Base) is a node that represents a 2D table of data used for 
@@ -43,10 +45,10 @@ class Node_Table(Node_Base):
         col_slices = slices.get_col_slices()
 
         # use column indices for header row
-        html_table.add_value('', border=0)
+        html_table.add_value(utils.unquoted_str(''), border=0)
         for coli in col_slices.table_iter(children_width):
             if coli == -1:
-                html_table.add_value('', border=0)
+                html_table.add_value(utils.unquoted_str(''), border=0)
             else:
                 self.add_index_or_name(html_table, coli, self.col_names)
         html_table.add_new_line()
@@ -65,7 +67,7 @@ class Node_Table(Node_Base):
                 first_col = True
             elif coli == -3:
                 html_table.add_new_line()
-                html_table.add_value('', border=0)
+                html_table.add_value(utils.unquoted_str(''), border=0)
                 for _ in range (html_table.get_max_column()-1):
                     html_table.add_dots()
                 html_table.add_new_line()

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph/utils.py

@@ -7,15 +7,47 @@ import types
 import functools
 import traceback
 import re
+import html
 
 import memory_graph.config as config
 
+class Base_Str():
+    def __init__(self, s):
+        self.s = s
+    def __str__(self):
+        return self.s
+    
+class unquoted_str(Base_Str):
+    pass
+    
+class full_str(Base_Str):
+    pass 
+
+class html_str(Base_Str):
+    pass
+
 def limit_string(s):
-    """ Helper function to limit the length of a string s to the 'max_string_length' in the config. """
+    """ Limit the length of a string s to the 'max_string_length' in the config. """
     if len(s) > config.max_string_length:
         return s[:config.max_string_length] + '...'
     return s
 
+def html_escape(s):
+    """ Escape HTML characters in 's' for safe display in the graph. """
+    return html.escape(s)
+
+def newlines_to_br(s):
+    """ Replace newlines in 's' with <BR/> tags for HTML display. """
+    return s.replace('\n', ' <BR/> ')
+
+def prep_str(s):
+    """ Prepare 's' by limiting length, escaping HTML, and replacing newlines. """
+    return newlines_to_br(html_escape(limit_string(s)))
+
+def quote_string(s):
+    """ Quote 's' if it is a string. """
+    return "'" + s + "'"
+
 def exception_to_string(e):
     """ Helper function to convert the traceback of an exception to a string. """
     return ''.join(traceback.format_exception(type(e), e, e.__traceback__)).strip()
@@ -24,9 +56,14 @@ def exception_to_string_no_path(e):
     """ Helper function to convert the traceback of an exception to a string without file paths. """
     s = exception_to_string(e)
     # Convert traceback file paths like File "/a/b/c.py" to File "c.py".
+    def _strip_path(match):
+        file_path = match.group(2).replace('\\', '/')  # for Windows paths
+        file_name = file_path.rsplit('/', 1)[-1]
+        return f'{match.group(1)}{file_name}{match.group(3)}'
+
     return re.sub(
         r'(^\s*File ")(.*?)(")',
-        lambda m: f'{m.group(1)}{m.group(2).replace("\\", "/").rsplit("/", 1)[-1]}{m.group(3)}',
+        _strip_path,
         s,
         flags=re.MULTILINE,
     )
@@ -35,6 +72,23 @@ def exception_to_string_short(e):
     """ Helper function to convert an exception to a short string. """
     return f'{type(e).__name__}: {e}'
 
+def mono_font(s):
+    """ Helper function to wrap in monospaced font. """
+    return f'<FONT FACE="Courier">{s}</FONT>'
+
+def caret_line_length(s):
+    """ Adds whitespace to caret line in 's' so it is as long as the previois line. """
+    lines = s.split('\n')
+    for i in range(len(lines)-2, -1, -1):
+        if re.fullmatch(r'\s*~*\^+\s*', lines[i]):  # match line like '  ~~~^^ '
+            lines[i] = lines[i].ljust(len(lines[i - 1]))
+            break
+    return '\n'.join(lines)
+
+def prep_exception_str(s):
+    """ Helper function to prepare an exception string for HTML display. """
+    return newlines_to_br(mono_font(html_escape(caret_line_length(s))))
+
 def get_all_types(obj):
     cls = type(obj)
     if hasattr(cls, '__mro__'):

{memory_graph-0.3.75 → memory_graph-0.3.77}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.75
+Version: 0.3.77
 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
@@ -1245,7 +1245,7 @@ Arguably the visualization is then more clear when we show a List_View object as
 
 ```python
 mg.config.type_to_node[List_View] = (lambda l: mg.Node_Linear(l,
-    [v if l.begin <= i < l.end else '' for i, v in enumerate(l.lst)]
+    [v if l.begin <= i < l.end else mg.unquoted('') for i, v in enumerate(l.lst)]
     if hasattr(l, 'end') else [])
 )
 ```

{memory_graph-0.3.75 → memory_graph-0.3.77}/pyproject.toml

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