bug fix and refactoring

Author: leila79

python/layout_visualizer.py

@@ -1,15 +1,15 @@
 from graphviz import Digraph
 import json
+from typing import Optional
 import argparse
 
-def tree_visualizer(json_path: str, output_path: str = "logs/layout_tree", format: str = "png"):
-    print(output_path, format)
-    with open(json_path, 'r', encoding='utf-8') as f:
-        data = json.load(f)
+def visualize_layout_tree(data, output_path: str = "-", format: str = "png") -> Optional[str]:
+    if isinstance(data, str):
+        data = json.load(data)
 
     tree = data['final_tree']
 
-    dot = Digraph('LayoutTree', filename=output_path, format=format)
+    dot = Digraph('LayoutTree', filename='layout_tree' if output_path == '-' else output_path, format=format)
     dot.attr("node", shape="box", fontname="Arial", fontsize="10")
 
     def add_node(node):
@@ -19,29 +19,43 @@ def add_node(node):
         label += f'dir={node.get("direction", "-")}\n'
         label += f'size=({node["size"]["w"]}×{node["size"]["h"]})\n'
         label += f'pos=({node["position"]["x"]},{node["position"]["y"]})'
+        color = node.get("color", "#dddddd")
         if node["type"] == "Text":
             txt = node.get("text_preview", "")
             preview = (txt[:20] + "…") if len(txt) > 20 else txt
             label += f'\n"{preview}"'
-        color = node.get("backgroundColor", "#dddddd")
+            color = "#dddddd"
         dot.node(nid, label, style="filled", fillcolor=color)
         for c in node.get("children", []):
             cid = str(c["node_id"])
             dot.edge(nid, cid)
             add_node(c)
     add_node(tree)
-    dot.render(cleanup=True)
-    print(f"[✓] Layout tree rendered to {output_path}.{format}")
+    if output_path == '-':
+        return dot.source
+    else:
+        dot.render(cleanup=True)
+        print(f"[✓] Layout tree rendered to {output_path}.{format}")
+        return None
+       
+
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Visualize layout tree from a layout JSON file.")
-    parser.add_argument("--in", dest="input", required=True,
+    parser.add_argument("input",
                         help="Input JSON layout log (e.g., logs/layout-log.json)")
-    parser.add_argument("--out", dest="output", default="layout_tree",
-                        help="Output file path without extension (default: layout_tree)")
+    parser.add_argument("-o", "--out", default='-',
+                        help="Output file path or '-' for stdout (default: '-')")
     parser.add_argument("--format", default="png", choices=["png", "svg", "pdf"],
                         help="Output format (default: png)")
 
     args = parser.parse_args()
-
-    tree_visualizer(json_path=args.input)
+    try:
+        with open(args.input, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        data = args.input
+    
+    result = visualize_layout_tree(data, args.out, args.format)
+    if result:
+        print(result)

python/rlc/layout.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import Optional, Tuple, List
 import copy
 # //utility for dumping layout
 
@@ -12,17 +13,17 @@ class SizePolicies(Enum):
     GROW = "grow"
 
 class SizePolicy:
-    def __init__(self, mode, value=None):
-        self.mode = mode
-        self.value = value
-    def __repr__(self):
-        return f"{self.mode}({self.value})" if self.value is not None else self.mode
+    def __init__(self, size_policy: SizePolicies, value: Optional[float] = None):
+        self.size_policy = size_policy
+        self.value : Optional[int] = value
+    def __repr__(self) -> str:
+        return f"{self.size_policy.value}({self.value})" if self.value is not None else self.size_policy.value
 
-def FIXED(value):
+def FIXED(value) -> SizePolicy:
     return SizePolicy(SizePolicies.FIXED, value)
-def FIT():
+def FIT() -> SizePolicy:
     return SizePolicy(SizePolicies.FIT, 0)
-def GROW():
+def GROW() -> SizePolicy:
     return SizePolicy(SizePolicies.GROW, 0)
 
 class Padding:
@@ -34,27 +35,33 @@ def __init__(self, top=0, bottom=0, left=0, right=0):
 
 
 class Layout:
-    def __init__(self, backgroundColor="white", sizing=(FIT(), FIT()), padding=Padding(0, 0, 0, 0), direction=Direction.ROW, child_gap=0):
-        self.sizing = sizing
-        self.backgroundColor = backgroundColor
-        self.direction = direction
-        self.child_gap = child_gap
-        self.padding = padding
-        self.children = []
+    def __init__(
+            self, 
+            sizing : Tuple[SizePolicy, SizePolicy] = (FIT(), FIT()), 
+            padding : Padding = Padding(0, 0, 0, 0),
+            direction : Direction = Direction.ROW,
+            child_gap : float = 0,
+            color: Optional[str] = None):
+        self.sizing : Tuple[SizePolicy, SizePolicy] = sizing
+        self.direction : Direction = direction
+        self.child_gap : float = child_gap
+        self.padding : Padding = padding
+        self.color: Optional[str] = color
+        self.children : List['Layout'] = []
         self.x = 0
         self.y = 0
-        self.width = sizing[0].value if sizing[0].mode == SizePolicies.FIXED else 0
-        self.height = sizing[1].value if sizing[1].mode == SizePolicies.FIXED else 0    
+        self.width = sizing[0].value if sizing[0].size_policy == SizePolicies.FIXED else 0
+        self.height = sizing[1].value if sizing[1].size_policy == SizePolicies.FIXED else 0    
 
-    def add_child(self, child):
-        self.children.append(child)
+    def add_child(self, child: 'Layout') -> None:
+        self.children.append(copy.deepcopy(child))
 
-    def _inner_dims(self):
+    def _inner_dims(self) -> Tuple[float, float]:
         iw = max(0, self.width - self.padding.left - self.padding.right)
         ih = max(0, self.height - self.padding.top - self.padding.bottom)
         return iw, ih
 
-    def child_size(self,logger=None):
+    def child_size(self,logger: Optional['LayoutLogger'] = None) -> None:
         # Always size children — even if self has fixed size
         inner_available_width = self.width - self.padding.left - self.padding.right
         inner_available_height = self.height - self.padding.top - self.padding.bottom
@@ -63,17 +70,17 @@ def child_size(self,logger=None):
             child_width_policy, child_height_policy = child.sizing
             # Only pass constraints if needed
             child_width = (
-                inner_available_width if child_width_policy.mode != SizePolicies.FIXED else child_width_policy.value
+                inner_available_width if child_width_policy.size_policy != SizePolicies.FIXED else child_width_policy.value
             )
             child_height = (
-                inner_available_height if child_height_policy.mode != SizePolicies.FIXED else child_height_policy.value
+                inner_available_height if child_height_policy.size_policy != SizePolicies.FIXED else child_height_policy.value
             )
             child.compute_size(child_width, child_height,logger)
 
 
      # Sizing  
 
-    def compute_size(self, available_width=None, available_height=None, logger=None):
+    def compute_size(self, available_width=None, available_height=None, logger: Optional['LayoutLogger']=None) -> None:
         if logger: logger.snapshot(self, "before_compute")
         if self.direction == Direction.ROW:
             self._compute_width()
@@ -91,25 +98,21 @@ def compute_size(self, available_width=None, available_height=None, logger=None)
             self._compute_grow_width()
         if logger: logger.snapshot(self, "after_compute")
 
-    def _compute_width(self):
+    def _compute_width(self) -> None:
         width_policy, _ = self.sizing
-        if width_policy.mode == SizePolicies.FIXED:
+        if width_policy.size_policy == SizePolicies.FIXED:
             self.width = width_policy.value
-        elif width_policy.mode == SizePolicies.FIT: 
-            self.width = self._compute_fit_width()
-        # elif width_policy.mode == SizePolicies.GROW:
-        #     self.width = 0        
+        elif width_policy.size_policy == SizePolicies.FIT: 
+            self.width = self._compute_fit_width()       
 
-    def _compute_height(self):
+    def _compute_height(self) -> None:
         _, height_policy = self.sizing
-        if height_policy.mode == SizePolicies.FIXED:
+        if height_policy.size_policy == SizePolicies.FIXED:
             self.height = height_policy.value
-        elif height_policy.mode == SizePolicies.FIT:
+        elif height_policy.size_policy == SizePolicies.FIT:
             self.height = self._compute_fit_height()
-        # elif height_policy.mode == SizePolicies.GROW:
-        #     self.height = 0
 
-    def _compute_fit_width(self):
+    def _compute_fit_width(self) -> float:
         self.child_size()
         if self.direction == Direction.ROW:
             content_width = sum(c.width for c in self.children)
@@ -120,7 +123,7 @@ def _compute_fit_width(self):
 
         return content_width + self.padding.left + self.padding.right
 
-    def _compute_fit_height(self):
+    def _compute_fit_height(self) -> float:
         self.child_size()
         if self.direction == Direction.COLUMN:
             content_height = sum(c.height for c in self.children)
@@ -131,10 +134,10 @@ def _compute_fit_height(self):
 
         return content_height + self.padding.top + self.padding.bottom
 
-    def _compute_grow_width(self):
+    def _compute_grow_width(self) -> None:
         if self.direction == Direction.ROW:
             # Horizontal GROW
-            total_fixed_width = sum(child.width for child in self.children if child.sizing[0].mode != SizePolicies.GROW)
+            total_fixed_width = sum(child.width for child in self.children if child.sizing[0].size_policy != SizePolicies.GROW)
             total_gap = (len(self.children) - 1) * self.child_gap
             remaining_width = self.width - self.padding.left - self.padding.right - total_fixed_width - total_gap
             self._grow_children_evenly(self.children, remaining_width, axis=0)
@@ -143,26 +146,26 @@ def _compute_grow_width(self):
             # cross-axis GROW
             remaining_width = self.width - self.padding.left - self.padding.right
             for child in self.children:
-                if child.sizing[0].mode == SizePolicies.GROW:
+                if child.sizing[0].size_policy == SizePolicies.GROW:
                     child.width = remaining_width 
 
-    def _compute_grow_height(self):
+    def _compute_grow_height(self) -> None:
         if self.direction == Direction.ROW:
             # cross-axis GROW
             remaining_height = self.height - self.padding.top - self.padding.bottom
             for child in self.children:
-                if child.sizing[1].mode == SizePolicies.GROW:
+                if child.sizing[1].size_policy == SizePolicies.GROW:
                     child.height = remaining_height 
 
         if self.direction == Direction.COLUMN:
             # Vertical GROW
-            total_fixed_height = sum(child.height for child in self.children if child.sizing[1].mode != SizePolicies.GROW)
+            total_fixed_height = sum(child.height for child in self.children if child.sizing[1].size_policy != SizePolicies.GROW)
             total_gap = self.child_gap * (len(self.children) - 1)
             remaining_height = self.height - self.padding.top - self.padding.bottom - total_fixed_height - total_gap
             self._grow_children_evenly(self.children, remaining_height, axis=1)
 
-    def _grow_children_evenly(self, children, remaining, axis):
-        growable = [c for c in children if c.sizing[axis].mode == SizePolicies.GROW]
+    def _grow_children_evenly(self, children: List['Layout'], remaining: float, axis: int):
+        growable = [c for c in children if c.sizing[axis].size_policy == SizePolicies.GROW]
         while growable and remaining > 0:
             growable.sort(key=lambda c: c.width if axis == 0 else c.height)
             smallest = growable[0]
@@ -192,7 +195,7 @@ def _grow_children_evenly(self, children, remaining, axis):
                     c.height += grow_amount
                 remaining -= grow_amount
             growable = [c for c in growable if (c.width if axis == 0 else c.height) < second_smallest]
-        shrinkable = [c for c in children if c.sizing[axis].mode != SizePolicies.FIXED]
+        shrinkable = [c for c in children if c.sizing[axis].size_policy != SizePolicies.FIXED]
         while shrinkable and remaining < 0:
             shrinkable.sort(key=lambda c: c.width if axis == 0 else c.height, reverse=True)
             largest = shrinkable[0]
@@ -227,7 +230,7 @@ def _grow_children_evenly(self, children, remaining, axis):
             shrinkable = [c for c in shrinkable if (c.width if axis == 0 else c.height) > second_largest_val]
 
     # Position
-    def layout(self, x=0, y=0, logger=None):
+    def layout(self, x: int=0, y: int=0, logger: Optional['LayoutLogger']=None) -> None:
         self.x = x
         self.y = y
         if logger: logger.snapshot(self, "before_layout")
@@ -237,22 +240,38 @@ def layout(self, x=0, y=0, logger=None):
             self._layout_column_children()
         if logger: logger.snapshot(self, "after_layout")
 
-    def _layout_row_children(self):
+    def _layout_row_children(self) -> None:
         left_offset = self.padding.left
         for child in self.children:
             child_pos_x = self.x + left_offset
             child_pos_y =  self.y + self.padding.top
             child.layout(child_pos_x, child_pos_y)
             left_offset += child.width + self.child_gap
 
-    def _layout_column_children(self):
+    def _layout_column_children(self) -> None:
         top_offset = self.padding.top
         for child in self.children:
             child_pos_x = self.x + self.padding.left
             child_pos_y = self.y + top_offset
             child.layout(child_pos_x, child_pos_y)
             top_offset += child.height + self.child_gap
 
+    def to_dot(self, dot: 'Diagraph', logger: Optional['LayoutLogger'] = None):
+        """Generate Graphviz DOT representation for this node and its children."""
+        from graphviz import Digraph
+        nid = str(logger._attach_id(self) if logger else id(self))
+        label = f'{self.__class__.__name__}#{nid}\n'
+        label += f'{self.sizing[0].size_policy.value}×{self.sizing[1].size_policy.value}\n'
+        label += f'dir={self.direction.value if self.direction else "-"}\n'
+        label += f'size=({self.width}×{self.height})\n'
+        label += f'pos=({self.x},{self.y})'
+        color = self.color if self.color else "#dddddd"
+        dot.node(nid, label, style="filled", fillcolor=color)
+        for child in self.children:
+            child_nid = child.to_dot(dot, logger)
+            dot.edge(nid, child_nid)
+        return nid
+
 
 
 

python/rlc/layout_logger.py

@@ -34,6 +34,9 @@ def __del__(self):
             pass
 
     def _attach_id(self, node) -> int:
+        # Reset _log_node_id for copied nodes to ensure unique IDs
+        if hasattr(node, "_log_node_id"):
+            delattr(node, "_log_node_id")
         nid = getattr(node, "_log_node_id", None)
         if nid is None:
             nid = next(self._id_counter)
@@ -72,8 +75,8 @@ def _pad_str(self, pad) -> str:
 
     def _extract_node_info(self, node) -> Dict[str, Any]:
         sizing = getattr(node, "sizing", (None, None))
-        wmode = sizing[0].mode.value if sizing and sizing[0] else None
-        hmode = sizing[1].mode.value if sizing and sizing[1] else None
+        wmode = sizing[0].size_policy.value if sizing and sizing[0] else None
+        hmode = sizing[1].size_policy.value if sizing and sizing[1] else None
         return {
             "id" : self._attach_id(node),
             "type": type(node).__name__,
@@ -203,13 +206,13 @@ def write_text_tree(self, root, path: str):
     def _tree_dict(self, node) -> Dict[str, Any]:
         nid = self._attach_id(node)
         sizing = getattr(node, "sizing", (None, None))
-        wm = sizing[0].mode.value if sizing[0] else None
-        hm = sizing[1].mode.value if sizing[1] else None
+        wm = sizing[0].size_policy.value if sizing[0] else None
+        hm = sizing[1].size_policy.value if sizing[1] else None
         info = self._extract_node_info(node)
         d : Dict[str, Any] = {
             "node_id" : info['id'],
             "type": info['type'],
-            "backgroundColor": getattr(node, "backgroundColor", (220, 220, 220)),
+            "color": getattr(node, "color", "#dddddd"),
             "direction": info['direction'],
             "position": info['position'],
             "size": info['size'],