wip

Author: vkottler

local/configs/package.yaml

@@ -8,7 +8,7 @@ time_command: true
 
 requirements:
   - aiofiles
-  - vcorelib>=3.6.3
+  - vcorelib>=3.6.4
   - svgen>=0.8.0
   - websockets
   - psutil

runtimepy/channel/environment/command/processor.py

@@ -49,10 +49,6 @@ def __init__(
 
         self.parser.initialize()
 
-        # need a way to build this
-        # buttons that do msg bus side effects
-        self.action_markdown = ""
-
     def register_custom_commands(
         self, *custom_commands: CustomCommand
     ) -> None:

runtimepy/data/js/classes/WorkerInterface.js

@@ -10,7 +10,7 @@ class WorkerInterface {
 
   command(data) { this.send({kind : "command", value : data}); }
 
-  bus(data) { this.worker.postMessage({bus : data}); }
+  bus(key, data) { this.worker.postMessage({key : key, bus : data}); }
 
   toWorker(data, param) { return this.send({"worker" : data}, param); }
 }

runtimepy/data/js/sample.js

@@ -1,2 +1,2 @@
 console.log(`sample.js included (${tab.name})`);
-// tab.worker.bus({a: 1, b: 2, c: 3});
+// tab.worker.bus("test", {a: 1, b: 2, c: 3});

runtimepy/net/server/app/env/__init__.py

@@ -29,6 +29,7 @@ def populate_tabs(app: AppInfo, tabs: TabbedContent) -> None:
             tabs,
             icon="ethernet",
             markdown=conn.markdown,
+            # buttons=,
         ).entry()
 
     # Task tabs.
@@ -40,6 +41,7 @@ def populate_tabs(app: AppInfo, tabs: TabbedContent) -> None:
             tabs,
             icon="arrow-repeat",
             markdown=task.markdown,
+            # buttons=,
             js_uris=task.config.get("js_uris", []),
         ).entry()
 
@@ -52,6 +54,7 @@ def populate_tabs(app: AppInfo, tabs: TabbedContent) -> None:
             tabs,
             icon="bucket",
             markdown=struct.markdown,
+            # buttons=,
             js_uris=struct.config.get("js_uris", []),
         ).entry()
 

runtimepy/net/server/app/env/tab/base.py

@@ -2,7 +2,15 @@
 A module implementing a channel-environment tab HTML interface.
 """
 
+# built-in
+from io import StringIO
+from json import dumps
+from typing import NamedTuple
+
 # third-party
+from svgen.element import Element
+from svgen.element.html import div
+from vcorelib.dict import GenericStrDict
 from vcorelib.io.markdown import MarkdownMixin
 from vcorelib.logging import LoggerMixin
 from vcorelib.math import RateLimiter
@@ -13,10 +21,60 @@
     ChannelCommandProcessor,
 )
 from runtimepy.net.arbiter.info import AppInfo
+from runtimepy.net.html.bootstrap import icon_str
 from runtimepy.net.html.bootstrap.tabs import TabbedContent
 from runtimepy.net.server.app.tab import Tab
 
 
+class ActionButton(NamedTuple):
+    """A class implementing an interface for action buttons."""
+
+    key: str
+    payload: GenericStrDict
+    text: str
+    icon: str
+    variant: str
+    outline: bool
+
+    @staticmethod
+    def from_dict(data: GenericStrDict) -> "ActionButton":
+        """Create an action button from dictionary data."""
+
+        return ActionButton(
+            data["key"],
+            data["payload"],
+            data.get("text", ""),
+            data.get("icon", ""),
+            data.get("variant", "primary"),
+            data.get("outline", True),
+        )
+
+    def element(self) -> Element:
+        """Create an action button element."""
+
+        payload = dumps(self.payload).replace('"', """)
+
+        text_parts = []
+        if self.icon:
+            text_parts.append(
+                icon_str(
+                    self.icon,
+                    [f"text-{self.variant}-emphasis"] if self.text else [],
+                )
+            )
+        if self.text:
+            text_parts.append(self.text)
+
+        return div(
+            tag="button",
+            type="button",
+            onclick=f"tabs[shown_tab].worker.bus('{self.key}', {payload})",
+            class_str=f"btn btn{'-outline' if self.outline else ''}"
+            f"-{self.variant} m-2 ms-1 me-0",
+            text=" ".join(text_parts),
+        )
+
+
 class ChannelEnvironmentTabBase(Tab, LoggerMixin, MarkdownMixin):
     """A channel-environment tab interface."""
 
@@ -28,14 +86,61 @@ def __init__(
         tabs: TabbedContent,
         icon: str = "alarm",
         markdown: str = None,
+        buttons: list[ActionButton] = None,
         **kwargs,
     ) -> None:
         """Initialize this instance."""
 
+        # Action buttons.
+        if buttons is None:
+            buttons = [
+                ###############################################################
+                # REMOVE THESE
+                ###############################################################
+                ActionButton.from_dict(
+                    {"icon": "tux", "key": "test", "payload": {}}
+                ),
+                ActionButton.from_dict(
+                    {
+                        "icon": "tux",
+                        "key": "test",
+                        "payload": {},
+                        "text": "asdf",
+                    }
+                ),
+                ActionButton.from_dict(
+                    {
+                        "icon": "tux",
+                        "key": "test",
+                        "payload": {},
+                        "outline": False,
+                    }
+                ),
+                ActionButton.from_dict(
+                    {
+                        "icon": "tux",
+                        "key": "test",
+                        "payload": {},
+                        "text": "asdf",
+                        "outline": False,
+                    }
+                ),
+                ###############################################################
+            ]
+        self.buttons: list[ActionButton] = buttons
+
         self.command = command
         self.set_markdown(markdown=markdown, package=PKG_NAME)
         super().__init__(name, app, tabs, source="env", icon=icon, **kwargs)
 
         # Logging.
         LoggerMixin.__init__(self, logger=self.command.logger)
         self.log_limiter = RateLimiter.from_s(1.0)
+
+    def _action_markdown(self) -> str:
+        """Get action-button markdown."""
+
+        with StringIO() as stream:
+            for button in self.buttons:
+                button.element().encode(stream)
+            return stream.getvalue()

runtimepy/net/server/app/env/tab/html.py

@@ -289,10 +289,10 @@ def compose(self, parent: Element) -> None:
         )
         logs.booleans.add("readonly")
 
-        if self.command.action_markdown:
+        if self.buttons:
             centered_markdown(
                 vert_container,
-                self.command.action_markdown,
+                self._action_markdown(),
                 "border-start",
                 "border-bottom",
                 "border-end",

runtimepy/net/server/websocket/__init__.py

@@ -96,7 +96,7 @@ async def ui_handler(outbox: JsonMessage, inbox: JsonMessage) -> None:
 
             # Handle bus messages.
             if "bus" in inbox:
-                await BUS.send_ro("ui", inbox["bus"])
+                await BUS.send_ro(inbox["key"], inbox["bus"])
                 return
 
             # Handle frame messages.

runtimepy/requirements.txt

@@ -1,5 +1,5 @@
 aiofiles
-vcorelib>=3.6.3
+vcorelib>=3.6.4
 svgen>=0.8.0
 websockets
 psutil

tests/net/server/__init__.py

@@ -29,7 +29,7 @@ async def runtimepy_websocket_client(
 ) -> None:
     """Test client interactions via WebSocket."""
 
-    client.send_json({"ui": {"bus": {"a": 1}}})
+    client.send_json({"ui": {"key": "test", "bus": {"a": 1}}})
 
     send_ui(client, "test", {"a": 1, "b": 2, "c": 3})