runtimepy 5.14.2__py3-none-any.whl → 5.15.1__py3-none-any.whl

runtimepy/net/http/request_target.py

@@ -4,9 +4,9 @@ A module implementing a simple request-target (3.2) interface.
 
 # built-in
 import http
-from typing import Optional, Tuple
+from typing import Optional
 
-PathMaybeQuery = Tuple[str, Optional[str]]
+PathMaybeQuery = tuple[str, Optional[str]]
 
 
 class RequestTarget:
@@ -20,7 +20,7 @@ class RequestTarget:
         self.raw = request_target_raw
 
         # Host and port.
-        self.authority_form: Optional[Tuple[str, int]] = None
+        self.authority_form: Optional[tuple[str, int]] = None
 
         # Path and optional query.
         self.origin_form: Optional[PathMaybeQuery] = None

runtimepy/net/mixin.py

@@ -11,10 +11,12 @@ from typing import Callable
 from typing import Optional as _Optional
 from typing import cast as _cast
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.net import IpHost as _IpHost
 from runtimepy.net import normalize_host as _normalize_host
-from runtimepy.net.connection import BinaryMessage as _BinaryMessage
 from runtimepy.net.mtu import ETHERNET_MTU, UDP_DEFAULT_MTU, host_discover_mtu
 
 
@@ -23,7 +25,7 @@ class BinaryMessageQueueMixin:
 
     def __init__(self) -> None:
         """Initialize this protocol."""
-        self.queue: _asyncio.Queue[_BinaryMessage] = _asyncio.Queue()
+        self.queue: _asyncio.Queue[BinaryMessage] = _asyncio.Queue()
 
 
 class TransportMixin:

runtimepy/net/server/__init__.py

@@ -9,6 +9,7 @@ import logging
 import mimetypes
 from pathlib import Path
 from typing import Any, Optional, TextIO, Union
+from urllib.parse import urlencode
 
 # third-party
 from vcorelib import DEFAULT_ENCODING
@@ -24,7 +25,8 @@ from runtimepy.net.http.request_target import PathMaybeQuery
 from runtimepy.net.http.response import AsyncResponse, ResponseHeader
 from runtimepy.net.server.html import HtmlApp, HtmlApps, get_html, html_handler
 from runtimepy.net.server.json import encode_json, json_handler
-from runtimepy.net.server.markdown import markdown_for_dir
+from runtimepy.net.server.markdown import DIR_FILE, markdown_for_dir
+from runtimepy.net.server.mux import mux_app
 from runtimepy.net.tcp.http import HttpConnection, HttpResult
 from runtimepy.util import normalize_root, path_has_part, read_binary
 
@@ -43,7 +45,7 @@ class RuntimepyServerConnection(HttpConnection):
     """A class implementing a server-connection interface for this package."""
 
     # Can register application methods to URL paths.
-    apps: HtmlApps = {}
+    apps: HtmlApps = {"/mux.html": mux_app}
     default_app: Optional[HtmlApp] = None
 
     # Can load additional data into this dictionary for easy HTTP access.
@@ -58,7 +60,7 @@ class RuntimepyServerConnection(HttpConnection):
     # Set these to control meta attributes.
     metadata: dict[str, Optional[str]] = {
         "title": HttpConnection.identity,
-        "description": None,
+        "description": f"({HttpConnection.identity})",
     }
 
     def add_path(self, path: Pathlike, front: bool = False) -> None:
@@ -153,7 +155,6 @@ class RuntimepyServerConnection(HttpConnection):
 
         meta: dict[str, str] = type(self).metadata.copy()  # type: ignore
 
-        meta.setdefault("description", "")
         meta["description"] += (
             " This page was rendered from "
             f"Markdown by {HttpConnection.identity}."
@@ -202,6 +203,10 @@ class RuntimepyServerConnection(HttpConnection):
         candidates: list[Path] = []
         for search in self.paths:
             candidate = search.joinpath(path[0][1:])
+
+            if candidate.name == DIR_FILE:
+                candidate = candidate.parent
+
             if candidate.is_dir():
                 directories.append((candidate, search))
                 candidates.append(candidate.joinpath("index.html"))
@@ -245,10 +250,9 @@ class RuntimepyServerConnection(HttpConnection):
 
         # Handle a directory as a last resort.
         if not result and directories:
-            candidate, search = directories[0]
             result = self.render_markdown(
                 markdown_for_dir(
-                    candidate, search, {"applications": self.apps.keys()}
+                    directories, {"applications": self.apps.keys()}
                 ),
                 response,
                 path[1],
@@ -285,7 +289,7 @@ class RuntimepyServerConnection(HttpConnection):
         self,
         response: ResponseHeader,
         request: RequestHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> HttpResult:
         """Handle POST requests."""
 
@@ -307,7 +311,7 @@ class RuntimepyServerConnection(HttpConnection):
         self,
         response: ResponseHeader,
         request: RequestHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> HttpResult:
         """Handle GET requests."""
 
@@ -360,4 +364,7 @@ class RuntimepyServerConnection(HttpConnection):
                 if populated:
                     result = stream.getvalue().encode()
 
-        return result or self.redirect_to("/404.html", response)
+        return result or self.redirect_to(
+            f"/404.html?{urlencode({'target': request.target.raw})}",
+            response,
+        )

runtimepy/net/server/app/__init__.py

@@ -74,6 +74,7 @@ async def setup(app: AppInfo) -> int:
     html_app = create_app(app, getattr(_import_module(module), method))
     target: str
     for target in app.config_param("http_app_paths", []):
+        assert target not in RuntimepyServerConnection.apps, target
         RuntimepyServerConnection.apps[target] = html_app
 
     # Register redirects.

runtimepy/net/server/app/create.py

@@ -29,7 +29,7 @@ def config_param(
 
 
 HtmlAppComposer = Callable[
-    [AppInfo, Html, RequestHeader, ResponseHeader, Optional[bytes]], Html
+    [AppInfo, Html, RequestHeader, ResponseHeader, Optional[bytearray]], Html
 ]
 
 
@@ -43,7 +43,7 @@ def create_cacheable_app(app: AppInfo, compose: HtmlAppComposer) -> HtmlApp:
         document: Html,
         request: RequestHeader,
         response: ResponseHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> Html:
         """A simple 'Hello, world!' application."""
 
@@ -82,7 +82,7 @@ def create_app(
         document: Html,
         request: RequestHeader,
         response: ResponseHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> Html:
         """Main package web application."""
 

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

@@ -40,6 +40,7 @@ def populate_tabs(app: AppInfo, tabs: TabbedContent) -> None:
             tabs,
             icon="arrow-repeat",
             markdown=task.markdown,
+            js_uris=task.config.get("js_uris", []),
         ).entry()
 
     # Struct tabs.
@@ -51,6 +52,7 @@ def populate_tabs(app: AppInfo, tabs: TabbedContent) -> None:
             tabs,
             icon="bucket",
             markdown=struct.markdown,
+            js_uris=struct.config.get("js_uris", []),
         ).entry()
 
     # Subprocess tabs.
@@ -109,16 +111,27 @@ def channel_environments(app: AppInfo, tabs: TabbedContent) -> None:
     # Remove tab-content scrolling.
     tabs.set_scroll(False)
 
-    # Tab name filter.
-    input_box(tabs.tabs, label="tab", description="Tab name filter.")
-
     centered_markdown(
         tabs.tabs,
         app.config_param("top_markdown", "configure `top_markdown`"),
         "border-start",
         "border-bottom",
         "border-end",
+        "bg-gradient-tertiary-to-top",
+    )
+
+    # Tab name filter.
+    _, label, box = input_box(
+        div(tag="form", autocomplete="off", parent=tabs.tabs),
+        label="tab",
+        description="Tab name filter.",
+        placement="bottom",
+        icon="funnel",
+        spellcheck="false",
+        pattern=".* $ @",
     )
+    label.add_class("border-top-0")
+    box.add_class("border-top-0")
 
     populate_tabs(app, tabs)
 
@@ -129,6 +142,18 @@ def channel_environments(app: AppInfo, tabs: TabbedContent) -> None:
         icon="table",
         id="channels-button",
     )
+    tabs.add_button(
+        "Open channel table",
+        "",
+        icon="arrow-bar-right",
+        id="open-channels-button",
+    )
+    tabs.add_button(
+        "Dedent channel table",
+        "",
+        icon="arrow-bar-left",
+        id="dedent-channels-button",
+    )
 
     # Plot settings modal.
     plot_settings(tabs)
@@ -149,11 +174,12 @@ def channel_environments(app: AppInfo, tabs: TabbedContent) -> None:
         app.config_param("bottom_markdown", "configure `bottom_markdown`"),
         "border-start",
         "border-end",
+        "bg-gradient-tertiary-to-bottom",
     )
 
     # Add splash screen element.
     div(
         id=f"{PKG_NAME}-splash",
         parent=tabs.container,
-        class_str="bg-success-subtle bg-gradient",
+        class_str="bg-secondary-subtle bg-gradient",
     )

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

@@ -15,17 +15,14 @@ from runtimepy.net.server.app.placeholder import under_construction
 def plot_settings(tabs: TabbedContent) -> None:
     """Create the plot settings modal."""
 
-    modal = Modal(tabs, name="plot", icon="graph-up")
+    modal = Modal(tabs, name="settings", icon="sliders")
     under_construction(modal.footer)
 
-    div(tag="h1", text="settings", parent=modal.body)
-    div(tag="hr", parent=modal.body)
-
-    div(tag="h2", text="plot status", parent=modal.body)
+    div(tag="h1", text="plot status", parent=modal.body)
     div(id="plot-status-inner", parent=modal.body)
-    div(tag="hr", parent=modal.body)
 
-    div(tag="h2", text="minimum transmit period (ms)", parent=modal.body)
+    div(tag="hr", parent=modal.body)
+    div(tag="h1", text="minimum transmit period (ms)", parent=modal.body)
 
     div(
         tag="p",

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

@@ -28,12 +28,13 @@ class ChannelEnvironmentTabBase(Tab, LoggerMixin, MarkdownMixin):
         tabs: TabbedContent,
         icon: str = "alarm",
         markdown: str = None,
+        **kwargs,
     ) -> None:
         """Initialize this instance."""
 
         self.command = command
         self.set_markdown(markdown=markdown, package=PKG_NAME)
-        super().__init__(name, app, tabs, source="env", icon=icon)
+        super().__init__(name, app, tabs, source="env", icon=icon, **kwargs)
 
         # Logging.
         LoggerMixin.__init__(self, logger=self.command.logger)

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

@@ -20,6 +20,7 @@ from runtimepy.net.server.app.env.widgets import (
     enum_dropdown,
     value_input_box,
 )
+from runtimepy.ui.controls import Controls, Default
 
 
 def get_channel_kind_str(
@@ -39,7 +40,7 @@ def get_channel_kind_str(
 def default_button(
     parent: Element,
     name: str,
-    chan: AnyChannel,
+    default: Default,
     *classes: str,
     front: bool = True,
 ) -> Element:
@@ -49,14 +50,31 @@ def default_button(
         parent,
         id=name,
         icon="arrow-counterclockwise",
-        title=f"Reset '{name}' to default value '{chan.default}'.",
-        value=chan.default,
+        title=f"Reset '{name}' to default value '{default}'.",
+        value=default,
         front=front,
     )
     button.add_class("default-button", *classes)
     return button
 
 
+def handle_controls(parent: Element, name: str, controls: Controls) -> None:
+    """Add control elements."""
+
+    # Determine if a slider should be created.
+    if "slider" in controls:
+        elem = controls["slider"]
+
+        slider(
+            elem["min"],  # type: ignore
+            elem["max"],  # type: ignore
+            int(elem["step"]),  # type: ignore
+            parent=parent,
+            id=name,
+            title=f"Value control for '{name}'.",
+        ).add_class("bg-body", "rounded-pill", "me-2")
+
+
 class ChannelEnvironmentTabControls(ChannelEnvironmentTabBase):
     """A channel-environment tab interface."""
 
@@ -74,12 +92,18 @@ class ChannelEnvironmentTabControls(ChannelEnvironmentTabBase):
         # Add boolean/bit toggle button.
         control = div(tag="td", parent=parent, class_str="p-0")
 
+        if chan.commandable:
+            control.add_class("border-start-info-subtle")
+            parent.add_class("channel-commandable")
+        else:
+            parent.add_class("channel-regular")
+
         chan_type = div(
             tag="td",
             text=get_channel_kind_str(env, chan, enum),
             parent=parent,
             title=f"Underlying primitive type for '{name}'.",
-            class_str="p-0 ps-1 pe-1",
+            class_str="p-0 ps-2 pe-1",
         )
 
         control_added = False
@@ -88,50 +112,82 @@ class ChannelEnvironmentTabControls(ChannelEnvironmentTabBase):
             chan_type.add_class("fw-bold")
 
             if chan.commandable and not chan.type.is_boolean:
-                enum_dropdown(control, name, enum, cast(int, chan.raw.value))
+                enum_dropdown(
+                    control, name, enum, cast(int, chan.raw.value)
+                ).add_class(
+                    "border-0",
+                    "text-secondary-emphasis",
+                    "pt-0",
+                    "pb-0",
+                    "d-inline",
+                )
+                control.add_class("border-end-info-subtle")
                 control_added = True
 
+                if chan.default is not None:
+                    default_button(
+                        control,
+                        name,
+                        chan.default,
+                        "p-0",
+                        "d-inline",
+                        *TABLE_BUTTON_CLASSES,
+                        front=False,
+                    )
+
         if chan.type.is_boolean:
-            chan_type.add_class("text-primary-emphasis")
+            chan_type.add_class("text-primary")
             if chan.commandable:
                 button = toggle_button(
                     control, id=name, title=f"Toggle '{name}'."
                 )
-                button.add_class("toggle-value", *TABLE_BUTTON_CLASSES)
+                button.add_class(
+                    "toggle-value",
+                    "pt-0",
+                    "pb-0",
+                    "fs-5",
+                    "border-end-info-subtle",
+                    *TABLE_BUTTON_CLASSES,
+                )
                 control_added = True
 
                 if chan.default is not None:
                     default_button(
-                        control, name, chan, *TABLE_BUTTON_CLASSES, front=False
+                        control,
+                        name,
+                        chan.default,
+                        "p-0",
+                        *TABLE_BUTTON_CLASSES,
+                        front=False,
                     )
 
         elif chan.type.is_float:
             chan_type.add_class("text-secondary-emphasis")
         else:
-            chan_type.add_class("text-primary")
+            chan_type.add_class("text-primary-emphasis")
 
         # Input box with send button.
         if not control_added and chan.commandable:
-            container = value_input_box(name, control)
+            control.add_class("border-end-info-subtle")
+
+            container = value_input_box(name, control).add_class(
+                "justify-content-start"
+            )
 
             # Reset-to-default button if a default value exists.
             if chan.default is not None:
-                default_button(container, name, chan, *TABLE_BUTTON_CLASSES)
+                default_button(
+                    container,
+                    name,
+                    chan.default,
+                    "pt-0",
+                    "pb-0",
+                    *TABLE_BUTTON_CLASSES,
+                    front=False,
+                )
 
             if chan.controls:
-                # Determine if a slider should be created.
-                if "slider" in chan.controls:
-                    elem = chan.controls["slider"]
-
-                    slider(
-                        elem["min"],  # type: ignore
-                        elem["max"],  # type: ignore
-                        int(elem["step"]),  # type: ignore
-                        parent=container,
-                        id=name,
-                        title=f"Value control for '{name}'.",
-                        front=True,
-                    )
+                handle_controls(container, name, chan.controls)
 
     def _bit_field_controls(
         self,
@@ -146,12 +202,70 @@ class ChannelEnvironmentTabControls(ChannelEnvironmentTabBase):
 
         field = self.command.env.fields[name]
         if field.commandable:
+            control.add_class("border-start-info-subtle")
+            parent.add_class("channel-commandable")
+
+            if not is_bit:
+                control.add_class("border-end-info-subtle")
+
             if is_bit:
                 button = toggle_button(
                     control, id=name, title=f"Toggle '{name}'."
                 )
-                button.add_class("toggle-value", *TABLE_BUTTON_CLASSES)
+                button.add_class(
+                    "toggle-value",
+                    "pt-0",
+                    "pb-0",
+                    "fs-5",
+                    "border-start-0",
+                    "border-end-info-subtle",
+                    *TABLE_BUTTON_CLASSES,
+                )
+                if field.default is not None:
+                    default_button(
+                        control,
+                        name,
+                        field.default,  # type: ignore
+                        "p-0",
+                        *TABLE_BUTTON_CLASSES,
+                        front=False,
+                    )
+
             elif enum:
-                enum_dropdown(control, name, enum, field())
+                enum_dropdown(control, name, enum, field()).add_class(
+                    "border-0",
+                    "text-secondary-emphasis",
+                    "pt-0",
+                    "pb-0",
+                    "d-inline",
+                )
+                if field.default is not None:
+                    default_button(
+                        control,
+                        name,
+                        field.default,  # type: ignore
+                        "p-0",
+                        "d-inline",
+                        *TABLE_BUTTON_CLASSES,
+                        front=False,
+                    )
             else:
-                value_input_box(name, control)
+                container = value_input_box(name, control).add_class(
+                    "justify-content-start"
+                )
+
+                if field.default is not None:
+                    default_button(
+                        container,
+                        name,
+                        field.default,  # type: ignore
+                        "pt-0",
+                        "pb-0",
+                        *TABLE_BUTTON_CLASSES,
+                        front=False,
+                    )
+
+                if field.controls:
+                    handle_controls(container, name, field.controls)
+        else:
+            parent.add_class("channel-regular")