runtimepy 5.4.4__py3-none-any.whl → 5.6.0__py3-none-any.whl

runtimepy/__init__.py

@@ -1,7 +1,7 @@
 # =====================================
 # generator=datazen
 # version=3.1.4
-# hash=5a37b52aedb2af82fb174fbea8ce0c1f
+# hash=6c21c41096ed57b6c6469232c97787cd
 # =====================================
 
 """
@@ -10,7 +10,7 @@ Useful defaults and other package metadata.
 
 DESCRIPTION = "A framework for implementing Python services."
 PKG_NAME = "runtimepy"
-VERSION = "5.4.4"
+VERSION = "5.6.0"
 
 # runtimepy-specific content.
 METRICS_NAME = "metrics"

runtimepy/channel/environment/__init__.py

@@ -29,11 +29,6 @@ class ChannelEnvironment(
 ):
     """A class integrating channel and enumeration registries."""
 
-    @property
-    def names(self) -> _Iterator[str]:
-        """Iterate over registered names in the environment."""
-        yield from self.channels.names.names
-
     def search_names(
         self, pattern: str, exact: bool = False
     ) -> _Iterator[str]:

runtimepy/channel/environment/array.py

@@ -4,6 +4,7 @@ A channel-environment extension for creating arrays of primitives.
 
 # built-in
 from typing import Iterable as _Iterable
+from typing import Iterator as _Iterator
 from typing import NamedTuple
 from typing import Optional as _Optional
 
@@ -23,9 +24,9 @@ class ChannelArray(NamedTuple):
     array: _PrimitiveArray
 
     @staticmethod
-    def create() -> "ChannelArray":
+    def create(**kwargs) -> "ChannelArray":
         """Create a new, empty channel array."""
-        return ChannelArray([], _PrimitiveArray())
+        return ChannelArray([], _PrimitiveArray(**kwargs))
 
 
 class ArrayChannelEnvironment(_BaseChannelEnvironment):
@@ -33,12 +34,19 @@ class ArrayChannelEnvironment(_BaseChannelEnvironment):
     A channel-environment extension for working with arrays of primitives.
     """
 
-    def array(self, keys: _Iterable[_RegistryKey]) -> ChannelArray:
+    @property
+    def names(self) -> _Iterator[str]:
+        """Iterate over registered names in the environment."""
+        yield from self.channels.names.names
+
+    def array(
+        self, keys: _Iterable[_RegistryKey] = None, **kwargs
+    ) -> ChannelArray:
         """
         Create a primitive array from an in-order iterable of registry keys.
         """
 
-        result = ChannelArray.create()
+        result = ChannelArray.create(**kwargs)
 
         curr_fields: _Optional[_BitFields] = None
         invalid_field_names: set[str] = set()
@@ -46,6 +54,9 @@ class ArrayChannelEnvironment(_BaseChannelEnvironment):
 
         names: set[str] = set()
 
+        if keys is None:
+            keys = self.names
+
         for key in keys:
             # All keys must be registered names.
             name = self.channels.names.name(key)

runtimepy/channel/environment/base.py

@@ -24,8 +24,6 @@ from runtimepy.enum import RuntimeEnum as _RuntimeEnum
 from runtimepy.enum.registry import EnumRegistry as _EnumRegistry
 from runtimepy.mixins.finalize import FinalizeMixin
 from runtimepy.primitives import BaseIntPrimitive, StrToBool
-
-# third-party
 from runtimepy.primitives.evaluation import EvalResult, Operator, sample_for
 from runtimepy.primitives.field import BitField as _BitField
 from runtimepy.primitives.field.fields import BitFields as _BitFields

runtimepy/channel/environment/sample.py

@@ -7,19 +7,18 @@ from random import randint, random
 
 # internal
 from runtimepy.channel.environment import ChannelEnvironment
+from runtimepy.enum import RuntimeEnum
 from runtimepy.primitives import Uint8
 from runtimepy.primitives.field import BitField, BitFlag
 
 
-def sample_env(env: ChannelEnvironment = None) -> ChannelEnvironment:
-    """Register sample enumerations and channels to an environment."""
+def sample_int_enum(
+    env: ChannelEnvironment, name: str = "SampleEnum"
+) -> RuntimeEnum:
+    """A sample integer enumeration."""
 
-    if env is None:
-        env = ChannelEnvironment()
-
-    # Register an enum.
-    sample_enum = env.enum(
-        "SampleEnum",
+    return env.enum(
+        name,
         "int",
         items={
             "zero": 0,
@@ -36,12 +35,16 @@ def sample_env(env: ChannelEnvironment = None) -> ChannelEnvironment:
         },
     )
 
-    # Boolean enumeration.
-    env.enum("OnOff", "bool", {"On": True, "Off": False})
-    env.bool_channel("sample_state", commandable=True, enum="OnOff")
 
-    env.enum(
-        "InsanelyLongEnumNameForTesting",
+def long_name_int_enum(
+    env: ChannelEnvironment,
+    name: str = "InsanelyLongEnumNameForTesting",
+    channel: str = "sample_enum",
+) -> RuntimeEnum:
+    """Add an integer enumeration with a long name."""
+
+    result = env.enum(
+        name,
         "int",
         {
             "very_long_member_name_0": 0,
@@ -50,40 +53,101 @@ def sample_env(env: ChannelEnvironment = None) -> ChannelEnvironment:
             "very_long_member_name_3": 3,
         },
     )
-    env.int_channel(
-        "sample_enum", commandable=True, enum="InsanelyLongEnumNameForTesting"
+
+    if channel:
+        env.int_channel(
+            channel,
+            commandable=True,
+            enum="InsanelyLongEnumNameForTesting",
+            description="A sample long-enum-name channel.",
+        )
+
+    return result
+
+
+def sample_bool_enum(
+    env: ChannelEnvironment, name: str = "OnOff", channel: str = "sample_state"
+) -> RuntimeEnum:
+    """A sample boolean enumeration."""
+
+    result = env.enum(name, "bool", {"On": True, "Off": False})
+
+    if channel:
+        env.bool_channel(
+            channel,
+            commandable=True,
+            enum="OnOff",
+            description="A sample on-off state channel.",
+        )
+
+    return result
+
+
+def sample_fields(env: ChannelEnvironment, enum: str = "SampleEnum") -> None:
+    """Add sample bit-fields to an environment."""
+
+    with env.names_pushed("fields"):
+        prim = Uint8()
+        env.int_channel("raw", prim)
+
+        # Add a bit field and flag.
+        env.add_field(BitFlag("flag1", prim, 0))
+        env.add_field(
+            BitFlag(
+                "flag2",
+                prim,
+                1,
+                commandable=True,
+                description="Sample bit flag.",
+            )
+        )
+        env.add_field(
+            BitField(
+                "field1",
+                prim,
+                2,
+                2,
+                enum=enum if enum else None,
+                commandable=True,
+                description="Sample bit field.",
+            )
+        )
+        env.add_field(BitField("field2", prim, 4, 4, commandable=True))
+
+
+def sample_float(
+    env: ChannelEnvironment,
+    channel: str = "sample_float",
+    kind: str = "double",
+) -> None:
+    """Add a sample floating-point channel."""
+
+    env.float_channel(
+        channel,
+        kind,
+        commandable=True,
+        description="A sample floating-point member.",
     )
-    env.float_channel("sample_float", "double", commandable=True)
+
+
+def sample_env(env: ChannelEnvironment = None) -> ChannelEnvironment:
+    """Register sample enumerations and channels to an environment."""
+
+    if env is None:
+        env = ChannelEnvironment()
+
+    # Register an enum.
+    sample_int_enum(env)
+
+    # Boolean enumeration.
+    sample_bool_enum(env)
+
+    long_name_int_enum(env)
+    sample_float(env)
 
     for name in ["a", "b", "c"]:
         with env.names_pushed(name):
-            with env.names_pushed("fields"):
-                prim = Uint8()
-                env.int_channel("raw", prim)
-
-                # Add a bit field and flag.
-                env.add_field(BitFlag("flag1", prim, 0))
-                env.add_field(
-                    BitFlag(
-                        "flag2",
-                        prim,
-                        1,
-                        commandable=True,
-                        description="Sample bit flag.",
-                    )
-                )
-                env.add_field(
-                    BitField(
-                        "field1",
-                        prim,
-                        2,
-                        2,
-                        enum=sample_enum.id,
-                        commandable=True,
-                        description="Sample bit field.",
-                    )
-                )
-                env.add_field(BitField("field2", prim, 4, 4, commandable=True))
+            sample_fields(env)
 
             for i in range(10):
                 with env.names_pushed(str(i)):

runtimepy/commands/all.py

@@ -1,7 +1,7 @@
 # =====================================
 # generator=datazen
 # version=3.1.4
-# hash=5162b7ebed95a36719dad0f72cd0872f
+# hash=1814b7f7fae3556a0dbeec37141e4182
 # =====================================
 
 """
@@ -17,6 +17,7 @@ from vcorelib.args import CommandRegister as _CommandRegister
 
 # internal
 from runtimepy.commands.arbiter import add_arbiter_cmd
+from runtimepy.commands.mtu import add_mtu_cmd
 from runtimepy.commands.server import add_server_cmd
 from runtimepy.commands.task import add_task_cmd
 from runtimepy.commands.tftp import add_tftp_cmd
@@ -32,6 +33,11 @@ def commands() -> _List[_Tuple[str, str, _CommandRegister]]:
             "run a connection-arbiter application from a config",
             add_arbiter_cmd,
         ),
+        (
+            "mtu",
+            "probe for MTU size to some endpoint",
+            add_mtu_cmd,
+        ),
         (
             "server",
             "run a server for a specific connection factory",

runtimepy/commands/mtu.py

@@ -0,0 +1,57 @@
+"""
+An entry-point for the 'mtu' command.
+"""
+
+# built-in
+import argparse
+import socket
+
+# third-party
+from vcorelib.args import CommandFunction
+
+# internal
+from runtimepy.net.mtu import ETHERNET_MTU, UDP_DEFAULT_MTU, discover_mtu
+
+
+def mtu_cmd(args: argparse.Namespace) -> int:
+    """Execute the mtu command."""
+
+    discover_mtu(
+        args.destination[0],
+        *(int(x) for x in args.destination[1:]),
+        probe_size=args.probe_size,
+        fallback=args.fallback,
+        kind=socket.SOCK_STREAM if args.tcp else socket.SOCK_DGRAM,
+    )
+
+    return 0
+
+
+def add_mtu_cmd(parser: argparse.ArgumentParser) -> CommandFunction:
+    """Add mtu-command arguments to its parser."""
+
+    parser.add_argument(
+        "--probe-size",
+        type=int,
+        default=UDP_DEFAULT_MTU,
+        help="data payload size to use for probe (default: %(default)d)",
+    )
+    parser.add_argument(
+        "--fallback",
+        type=int,
+        default=ETHERNET_MTU,
+        help="fallback MTU value if probing doesn't succeed "
+        "(i.e. not on Linux, default: %(default)d)",
+    )
+
+    parser.add_argument(
+        "-t", "--tcp", action="store_true", help="use TCP instead of UDP"
+    )
+
+    parser.add_argument(
+        "destination",
+        nargs="+",
+        help="endpoint parameters (host, port[, flowinfo, scope_id])",
+    )
+
+    return mtu_cmd

runtimepy/commands/server.py

@@ -14,6 +14,9 @@ from vcorelib.args import CommandFunction as _CommandFunction
 from runtimepy.commands.arbiter import arbiter_cmd
 from runtimepy.commands.common import FACTORIES, arbiter_args, cmd_with_jit
 
+SSL_PASSTHROUGH = ["cafile", "capath", "cadata", "certfile"]
+PASSTHROUGH = SSL_PASSTHROUGH + ["keyfile"]
+
 
 def port_name(args: _Namespace, port: str = "port") -> str:
     """Get the name for a connection factory's port."""
@@ -25,7 +28,7 @@ def server_data(args: _Namespace) -> dict[str, Any]:
 
     return {
         "factory": args.factory,
-        "kwargs": {"port": f"${port_name(args)}", "host": args.host},
+        "kwargs": get_kwargs(args, port=f"${port_name(args)}", host=args.host),
     }
 
 
@@ -34,6 +37,26 @@ def is_websocket(args: _Namespace) -> bool:
     return "websocket" in args.factory.lower()
 
 
+def is_ssl(kwargs: dict[str, Any]) -> bool:
+    """Determine if server arugments indicate SSL use."""
+    return any(x in kwargs for x in SSL_PASSTHROUGH)
+
+
+def get_kwargs(args: _Namespace, **kwargs) -> dict[str, Any]:
+    """Get boilerplate kwargs."""
+
+    new_kwargs: dict[str, Any] = {**kwargs}
+
+    # Pass additional arguments through.
+    print(args)
+    for opt in PASSTHROUGH:
+        value = getattr(args, opt, None)
+        if value is not None:
+            new_kwargs[opt] = value
+
+    return new_kwargs
+
+
 def client_data(args: _Namespace) -> dict[str, Any]:
     """Get client data based on command-line arguments."""
 
@@ -43,7 +66,9 @@ def client_data(args: _Namespace) -> dict[str, Any]:
     kwargs: dict[str, Any] = {}
 
     if is_websocket(args):
-        arg_list.append(f"ws://localhost:{port}")
+        arg_list.append(
+            f"ws{'s' if is_ssl(get_kwargs(args)) else ''}://localhost:{port}"
+        )
     elif not args.udp:
         kwargs["host"] = "localhost"
         kwargs["port"] = port
@@ -76,7 +101,9 @@ def config_data(args: _Namespace) -> dict[str, Any]:
             {
                 "name": port_name(args, port="server"),
                 "factory": args.factory,
-                "kwargs": {"local_addr": ["0.0.0.0", f"${port_name(args)}"]},
+                "kwargs": get_kwargs(
+                    args, local_addr=["0.0.0.0", f"${port_name(args)}"]
+                ),
             }
         )
 
@@ -108,6 +135,11 @@ def add_server_cmd(parser: _ArgumentParser) -> _CommandFunction:
     """Add server-command arguments to its parser."""
 
     with arbiter_args(parser, nargs="*"):
+        for optional in PASSTHROUGH:
+            parser.add_argument(
+                f"--{optional}", help="passed directly to instantiation"
+            )
+
         parser.add_argument(
             "--host",
             default="0.0.0.0",

runtimepy/commands/tftp.py

@@ -6,7 +6,6 @@ An entry-point for the 'tftp' command.
 import argparse
 import asyncio
 from pathlib import Path
-from socket import getaddrinfo
 
 # third-party
 from vcorelib.args import CommandFunction
@@ -16,13 +15,16 @@ from vcorelib.asyncio import run_handle_stop
 from runtimepy.net.udp.tftp import TFTP_PORT, tftp_read, tftp_write
 from runtimepy.net.udp.tftp.base import DEFAULT_TIMEOUT_S, REEMIT_PERIOD_S
 from runtimepy.net.udp.tftp.enums import DEFAULT_MODE
+from runtimepy.net.util import normalize_host
 
 
 def tftp_cmd(args: argparse.Namespace) -> int:
     """Execute the tftp command."""
 
+    host = normalize_host(args.host, args.port)
+
     # Resolve hostname as early as possible.
-    addr = (getaddrinfo(args.host, None)[0][4][0], args.port)
+    addr = host.address_str_tuple
 
     stop_sig = asyncio.Event()
     kwargs = {

runtimepy/data/js/classes/TabInterface.js

@@ -43,6 +43,9 @@ class TabInterface {
         /* Update global reference. */
         shown_tab = this.name;
         hash.setTab(shown_tab);
+
+        /* Audit vertical bar position. */
+        this.correctVerticalBarPosition();
       }
       this.worker.send({kind : msg});
     } ];
@@ -51,6 +54,11 @@ class TabInterface {
     this.initCommand();
     this.initControls();
     this.initButton();
+
+    /* Ensure vertical divider is always visible. */
+    window.addEventListener(
+        "resize",
+        ((event) => { this.correctVerticalBarPosition(); }).bind(this));
   }
 
   initCommand() {
@@ -131,9 +139,9 @@ class TabInterface {
     }
 
     /* Initialize channel table and plot divider. */
-    let divider = this.query(".vertical-divider");
-    if (divider) {
-      this.setupVerticalDivider(divider);
+    this.divider = this.query(".vertical-divider");
+    if (this.divider) {
+      this.setupVerticalDivider(this.divider);
     }
 
     /* Initialize sliders. */
@@ -185,12 +193,22 @@ class TabInterface {
 
       let origX = event.clientX || event.touches[0].clientX;
 
+      let barWidth = 0;
+      if (this.divider) {
+        barWidth = this.divider.clientWidth;
+      }
+
       /* Track mouse movement while the mouse is held down. */
       let handleMouse = (event) => {
         let eventX = event.clientX || event.touches[0].clientX;
 
         let deltaX = origX - eventX;
-        elem.style.width = elem.getBoundingClientRect().width - deltaX + "px";
+
+        let rect = elem.getBoundingClientRect();
+
+        /* No use in allowing dragging out of view. */
+        let minWidth = window.innerWidth - (rect.left + barWidth);
+        elem.style.width = Math.min(minWidth, rect.width - deltaX) + "px";
         origX = eventX;
       };
       document.addEventListener(move, handleMouse);
@@ -206,6 +224,21 @@ class TabInterface {
     setupCursorContext(elem, this.setupVerticalDividerEvents.bind(this));
   }
 
+  correctVerticalBarPosition(elem) {
+    if (shown_tab == this.name && this.divider) {
+      let margin =
+          window.innerWidth - this.divider.getBoundingClientRect().right;
+
+      if (margin < 0) {
+        let column = this.query(".channel-column");
+        if (column) {
+          column.style.width =
+              column.getBoundingClientRect().width + margin + "px";
+        }
+      }
+    }
+  }
+
   initPlot() {
     let plot = this.query(`#${this.queryName}-plot`);
     if (plot) {

runtimepy/data/js/util.js

@@ -1,6 +1,15 @@
 function worker_config(config) {
   let worker_cfg = {};
 
+  let port_name = "runtimepy_websocket";
+  let uri_prefix = "ws";
+
+  /* Ensured TLS is handled properly. */
+  if (location.protocol.includes("https")) {
+    port_name = "runtimepy_secure_websocket";
+    uri_prefix += "s";
+  }
+
   /* Look for connections to establish. */
   let ports = config["config"]["ports"];
   for (let port_idx in ports) {
@@ -10,11 +19,11 @@ function worker_config(config) {
     let hostname = window.location.hostname;
 
     /* This business logic could use some work. */
-    if (port["name"].includes("runtimepy_websocket")) {
+    if (port["name"].includes(port_name)) {
       if (port["name"].includes("data")) {
-        worker_cfg["data"] = "ws://" + hostname + ":" + port["port"];
+        worker_cfg["data"] = `${uri_prefix}://${hostname}:` + port["port"];
       } else {
-        worker_cfg["json"] = "ws://" + hostname + ":" + port["port"];
+        worker_cfg["json"] = `${uri_prefix}://${hostname}:` + port["port"];
       }
     }
   }

runtimepy/data/sample_telemetry.yaml

@@ -0,0 +1,29 @@
+---
+factories:
+  - {name: runtimepy.telemetry.sample.SampleTelemetry}
+  - {name: runtimepy.telemetry.sample.SampleTelemetryStruct}
+  - {name: runtimepy.telemetry.sample.SampleTelemetryPeriodic}
+
+structs:
+  - name: tx
+    factory: SampleTelemetryStruct
+  - name: rx
+    factory: SampleTelemetryStruct
+
+tasks:
+  - {name: tlm_periodic, factory: sample_telemetry_periodic, period_s: 0.01}
+
+ports:
+  - {name: udp_sample_telemetry, type: udp}
+
+clients:
+  - factory: SampleTelemetry
+    name: rx_conn
+    kwargs:
+      local_addr: ["0.0.0.0", "$udp_sample_telemetry"]
+
+  - factory: SampleTelemetry
+    name: tx_conn
+    defer: true
+    kwargs:
+      remote_addr: ["127.0.0.1", "$udp_sample_telemetry"]

runtimepy/net/arbiter/info.py

@@ -31,6 +31,8 @@ from runtimepy.net.arbiter.result import OverallResult, results
 from runtimepy.net.connection import Connection as _Connection
 from runtimepy.net.manager import ConnectionManager
 from runtimepy.primitives import Uint32
+from runtimepy.primitives.array import PrimitiveArray
+from runtimepy.primitives.byte_order import DEFAULT_BYTE_ORDER, ByteOrder
 from runtimepy.struct import RuntimeStructBase
 from runtimepy.struct import StructMap as _StructMap
 from runtimepy.task import PeriodicTask, PeriodicTaskManager
@@ -51,15 +53,24 @@ class RuntimeStruct(RuntimeStructBase, _ABC):
     """A class implementing a base runtime structure."""
 
     app: "AppInfo"
+    array: PrimitiveArray
+
+    byte_order: ByteOrder = DEFAULT_BYTE_ORDER
 
     def init_env(self) -> None:
         """Initialize this sample environment."""
 
-    async def build(self, app: "AppInfo") -> None:
+    async def build(self, app: "AppInfo", **kwargs) -> None:
         """Build a struct instance's channel environment."""
 
         self.app = app
         self.init_env()
+        self.update_byte_order(self.byte_order, **kwargs)
+
+    def update_byte_order(self, byte_order: ByteOrder, **kwargs) -> None:
+        """Update the over-the-wire byte order for this struct."""
+
+        self.array = self.env.array(byte_order=byte_order, **kwargs).array
 
 
 W = _TypeVar("W", bound=RuntimeStruct)
@@ -93,9 +104,8 @@ class SampleStruct(TrigStruct):
 
     def init_env(self) -> None:
         """Initialize this sample environment."""
-
-        sample_env(self.env)
         super().init_env()
+        sample_env(self.env)
 
     def poll(self) -> None:
         """