memory-graph 0.3.83__tar.gz → 0.3.85__tar.gz

{memory_graph-0.3.83 → memory_graph-0.3.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.83
+Version: 0.3.85
 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

{memory_graph-0.3.83 → memory_graph-0.3.85}/memory_graph/__init__.py

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

{memory_graph-0.3.83 → memory_graph-0.3.85}/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.83 → memory_graph-0.3.85}/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,6 +269,7 @@ def memory_to_nodes(data):
                                     graph_attr=graphviz_graph_attr,
                                     node_attr=graphviz_node_attr,
                                     edge_attr=graphviz_edge_attr)
-    graphviz_graph.attr(rankdir= "LR" if config.horizontal else "TB")
+    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.83 → memory_graph-0.3.85}/memory_graph/node_key_value.py

@@ -60,6 +60,8 @@ class Node_Key_Value(Node_Base):
         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.83 → memory_graph-0.3.85}/memory_graph/node_linear.py

@@ -52,6 +52,8 @@ class Node_Linear(Node_Base):
         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:

{memory_graph-0.3.83 → memory_graph-0.3.85}/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,10 @@ class Node_Table(Node_Base):
         children_width = children_size[1]
         col_slices = slices.get_col_slices()
 
+        # Better keep a table in normal order, I think
+        #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.83 → memory_graph-0.3.85}/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.83 → memory_graph-0.3.85}/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.83 → memory_graph-0.3.85}/memory_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.83
+Version: 0.3.85
 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

{memory_graph-0.3.83 → memory_graph-0.3.85}/pyproject.toml

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