runtimepy 4.2.0__tar.gz → 4.2.2__tar.gz

{runtimepy-4.2.0/runtimepy.egg-info → runtimepy-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: runtimepy
-Version: 4.2.0
+Version: 4.2.2
 Summary: A framework for implementing Python services.
 Home-page: https://github.com/vkottler/runtimepy
 Author: Vaughn Kottler
@@ -17,10 +17,10 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: websockets
+Requires-Dist: psutil
 Requires-Dist: vcorelib>=3.2.4
 Requires-Dist: svgen>=0.6.6
-Requires-Dist: psutil
+Requires-Dist: websockets
 Provides-Extra: test
 Requires-Dist: pylint; extra == "test"
 Requires-Dist: flake8; extra == "test"
@@ -44,11 +44,11 @@ Requires-Dist: uvloop; (sys_platform != "win32" and sys_platform != "cygwin") an
     =====================================
     generator=datazen
     version=3.1.4
-    hash=e23f54e60d0c62ebc1be3cae63bc7678
+    hash=5f56531d1be3002a8547ddb013d713f9
     =====================================
 -->
 
-# runtimepy ([4.2.0](https://pypi.org/project/runtimepy/))
+# runtimepy ([4.2.2](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/vkottler/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-4.2.0 → runtimepy-4.2.2}/README.md

@@ -2,11 +2,11 @@
     =====================================
     generator=datazen
     version=3.1.4
-    hash=e23f54e60d0c62ebc1be3cae63bc7678
+    hash=5f56531d1be3002a8547ddb013d713f9
     =====================================
 -->
 
-# runtimepy ([4.2.0](https://pypi.org/project/runtimepy/))
+# runtimepy ([4.2.2](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/vkottler/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-4.2.0 → runtimepy-4.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "runtimepy"
-version = "4.2.0"
+version = "4.2.2"
 description = "A framework for implementing Python services."
 readme = "README.md"
 requires-python = ">=3.11"

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/__init__.py

@@ -1,7 +1,7 @@
 # =====================================
 # generator=datazen
 # version=3.1.4
-# hash=58424f506ef1e5d09db770f3e0dd8fce
+# hash=9427b9a1aadbcbc5e128b88c10b37dbe
 # =====================================
 
 """
@@ -10,7 +10,7 @@ Useful defaults and other package metadata.
 
 DESCRIPTION = "A framework for implementing Python services."
 PKG_NAME = "runtimepy"
-VERSION = "4.2.0"
+VERSION = "4.2.2"
 
 # runtimepy-specific content.
 METRICS_NAME = "metrics"

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/environment/__init__.py

@@ -15,23 +15,19 @@ from runtimepy.channel.environment.create import (
 from runtimepy.channel.environment.file import (
     FileChannelEnvironment as _FileChannelEnvironment,
 )
-from runtimepy.channel.registry import ParsedEvent
+from runtimepy.channel.environment.telemetry import (
+    TelemetryChannelEnvironment as _TelemetryChannelEnvironment,
+)
 
 
 class ChannelEnvironment(
+    _TelemetryChannelEnvironment,
     _ArrayChannelEnvironment,
     _FileChannelEnvironment,
     _CreateChannelEnvironment,
 ):
     """A class integrating channel and enumeration registries."""
 
-    def ingest(self, point: ParsedEvent) -> None:
-        """
-        Update internal state based on an event. Note that the event timestamp
-        is not respected.
-        """
-        self.set(point.name, point.value)
-
     @property
     def names(self) -> _Iterator[str]:
         """Iterate over registered names in the environment."""

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/environment/base.py

@@ -73,6 +73,8 @@ class BaseChannelEnvironment(_NamespaceMixin, FinalizeMixin):
             for field in fields:
                 self.fields.add(field)
 
+        self.to_add: list[_BitFields] = []
+
         # Keep a mapping of each channel's name and integer identifier to the
         # underlying enumeration.
         self.channel_enums: dict[_AnyChannel, _RuntimeEnum] = {
@@ -282,3 +284,20 @@ class BaseChannelEnvironment(_NamespaceMixin, FinalizeMixin):
             prim = self.fields[key].raw
 
         return prim.age_ns()
+
+    def add_field(self, field: _BitField, namespace: Namespace = None) -> str:
+        """Add a bit field to the environment."""
+
+        result = self.fields.add_field(field)
+        if result is not None:
+            self.to_add.append(result)
+
+        return self.namespace(name=field.name, namespace=namespace)
+
+    def finalize(self, strict: bool = True) -> None:
+        """Finalize this instance."""
+
+        for fields in self.to_add:
+            self.fields.add(fields)
+
+        super().finalize(strict=strict)

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/environment/command/__init__.py

@@ -25,7 +25,8 @@ from runtimepy.channel.environment.command.processor import (
     EnvironmentMap,
 )
 from runtimepy.channel.registry import ParsedEvent
-from runtimepy.mapping import DEFAULT_PATTERN, name_search
+from runtimepy.mapping import DEFAULT_PATTERN
+from runtimepy.util import name_search
 
 # Declared so we re-export FieldOrChannel after moving where it's declared.
 __all__ = [
@@ -115,7 +116,7 @@ class GlobalEnvironment(UserDict[str, ChannelCommandProcessor], LoggerMixin):
         """Reade events from a specific environment."""
 
         with self.valid_root.joinpath(env, path).open("rb") as path_fd:
-            yield from self[env].env.channels.parse_event_stream(path_fd)
+            yield from self[env].env.parse_event_stream(path_fd)
 
     def export(self, env: str) -> Path:
         """Export an environment to a sub-directory of the root directory."""

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/environment/create.py

@@ -28,8 +28,6 @@ from runtimepy.enum.types import EnumTypelike as _EnumTypelike
 from runtimepy.mapping import EnumMappingData as _EnumMappingData
 from runtimepy.primitives import ChannelScaling, Primitive
 from runtimepy.primitives import Primitivelike as _Primitivelike
-from runtimepy.primitives.field import BitField
-from runtimepy.primitives.field.fields import BitFields
 from runtimepy.registry.name import RegistryKey as _RegistryKey
 
 
@@ -184,15 +182,3 @@ class CreateChannelEnvironment(_BaseChannelEnvironment):
         )
         assert result is not None, f"Can't create enum '{name}'!"
         return result
-
-    def add_field(self, field: BitField, namespace: _Namespace = None) -> str:
-        """Add a bit field to the environment."""
-
-        fields = BitFields.new()
-        fields.claim_field(field)
-
-        name = self.namespace(name=field.name, namespace=namespace)
-
-        self.fields.add(fields)
-
-        return name

runtimepy-4.2.2/runtimepy/channel/environment/telemetry.py

@@ -0,0 +1,173 @@
+"""
+A module implementing channel-environment telemetry registration.
+"""
+
+# built-in
+from contextlib import ExitStack, contextmanager
+from typing import BinaryIO, Iterator, Optional, cast
+
+# internal
+from runtimepy.channel.environment.base import (
+    BaseChannelEnvironment as _BaseChannelEnvironment,
+)
+from runtimepy.channel.event import PrimitiveEvent
+from runtimepy.channel.registry import ParsedEvent
+from runtimepy.mapping import DEFAULT_PATTERN
+from runtimepy.metrics.channel import ChannelMetrics
+from runtimepy.util import name_search
+
+
+class TelemetryChannelEnvironment(_BaseChannelEnvironment):
+    """A class integrating telemetry streaming."""
+
+    events: list[str]
+
+    @contextmanager
+    def registered(
+        self,
+        stream: BinaryIO,
+        pattern: str = DEFAULT_PATTERN,
+        exact: bool = False,
+        flush: bool = False,
+        channel: ChannelMetrics = None,
+    ) -> Iterator[list[str]]:
+        """
+        Register a stream as a managed context. Returns a list of all channels
+        registered.
+        """
+
+        names: list[str] = []
+        events: list[PrimitiveEvent] = []
+
+        # Gather event telemetry emitters for bit-fields.
+        for fields in self.fields.fields:
+            for name in name_search(fields.fields, pattern, exact=exact):
+                names.append(name)
+                field = fields.fields[name]
+
+                ident = self.channels.names.identifier(name)
+                assert ident is not None, name
+
+                events.append(PrimitiveEvent(field.raw, ident))
+
+        with ExitStack() as stack:
+            # Register bit-field event telemetry.
+            for event in events:
+                stack.enter_context(
+                    event.registered(
+                        stream, flush=flush, channel=channel, force=True
+                    )
+                )
+
+            # Register channel telemetry.
+            names += stack.enter_context(
+                self.channels.registered(
+                    stream,
+                    pattern=pattern,
+                    exact=exact,
+                    flush=flush,
+                    channel=channel,
+                )
+            )
+
+            yield names
+
+    def ingest(self, point: ParsedEvent) -> None:
+        """
+        Update internal state based on an event. Note that the event timestamp
+        is not respected.
+        """
+
+        if self.fields.has_field(point.name):
+            self.fields[point.name].raw.value = point.value  # type: ignore
+        else:
+            self.set(point.name, point.value)
+
+    def _parse_channel_event(self, name: str) -> Optional[ParsedEvent]:
+        """Attempt to parse a channel event from the fifo."""
+
+        result = None
+        channels = self.channels
+
+        kind = channels[name].type
+        data = channels.event_fifo.pop(kind.size)
+        if data is not None:
+            result = ParsedEvent(
+                name,
+                cast(int, channels.event_header["timestamp"]),
+                kind.decode(
+                    data,
+                    byte_order=channels.event_header.array.byte_order,
+                ),
+            )
+
+        return result
+
+    def _parse_field_event(self, name: str) -> Optional[ParsedEvent]:
+        """Attempt to parse a bit-field event from the fifo."""
+
+        result = None
+
+        field = self.fields[name]
+
+        kind = field.raw.kind
+        data = self.channels.event_fifo.pop(kind.size)
+        if data is not None:
+            result = ParsedEvent(
+                name,
+                cast(int, self.channels.event_header["timestamp"]),
+                kind.decode(
+                    data,
+                    byte_order=self.channels.event_header.array.byte_order,
+                ),
+            )
+
+        return result
+
+    def parse_event_stream(self, stream: BinaryIO) -> Iterator[ParsedEvent]:
+        """Parse individual events from a stream."""
+
+        channels = self.channels
+
+        # Ingest stream.
+        channels.event_fifo.ingest(stream.read())
+
+        ident = -1
+        name = ""
+
+        keep_going = True
+        while keep_going:
+            keep_going = False
+
+            # Read header.
+            if not channels.header_ready:
+                read_size = channels.event_header.size
+                data = channels.event_fifo.pop(read_size)
+                if data is not None:
+                    channels.event_header.array.update(data)
+
+                    # Update local variables.
+                    ident = cast(int, channels.event_header["identifier"])
+                    name = channels.names.name(ident)  # type: ignore
+                    assert name is not None, ident
+
+                    # Update state.
+                    channels.header_ready = True
+                    keep_going = True
+            else:
+                event = None
+
+                # Handle bit-field.
+                if self.fields.has_field(name):
+                    event = self._parse_field_event(name)
+
+                # Handle channel.
+                elif name in channels.items:
+                    event = self._parse_channel_event(name)
+
+                if event is not None:
+                    yield event
+
+                    # Update state.
+                    channels.header_ready = False
+                    keep_going = True

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/event/__init__.py

@@ -44,6 +44,7 @@ class PrimitiveEvent:
         stream: BinaryIO,
         flush: bool = False,
         channel: ChannelMetrics = None,
+        force: bool = False,
     ) -> Iterator[None]:
         """Register a stream as a managed context."""
 
@@ -51,7 +52,7 @@ class PrimitiveEvent:
 
         def callback(_, __) -> None:
             """Emit a change event to the stream."""
-            self._poll(stream, flush=flush, channel=channel)
+            self._poll(stream, flush=flush, channel=channel, force=force)
 
         # Poll immediately.
         self.prev_ns = 0
@@ -71,6 +72,7 @@ class PrimitiveEvent:
         stream: BinaryIO,
         flush: bool = False,
         channel: ChannelMetrics = None,
+        force: bool = False,
     ) -> int:
         """
         Poll this event so that if the underlying channel has changed since the
@@ -83,7 +85,7 @@ class PrimitiveEvent:
         raw = self.primitive
         curr_ns = raw.last_updated_ns
 
-        if curr_ns - self.prev_ns >= self.min_period_ns:
+        if force or curr_ns - self.prev_ns >= self.min_period_ns:
             self.prev_ns = curr_ns
             self.header["timestamp"] = curr_ns
 

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/channel/registry.py

@@ -7,7 +7,7 @@ from contextlib import ExitStack, contextmanager
 from typing import Any as _Any
 from typing import BinaryIO, Iterable, Iterator, NamedTuple
 from typing import Optional as _Optional
-from typing import Union, cast
+from typing import Union
 
 # third-party
 from vcorelib.io import ByteFifo
@@ -150,47 +150,3 @@ class ChannelRegistry(_Registry[_Channel[_Any]]):
                 names.append(name)
 
             yield names
-
-    def parse_event_stream(self, stream: BinaryIO) -> Iterator[ParsedEvent]:
-        """Parse individual events from a stream."""
-
-        # Ingest stream.
-        self.event_fifo.ingest(stream.read())
-
-        ident = -1
-        name = ""
-
-        keep_going = True
-        while keep_going:
-            keep_going = False
-
-            # Read header.
-            if not self.header_ready:
-                read_size = self.event_header.size
-                data = self.event_fifo.pop(read_size)
-                if data is not None:
-                    self.event_header.array.update(data)
-
-                    # Update local variables.
-                    ident = cast(int, self.event_header["identifier"])
-                    name = self.names.name(ident)  # type: ignore
-                    assert name is not None, ident
-
-                    # Update state.
-                    self.header_ready = True
-                    keep_going = True
-            else:
-                kind = self[name].type
-                data = self.event_fifo.pop(kind.size)
-                if data is not None:
-                    yield ParsedEvent(
-                        name,
-                        cast(int, self.event_header["timestamp"]),
-                        kind.decode(
-                            data, byte_order=self.event_header.array.byte_order
-                        ),
-                    )
-
-                    # Update state.
-                    self.header_ready = False
-                    keep_going = True

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/dummy_load.yaml

@@ -11,6 +11,21 @@ tasks:
   - {name: wave2, factory: sinusoid, period_s: 0.02}
   - {name: wave3, factory: sinusoid, period_s: 0.03}
 
+  # Drive interactions with runtime entities that won't otherwise be polled.
+  - {name: app, factory: SampleApp, period_s: 0.25}
+
+# UDP JSON clients.
+clients:
+  - factory: udp_json
+    name: udp_json_client
+    defer: true
+    kwargs:
+      remote_addr: [localhost, "$udp_json"]
+  - factory: udp_json
+    name: udp_json_server
+    kwargs:
+      local_addr: [localhost, "$udp_json"]
+
 # Add some sample structs.
 structs:
   - name: example.struct1

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/factories.yaml

@@ -25,6 +25,7 @@ factories:
   # Useful tasks.
   - {name: runtimepy.task.trig.Sinusoid}
   - {name: runtimepy.task.sample.Sample}
+  - {name: runtimepy.task.sample.SampleApp}
 
   # Useful structs.
   - {name: runtimepy.net.arbiter.info.SampleStruct}

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/js/classes/TabFilter.js

@@ -15,6 +15,8 @@ class TabFilter {
   }
 
   updateStyles(pattern) {
+    hash.setTabFilter(pattern);
+
     if (!pattern) {
       pattern = ".*";
     }

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/js/classes/TabInterface.js

@@ -71,6 +71,8 @@ class TabInterface {
   }
 
   updateChannelStyles(pattern) {
+    hash.handleChannelFilter(this.name, pattern);
+
     if (!pattern) {
       pattern = ".*";
     }
@@ -96,6 +98,7 @@ class TabInterface {
       } else {
         curr += event.key;
       }
+
       this.updateChannelStyles(curr);
     }
   }

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/js/classes/WindowHashManager.js

@@ -4,9 +4,11 @@ class WindowHashManager {
     this.original = this.hash();
 
     this.tab = "";
+    this.tabFilter = "";
     this.tabsShown = true;
     this.channelsShown = true;
     this.plotChannels = {};
+    this.filters = {};
   }
 
   tabClick(event) {
@@ -29,6 +31,11 @@ class WindowHashManager {
     this.update();
   }
 
+  handleChannelFilter(tabName, value) {
+    this.filters[tabName] = value;
+    this.update();
+  }
+
   handlePlotChannelToggle(tabName, channel, state) {
     /* Service settings modal. */
     if (modalManager) {
@@ -51,6 +58,29 @@ class WindowHashManager {
     }
   }
 
+  setTabFilter(value) {
+    this.tabFilter = value;
+    this.update();
+  }
+
+  updateTabFilter(value) {
+    this.tabFilter = value;
+    if (tabFilter) {
+      tabFilter.input.value = value;
+      tabFilter.updateStyles(value);
+    }
+  }
+
+  setTabChannelFilter(tabName, value) {
+    this.filters[tabName] = value;
+
+    let elem = tabs[tabName].query("#channel-filter");
+    if (elem) {
+      elem.value = value;
+      tabs[tabName].updateChannelStyles(value);
+    }
+  }
+
   clearPlotChannels(tabName) {
     if (tabName in this.plotChannels) {
       let channels = this.plotChannels[tabName];
@@ -85,7 +115,16 @@ class WindowHashManager {
       for (let i = 1; i < boolsChannels.length; i++) {
         let nameChannels = boolsChannels[i].split(":");
         for (let chan of nameChannels[1].split(",")) {
-          this.togglePlotChannel(nameChannels[0], chan);
+          if (!chan.includes("=")) {
+            /* Handle regular channel names. */
+            this.togglePlotChannel(nameChannels[0], chan);
+          } else {
+            /* Handle key-value pairs. */
+            let keyVal = chan.split("=");
+            if (keyVal.length == 2 && keyVal[0] == "filter" && keyVal[1]) {
+              this.setTabChannelFilter(nameChannels[0], keyVal[1]);
+            }
+          }
         }
       }
 
@@ -95,6 +134,16 @@ class WindowHashManager {
       if (split.includes("hide-channels")) {
         channelsButton.click();
       }
+
+      /* Check for tab filter. */
+      for (let item of split) {
+        if (item.includes("=")) {
+          let keyVal = item.split("=");
+          if (keyVal.length == 2 && keyVal[0] == "filter" && keyVal[1]) {
+            this.updateTabFilter(keyVal[1]);
+          }
+        }
+      }
     }
   }
 
@@ -109,6 +158,9 @@ class WindowHashManager {
   update() {
     let hash = this.tab;
 
+    if (this.tabFilter) {
+      hash += ",filter=" + this.tabFilter;
+    }
     if (!this.tabsShown) {
       hash += ",hide-tabs"
     }
@@ -116,22 +168,40 @@ class WindowHashManager {
       hash += ",hide-channels"
     }
 
-    for (let tab in this.plotChannels) {
+    for (let tab in tabs) {
       let firstChan = true;
-      let channels = this.plotChannels[tab];
-      for (let name in channels) {
-        if (channels[name]) {
-          if (firstChan) {
-            hash += "/" + tab + ":"
-            firstChan = false;
-          }
 
-          if (hash.slice(-1) != ":") {
-            hash += ",";
+      /* Write plot channels if present. */
+      if (tab in this.plotChannels) {
+        let channels = this.plotChannels[tab];
+
+        for (let name in channels) {
+          if (channels[name]) {
+            if (firstChan) {
+              hash += "/" + tab + ":"
+              firstChan = false;
+            }
+
+            if (hash.slice(-1) != ":") {
+              hash += ",";
+            }
+            hash += name;
           }
-          hash += name;
         }
       }
+
+      /* Write tab filter if present. */
+      if (tab in this.filters && this.filters[tab]) {
+        if (firstChan) {
+          hash += "/" + tab + ":"
+          firstChan = false;
+        }
+
+        if (hash.slice(-1) != ":") {
+          hash += ",";
+        }
+        hash += "filter=" + this.filters[tab];
+      }
     }
 
     window.location.hash = hash;

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/js/util.js

@@ -22,6 +22,8 @@ function worker_config(config) {
   return worker_cfg;
 }
 
+let tabFilter = undefined;
+
 function bootstrap_init() {
   /*
    * Enable tooltips.
@@ -34,6 +36,6 @@ function bootstrap_init() {
   /* Initialize tab filter. */
   let tabs = document.getElementById("runtimepy-tabs");
   if (tabs) {
-    const tabFilter = new TabFilter(tabs);
+    tabFilter = new TabFilter(tabs);
   }
 }

{runtimepy-4.2.0 → runtimepy-4.2.2}/runtimepy/data/schemas/BitFields.yaml

@@ -27,6 +27,9 @@ properties:
           type: string
           pattern: "^[a-z0-9-_.]+$"
 
+        commandable:
+          type: boolean
+
         description:
           type: string