reworked a bit render mechanism

Author: drblallo

python/layout_visualizer.py

@@ -1,5 +1,6 @@
 from graphviz import Digraph
 import json
+import sys
 from typing import Optional
 import argparse
 
@@ -35,27 +36,25 @@ def add_node(node):
         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("input",
-                        help="Input JSON layout log (e.g., logs/layout-log.json)")
+                        help="Input JSON layout log (e.g., logs/layout-log.json)", nargs="?", default="-")
     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()
-    try:
+    if args.input != "-":
         with open(args.input, 'r', encoding='utf-8') as f:
             data = json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        data = args.input
-    
+    else:
+        data = json.load("\n".join(sys.stdin.readlines()))
+
     result = visualize_layout_tree(data, args.out, args.format)
     if result:
-        print(result)
+        print(result)

python/rlc/__init__.py

@@ -14,6 +14,5 @@
 from .layout import Layout, Padding, Direction, FIT, FIXED, GROW
 from .text import Text
 from rlc.layout_logger import LayoutLogConfig, LayoutLogger
-from test.display_layout import display
 
 

python/rlc/renderer/array_renderer.py

@@ -1,20 +1,19 @@
 from rlc.renderer.renderable import Renderable, register_renderer
 from rlc.layout import Layout, Direction, FIT, Padding
+from dataclasses import dataclass
 
 @register_renderer
+@dataclass
 class ArrayRenderer(Renderable):
-    def __init__(self, rlc_type_name, length, element_rendere: Renderable, style_policy):
-        super().__init__(rlc_type_name, style_policy)
-        self.length = length
-        self.element_renderer = element_rendere
-        self.style_policy = style_policy
+    length: int
+    element_renderer: Renderable
 
     def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2)):
         layout = self.make_layout(sizing=sizing, direction=direction, color=color, padding=padding, border=3, child_gap=5)
         layout.binding = {"type": "array"}
         color = 'lightgray'
         if self.element_renderer is not None:
-            for i in range(self.length):  
+            for i in range(self.length):
                 item = obj[i]
                 # Alternate direction for the next depth
                 next_dir = (
@@ -24,7 +23,7 @@ def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(F
                 item_binding = {
                     "type": "array_item",
                     "index": i,
-                    "parent": layout.binding 
+                    "parent": layout.binding
                 }
                 child = self.element_renderer(
                     item,
@@ -38,32 +37,16 @@ def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(F
                 child.binding = item_binding
                 layout.add_child(child)
         return layout
-    
+
     def update(self, layout, obj, elapsed_time=0.0):
         for i, child in enumerate(layout.children):
             item = obj[i]
             self.element_renderer.update(child, item, elapsed_time)
-    
+
     def _iter_children(self):
         return [self.element_renderer]
 
-    def _describe_self(self):
-        return f"{self.rlc_type_name + str(self.style_policy)}[len={self.length}]"
-    
-    def _to_dict_data(self):
-        return {
-            "length": self.length,
-            "element": self.element_renderer.to_dict() if self.element_renderer is not None else None,
-            "style_policy" : self.style_policy
-        }
-
-    @classmethod
-    def _from_dict_data(cls, rlc_type_name, data):
-        length = data["length"]
-        element = Renderable.from_dict(data["element"]) if data["element"] is not None else None
-        return cls(rlc_type_name, length, element, data["style_policy"])
-    
     def apply_interactivity(self, layout_child, index=None, parent_obj=None):
         """Hook for subclasses to mark children interactive."""
         return None
-    
+

python/rlc/renderer/bint_renderer.py

@@ -1,63 +1,28 @@
 from rlc.text import Text
 from rlc.renderer.renderable import Renderable, register_renderer
 from rlc.layout import  Direction, FIT, Padding
+from dataclasses import dataclass
 
 @register_renderer
 class BoundedIntRenderer(Renderable):
     """
     Renderer for bounded integer structs like BIntT1T10T.
     """
-    def __init__(self, rlc_type_name, style_policy):
-        super().__init__(rlc_type_name, style_policy)
-        # Optionally parse bounds from type name: BIntT1T10T -> 1,10
-        name = rlc_type_name
-        self.bounds = self._parse_bounds_from_name(name)
-        self.style_policy = style_policy
-
-    def _parse_bounds_from_name(self, name: str):
-        # Extract numbers between 'T' markers if present
-        # e.g., "BIntT1T10T" -> (1, 10)
-        parts = [p for p in name.split("T") if p.isdigit()]
-        if len(parts) >= 2:
-            return (int(parts[0]), int(parts[1]))
-        return None
-
     def build_layout(self, obj, direction=Direction.COLUMN,
                      color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2)):
         # Extract the 'value' field (the inner c_long)
         value = getattr(obj, "value", None)
         val_str = str(value if isinstance(value, int) else getattr(value, "value", value))
 
-        # Include bounds if known
-        # if self.bounds:
-        #     low, high = self.bounds
-        #     display = f"{val_str} [{low}-{high}]"
-        # else:
-        #     display = val_str
         layout = self.make_text(val_str, "Arial", 16, "black")
         layout.binding = {
             "type": "bounded_int",
             "obj": obj
         }
         return layout
-    
+
     def update(self, layout, obj, elapsed_time=0.0):
         if isinstance(layout, Text):
             value = getattr(obj, "value", None)
             new_val = str(value if isinstance(value, int) else getattr(value, "value", value))
             layout.update_text(new_val)
-
-    def _describe_self(self):
-        return f"{self.rlc_type_name + str(self.style_policy)}(bounded)"
-    
-    def _to_dict_data(self):
-        return {
-            "bounds": self.bounds,
-            "style_policy" : self.style_policy
-        }
-
-    @classmethod
-    def _from_dict_data(cls, rlc_type_name, data):
-        obj = cls(rlc_type_name, data["style_policy"])
-        obj.bounds = tuple(data["bounds"])
-        return obj

python/rlc/renderer/bounded_vector_renderer.py

@@ -1,52 +1,22 @@
 from rlc.text import Text
 from rlc.renderer.renderable import Renderable, register_renderer
 from rlc.layout import  Direction, FIT, Padding
+from dataclasses import dataclass
 
 @register_renderer
+@dataclass
 class BoundedVectorRenderer(Renderable):
     """
     Renderer for bounded integer structs like BIntT1T10T.
     """
-    def __init__(self, rlc_type_name, vector_renderer, style_policy):
-        super().__init__(rlc_type_name, style_policy)
-        name = rlc_type_name
-        self.vector_renderer = vector_renderer
-        self.bounds = self._parse_bounds_from_name(name)
-        self.style_policy = style_policy
-
-    def _parse_bounds_from_name(self, name: str):
-        # Extract numbers between 'T' markers if present
-        # e.g., "BoundedVectorT20T" -> (1, 10)
-        parts = [p for p in name.split("T") if p.isdigit()]
-        if len(parts) >= 2:
-            return int(parts[-1])
-        return None
+    vector_renderer: Renderable
 
     def build_layout(self, obj, direction=Direction.COLUMN,
                      color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2)):
         value = getattr(obj, "_data", None)
         value_layout = self.vector_renderer(value)
         return value_layout
-        
-    
+
     def update(self, layout, obj, elapsed_time=0.0):
         value = getattr(obj, "_data")
         self.vector_renderer.update(layout, value, elapsed_time)
-
-    def _describe_self(self):
-        return f"{self.rlc_type_name + str(self.style_policy)}(bounded)"
-    
-    def _to_dict_data(self):
-        return {
-            "bounds": self.bounds,
-            "field": self.vector_renderer.to_dict(),
-            "style_policy" : self.style_policy
-        }
-
-    @classmethod
-    def _from_dict_data(cls, rlc_type_name, data):
-        vector_renderer = Renderable.from_dict(data["field"])
-        obj = cls(rlc_type_name, vector_renderer, data["style_policy"])
-        obj.bounds = data["bounds"]
-        
-        return obj

python/rlc/renderer/primitive_renderer.py

@@ -4,16 +4,11 @@
 from rlc.text import Text
 from rlc.layout import  Direction, FIT, Padding
 import time
+from dataclasses import dataclass
 
 @register_renderer
+@dataclass
 class PrimitiveRenderer(Renderable):
-    def __init__(self, rlc_type_name, style_policy):
-        super().__init__(rlc_type_name, style_policy)
-        self.style_policy = style_policy
-
-    def _iter_children(self):
-        return []
-
     def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2)):
         if self.rlc_type_name == "c_bool":
             text = "True" if obj else "False"
@@ -29,7 +24,7 @@ def build_layout(self, obj, direction=Direction.COLUMN, color="white", sizing=(F
         }
 
         return layout
-    
+
     def update(self, layout, obj, elapsed_time=0.0):
         """Update the text node if the value changed."""
         if isinstance(layout, Text):
@@ -44,12 +39,4 @@ def _extract_value(self, obj):
         else:
             text = str(obj)
         return text
-    
-    def _to_dict_data(self):
-        return {
-            "style_policy" : self.style_policy
-        }  
 
-    @classmethod
-    def _from_dict_data(cls, rlc_type_name, data):
-        return cls(rlc_type_name, data["style_policy"])

python/rlc/renderer/renderable.py

@@ -1,6 +1,8 @@
 
 from abc import ABC, abstractmethod
 from rlc.layout import Layout, Direction, FIT, Padding
+from typing import Dict
+from dataclasses import dataclass, field
 from rlc.text import Text
 
 _renderer_registry = {}  # maps class name → class
@@ -9,14 +11,14 @@ def register_renderer(cls):
     _renderer_registry[cls.__name__] = cls
     return cls
 
+@dataclass(kw_only=True)
 class Renderable(ABC):
     """
     Base abstract renderer type.
     Each subclasss knows how to convert its types object into a Layout tree.
     """
-    def __init__(self, rlc_type_name, style_policy : dict): 
-        self.rlc_type_name = rlc_type_name
-        self.style_policy = style_policy
+    rlc_type_name: str
+    style_policy: Dict = field(default_factory=dict)
 
     def make_layout(self, direction=Direction.COLUMN, color="white", sizing=(FIT(), FIT()), logger=None, padding=Padding(2,2,2,2), border=3, child_gap=5) -> Layout:
         layout = Layout(sizing=sizing, direction=direction, color=color, padding=padding, border=border, child_gap=child_gap)
@@ -53,7 +55,7 @@ def update(self, layout, obj, elapsed_time: float = 0.0):
 
     def __call__(self, obj, parent_binding=None, **kwds):
         layout = self.build_layout(obj=obj, **kwds)
-       
+
         # If build_layout didn't set binding, ensure we add it
         if layout.binding is None:
             layout.binding = {
@@ -75,52 +77,7 @@ def __call__(self, obj, parent_binding=None, **kwds):
                 child.binding["parent"] = layout.binding
 
         return layout
-    
-
-    # ---------- PUBLIC SERIALIZATION API ----------
-    def to_dict(self):
-        return {
-            "renderer_class": self.__class__.__name__,
-            "rlc_type_name": self.rlc_type_name,
-            "data": self._to_dict_data(),
-            "style_policy" : self.style_policy
-        }
-
-    @staticmethod
-    def from_dict(d):
-        cls_name = d["renderer_class"]
-        if cls_name not in _renderer_registry:
-            raise ValueError(f"Unknown renderer class '{cls_name}'")
-        cls = _renderer_registry[cls_name]
-        return cls._from_dict_data(
-            d["rlc_type_name"],
-            d["data"]
-        )
-    
-    # ---------- SUBCLASS HOOKS ----------
-    @abstractmethod
-    def _to_dict_data(self):
-        """Return subclass-specific dict data."""
-        pass
-
-    @classmethod
-    @abstractmethod
-    def _from_dict_data(cls, rlc_type_name, data):
-        """Recreate subclass instance."""
-        pass
-    
-    def print_tree(self, indent: int = 0):
-        prefix = "  " * indent
-        print(f"{prefix}{self.__class__.__name__}({self._describe_self()})")
-        for child in self._iter_children():
-            if isinstance(child, Renderable):
-                child.print_tree(indent + 1)
-            else:
-                print(f"{'  ' * (indent + 1)}{child}")
 
-    def _describe_self(self) -> str:
-        """Subclasses can override to show additional info."""
-        return self.rlc_type_name + str(self.style_policy)
 
     def _iter_children(self):
         """Return iterable of child renderers, if any. Override per subclass."""