Autogenerate index.bob from beam pipe and vac pipe

Derive symbol SVG and execute open new tab action on mouse click
Scale dynamically with number of components

Author: niamhdougan

src/techui_builder/builder.py

@@ -178,55 +178,78 @@ def _validate_screen(self, screen_name: str):
         widget_group_name = widget_group.get_element_value("name")
         self.validator.validate_bob(screen_name, widget_group_name, widgets)
 
-    def create_screens(self):
-        """Create the screens for each component in techui.yaml"""
-        if len(self.entities) == 0:
-            logger_.critical(
-                "No ioc entities found. This [italic]normally[/italic]"
-                " suggests an issue with finding ixx-services."
-            )
-            exit()
-
-        # Loop over every component defined in techui.yaml and locate
-        # any extras defined
+    def _create_component_screens(self):
+        """Create screens for components defined in techui.yaml"""
         for component_name, component in self.conf.components.items():
             screen_entities: list[Entity] = []
 
-            # ONLY IF there is a matching component and entity, generate a screen
-            if component.prefix in self.entities.keys():
-                # Populate child labels for any entities
-                # with the same prefix as the component
-                for entity in self.entities[component.prefix]:
-                    entity.child_labels = component.child_labels
-
-                screen_entities.extend(self.entities[component.prefix])
-
-                if component.extras is not None:
-                    # If component has any extras, add them to the entries to generate
-                    for extra_p in component.extras:
-                        if extra_p not in self.entities.keys():
-                            logger_.error(
-                                f"Extra prefix {extra_p} for {component_name} does not"
-                                " exist."
-                            )
-                            continue
-                        screen_entities.extend(self.entities[extra_p])
+            if component.prefix not in self.entities.keys():
+                logger_.warning(
+                    f"{self.techui.name}: The prefix [bold]{component.prefix}[/bold] "
+                    f"set in the component [bold]{component_name}[/bold] does not match"
+                    " any P field in the ioc.yaml files in services"
+                )
+                continue
+
+            for entity in self.entities[component.prefix]:
+                entity.child_labels = component.child_labels
 
-                # This is used by both generate and validate,
-                # so called beforehand for tidyness
-                self.generator.build_widgets(component_name, screen_entities)
-                self.generator.build_groups(component_name, self.conf.components)
+            screen_entities.extend(self.entities[component.prefix])
 
-                screens_to_validate = list(self.validator.validate.keys())
+            if component.extras is not None:
+                for extra_p in component.extras:
+                    if extra_p not in self.entities.keys():
+                        logger_.error(
+                            f"Extra prefix {extra_p} for {component_name} does not"
+                            " exist."
+                        )
+                        continue
+                    screen_entities.extend(self.entities[extra_p])
 
-                if component_name in screens_to_validate:
-                    self._validate_screen(component_name)
-                else:
-                    self._generate_screen(component_name)
+            self.generator.build_widgets(component_name, screen_entities)
+            self.generator.build_groups(component_name, self.conf.components)
 
+            if component_name in list(self.validator.validate.keys()):
+                self._validate_screen(component_name)
             else:
+                self._generate_screen(component_name)
+
+    def _create_pipe_screens(self):
+        """Create screens for beam_pipe and vacuum_pipe components"""
+        all_pipe_components = {
+            **(self.conf.beam_pipe or {}),
+            **(self.conf.vacuum_pipe or {}),
+        }
+
+        for component_name, pipe_component in all_pipe_components.items():
+            pv_root = pipe_component.prefix.split(":", maxsplit=1)[0]
+
+            if pv_root not in self.entities:
                 logger_.warning(
-                    f"{self.techui.name}: The prefix [bold]{component.prefix}[/bold] "
-                    f"set in the component [bold]{component_name}[/bold] does not match"
-                    " any P field in the ioc.yaml files in services"
+                    f"Pipe component '{component_name}' with prefix "
+                    f"'{pipe_component.prefix}' does not match any entity "
+                    f"in the ioc.yaml files — skipping screen generation."
                 )
+                continue
+
+            screen_entities = self.entities[pv_root]
+
+            self.generator.build_widgets(component_name, screen_entities)
+            self.generator.build_groups(component_name, {})
+
+            if component_name in list(self.validator.validate.keys()):
+                self._validate_screen(component_name)
+            else:
+                self._generate_screen(component_name)
+
+    def create_screens(self):
+        """Create the screens for each component in techui.yaml"""
+        if len(self.entities) == 0:
+            logger_.critical(
+                "No ioc entities found. This [italic]normally[/italic]"
+                " suggests an issue with finding ixx-services."
+            )
+            return
+
+        self._create_component_screens()
+        self._create_pipe_screens()

src/techui_builder/generate.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import random
 import re
 from collections import defaultdict
 from collections.abc import Mapping
@@ -12,7 +11,13 @@
 from phoebusgen import widget as pwidget
 from phoebusgen.widget.widgets import ActionButton, EmbeddedDisplay, Group
 
-from techui_builder.models import Component, Entity, TechUi, TechUiSupport
+from techui_builder.models import (
+    Component,
+    Entity,
+    PipeComponent,
+    TechUi,
+    TechUiSupport,
+)
 
 logger_ = logging.getLogger(__name__)
 
@@ -327,24 +332,23 @@ def _create_beamline_widget(
         self._make_color_element(background_color, *color)
         return widget
 
-    def _get_available_symbols(self) -> list[Path]:
-        """Get list of available symbol SVG files."""
-        symbols_dir = self.support_path.joinpath("symbols")
-        if symbols_dir.exists():
-            return sorted(symbols_dir.glob("*.svg"))
-        return []
+    def _symbol_path(self, icon_type: str) -> Path | None:
+        """Derive SVG path from icon_type by converting underscores to hyphens."""
+        filename = icon_type.replace("_", "-") + ".svg"
+        path = self.support_path / "symbols" / filename
+        return path if path.exists() else None
 
     def _create_symbol_widget(
         self,
+        component_name: str,
         label: str,
         symbol_path: Path,
         x: int,
         y: int,
         width: int,
         height: int,
     ) -> etree.Element:
-        """Create a symbol widget with display action."""
-        # Make symbol path relative to synoptic dir
+        """Create a symbol widget that opens the component's bob on click."""
         try:
             rel_symbol_path = symbol_path.relative_to(
                 self.synoptic_dir,
@@ -360,11 +364,26 @@ def _create_symbol_widget(
             y=y,
             width=width,
             height=height,
-            pv_name=label,
         )
         symbols = etree.SubElement(widget, "symbols")
         symbol = etree.SubElement(symbols, "symbol")
         symbol.text = str(rel_symbol_path)
+
+        actions = etree.SubElement(widget, "actions")
+        actions.set("execute_as_one", "true")
+        action = etree.SubElement(actions, "action")
+        action.set("type", "open_display")
+        file_el = etree.SubElement(action, "file")
+        file_el.text = f"{component_name}.bob"
+        target_el = etree.SubElement(action, "target")
+        target_el.text = "tab"
+
+        run_actions = etree.SubElement(widget, "run_actions_on_mouse_click")
+        run_actions.text = "true"
+
+        desc_el = etree.SubElement(action, "description")
+        desc_el.text = f"Open {label}"
+
         return widget
 
     def _create_label_widget(
@@ -388,41 +407,11 @@ def _create_label_widget(
         )
         return widget
 
-    def _create_component_widget(
-        self,
-        component_name: str,
-        label: str,
-        x: int,
-        y: int,
-        width: int,
-        height: int,
-    ) -> etree.Element:
-        """Create a symbol widget with display action."""
-        widget = self._new_widget_element(
-            "action_button",
-            name=label,
-            x=x,
-            y=y,
-            width=width,
-            height=height,
-        )
-        actions = etree.SubElement(widget, "actions")
-        action = etree.SubElement(actions, "action")
-        action.set("type", "open_display")
-        file_el = etree.SubElement(action, "file")
-        file_el.text = f"{component_name}.bob"
-        target_el = etree.SubElement(action, "target")
-        target_el.text = "replace"
-        desc_el = etree.SubElement(action, "description")
-        desc_el.text = "Open Display"
-        return widget
-
     def _format_pipe_section(
         self,
         display: etree.Element,
         section_name: str,
-        component_names: list[str],
-        components: dict[str, Component],
+        components: dict[str, PipeComponent],
         pipe_left: int,
         pipe_top: int,
         pipe_width: int,
@@ -441,27 +430,23 @@ def _format_pipe_section(
             )
         )
 
-        if not component_names:
+        if not components:
             return
 
-        available_symbols = self._get_available_symbols()
         symbol_width = 60
         symbol_height = 60
-        # label_height = 20
-        count = len(component_names)
-        spacing = int((pipe_width - count * symbol_width) / (count + 1))
-        spacing = max(20, spacing)
+        count = len(components)
+        spacing = max(20, int((pipe_width - count * symbol_width) / (count + 1)))
 
         x = pipe_left + spacing
-        for component_name in component_names:
-            component = components[component_name]
+        for component_name, component in components.items():
             label = component.label or component_name
-            symbol_path = (
-                random.choice(available_symbols) if available_symbols else None
-            )
+            symbol_path = self._symbol_path(component.icon_type)
+
             if symbol_path:
                 display.append(
                     self._create_symbol_widget(
+                        component_name,
                         label,
                         symbol_path,
                         x,
@@ -470,6 +455,15 @@ def _format_pipe_section(
                         symbol_height,
                     )
                 )
+            else:
+                logger_.warning(
+                    f"No SVG found for icon_type '{component.icon_type}' "
+                    f"(component '{component_name}'): expected "
+                    f"{component.icon_type.replace('_', '-')}.svg in "
+                    f"{self.support_path / 'symbols'}. "
+                    f"Add the SVG to techui-support or fix the icon_type string."
+                )
+
             display.append(
                 self._create_label_widget(
                     label,
@@ -484,20 +478,24 @@ def generate_index_bob(
         techui: TechUi,
         output_dir: Path | None = None,
     ) -> None:
-        """Generate an index.bob from ordered components in techui.yaml."""
+        """Generate an index.bob from beam_pipe and vacuum_pipe in techui.yaml."""
         if output_dir is None:
             output_dir = self.synoptic_dir
 
         if not techui.beam_pipe and not techui.vacuum_pipe:
             logger_.warning(
-                "No beam_pipe or vacuum_pipe sections defined; "
-                "skipping index.bob generation."
+                "No beam_pipe or vacuum_pipe defined; skipping index.bob generation."
             )
             return
 
         pipe_left = 100
-        pipe_width = 1200
         pipe_height = 8
+        component_count = max(
+            len(techui.beam_pipe or {}),
+            len(techui.vacuum_pipe or {}),
+        )
+        pipe_width = max(1200, component_count * 120 + 200)
+
         display = etree.Element("display", version="2.0.0")
         title = etree.SubElement(display, "name")
         title.text = techui.beamline.location
@@ -507,31 +505,29 @@ def generate_index_bob(
                 display,
                 "vacuum_pipe",
                 techui.vacuum_pipe,
-                techui.components,
                 pipe_left,
-                120,
-                pipe_width,
-                pipe_height,
-                80,
-                (180, 180, 180),
+                pipe_top=120,
+                pipe_width=pipe_width,
+                pipe_height=pipe_height,
+                button_y=80,
+                color=(180, 180, 180),
             )
 
         if techui.beam_pipe:
             self._format_pipe_section(
                 display,
                 "beam_pipe",
                 techui.beam_pipe,
-                techui.components,
                 pipe_left,
-                260,
-                pipe_width,
-                pipe_height,
-                220,
-                (0, 120, 215),
+                pipe_top=260,
+                pipe_width=pipe_width,
+                pipe_height=pipe_height,
+                button_y=180,
+                color=(0, 255, 255),
             )
 
         output_dir.mkdir(parents=True, exist_ok=True)
-        output_path = output_dir.joinpath("index.bob")
+        output_path = output_dir / "index.bob"
         tree = etree.ElementTree(display)
         tree.write(
             output_path,