runtimepy 5.14.2__tar.gz → 5.15.0__tar.gz

{runtimepy-5.14.2/runtimepy.egg-info → runtimepy-5.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runtimepy
-Version: 5.14.2
+Version: 5.15.0
 Summary: A framework for implementing Python services.
 Home-page: https://github.com/libre-embedded/runtimepy
 Author: Libre Embedded
@@ -17,11 +17,11 @@ Classifier: Development Status :: 5 - Production/Stable
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiofiles
-Requires-Dist: svgen>=0.7.12
 Requires-Dist: psutil
+Requires-Dist: svgen>=0.8.0
+Requires-Dist: aiofiles
 Requires-Dist: websockets
-Requires-Dist: vcorelib>=3.6.0
+Requires-Dist: vcorelib>=3.6.2
 Provides-Extra: test
 Requires-Dist: pylint; extra == "test"
 Requires-Dist: flake8; extra == "test"
@@ -51,11 +51,11 @@ Dynamic: requires-python
     =====================================
     generator=datazen
     version=3.2.3
-    hash=d3dcde1ba35cb14decfc6881b6a2d4e6
+    hash=db8f45762873863c99d4d7d8f996d2fb
     =====================================
 -->
 
-# runtimepy ([5.14.2](https://pypi.org/project/runtimepy/))
+# runtimepy ([5.15.0](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/libre-embedded/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-5.14.2 → runtimepy-5.15.0}/README.md

@@ -2,11 +2,11 @@
     =====================================
     generator=datazen
     version=3.2.3
-    hash=d3dcde1ba35cb14decfc6881b6a2d4e6
+    hash=db8f45762873863c99d4d7d8f996d2fb
     =====================================
 -->
 
-# runtimepy ([5.14.2](https://pypi.org/project/runtimepy/))
+# runtimepy ([5.15.0](https://pypi.org/project/runtimepy/))
 
 [![python](https://img.shields.io/pypi/pyversions/runtimepy.svg)](https://pypi.org/project/runtimepy/)
 ![Build Status](https://github.com/libre-embedded/runtimepy/workflows/Python%20Package/badge.svg)

{runtimepy-5.14.2 → runtimepy-5.15.0}/pyproject.toml

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

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/__init__.py

@@ -1,7 +1,7 @@
 # =====================================
 # generator=datazen
 # version=3.2.3
-# hash=f2469e97ed5a3a48c5347357f12c3554
+# hash=58f166da9bc0561c671ef04c334d585d
 # =====================================
 
 """
@@ -10,7 +10,7 @@ Useful defaults and other package metadata.
 
 DESCRIPTION = "A framework for implementing Python services."
 PKG_NAME = "runtimepy"
-VERSION = "5.14.2"
+VERSION = "5.15.0"
 
 # runtimepy-specific content.
 METRICS_NAME = "metrics"

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/channel/__init__.py

@@ -29,10 +29,7 @@ from runtimepy.primitives.int import Uint32 as _Uint32
 from runtimepy.primitives.int import Uint64 as _Uint64
 from runtimepy.primitives.types import AnyPrimitiveType as _AnyPrimitiveType
 from runtimepy.registry.item import RegistryItem as _RegistryItem
-
-Literal = int | float | bool
-Default = _Optional[Literal]
-Controls = dict[str, Literal | dict[str, Literal]]
+from runtimepy.ui.controls import Controls, Default
 
 
 class Channel(_RegistryItem, _EnumMixin, _Generic[_T]):

runtimepy-5.15.0/runtimepy/channel/environment/__init__.py

@@ -0,0 +1,149 @@
+"""
+A module implementing a channel environment.
+"""
+
+# built-in
+from contextlib import ExitStack as _ExitStack
+from typing import Iterator as _Iterator
+from typing import Optional
+from typing import cast as _cast
+
+# internal
+from runtimepy.channel.environment.array import (
+    ArrayChannelEnvironment as _ArrayChannelEnvironment,
+)
+from runtimepy.channel.environment.create import (
+    CreateChannelEnvironment as _CreateChannelEnvironment,
+)
+from runtimepy.channel.environment.file import (
+    FileChannelEnvironment as _FileChannelEnvironment,
+)
+from runtimepy.channel.environment.telemetry import (
+    TelemetryChannelEnvironment as _TelemetryChannelEnvironment,
+)
+from runtimepy.codec.protocol import Protocol as _Protocol
+from runtimepy.codec.protocol.base import FieldSpec as _FieldSpec
+from runtimepy.primitives import AnyPrimitive
+from runtimepy.ui.controls import Controls, Default, bit_slider
+
+
+def regular_channel_controls(
+    primitive: AnyPrimitive, commandable: bool
+) -> Optional[Controls]:
+    """Get channel controls for a regular primitive."""
+
+    controls = None
+
+    if commandable and primitive.kind.is_integer and primitive.kind.bits <= 32:
+        controls = bit_slider(primitive.kind.bits, primitive.kind.signed)
+
+    return controls
+
+
+class ChannelEnvironment(
+    _TelemetryChannelEnvironment,
+    _ArrayChannelEnvironment,
+    _FileChannelEnvironment,
+    _CreateChannelEnvironment,
+):
+    """A class integrating channel and enumeration registries."""
+
+    def register_protocol(
+        self, protocol: _Protocol, commandable: bool
+    ) -> None:
+        """Register protocol elements as named channels and fields."""
+
+        # Register any new enumerations.
+        self.enums.register_from_other(protocol.enum_registry)
+
+        # need to handle defaults
+
+        for item in protocol.build:
+            # Handle regular primitive fields.
+            if isinstance(item, _FieldSpec):
+                if item.is_array():
+                    assert item.array_length is not None
+                    with self.names_pushed(item.name):
+                        for idx in range(item.array_length):
+                            primitive = protocol.get_primitive(
+                                item.name, index=idx
+                            )
+                            self.channel(
+                                str(idx),
+                                kind=primitive,
+                                commandable=commandable,
+                                enum=item.enum,
+                                controls=regular_channel_controls(
+                                    primitive, commandable
+                                ),
+                            )
+                else:
+                    primitive = protocol.get_primitive(item.name)
+                    self.channel(
+                        item.name,
+                        kind=primitive,
+                        commandable=commandable,
+                        enum=item.enum,
+                        controls=regular_channel_controls(
+                            primitive, commandable
+                        ),
+                    )
+
+            # Handle nested protocols.
+            elif isinstance(item[0], str):
+                name = item[0]
+                candidates = protocol.serializables[name]
+                if isinstance(candidates[0], _Protocol):
+                    with self.names_pushed(name):
+                        for idx, candidate in enumerate(candidates):
+                            with _ExitStack() as stack:
+                                # Enter array-index namespace if applicable.
+                                if len(candidates) > 1:
+                                    stack.enter_context(
+                                        self.names_pushed(str(idx))
+                                    )
+
+                                self.register_protocol(
+                                    _cast(_Protocol, candidate), commandable
+                                )
+
+            # Handle bit fields.
+            elif isinstance(item[0], int):
+                fields = protocol.get_fields(item[0])
+                for field in fields.fields.values():
+                    field.commandable = commandable
+                    # add sliders for non enum non bool (check enum fields too)
+                self.add_fields(
+                    item[1],
+                    fields,
+                    commandable=commandable,
+                    controls=bit_slider(fields.raw.kind.bits, False),
+                )
+
+    def search_names(
+        self, pattern: str, exact: bool = False
+    ) -> _Iterator[str]:
+        """Search for names belonging to this environment."""
+        yield from self.channels.names.search(pattern, exact=exact)
+
+    def set_default(self, key: str, default: Default) -> None:
+        """Set a new default value for a channel."""
+
+        chan, _ = self[key]
+        chan.default = default
+
+    @property
+    def num_defaults(self) -> int:
+        """
+        Determine the number of channels in this environment configured with
+        a default value.
+        """
+
+        result = 0
+
+        for name in self.names:
+            chan = self.get(name)
+            if chan is not None and chan[0].has_default:
+                result += 1
+
+        return result

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/channel/environment/create.py

@@ -28,6 +28,7 @@ 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.fields import BitFields as _BitFields
 from runtimepy.registry.name import RegistryKey as _RegistryKey
 
 
@@ -74,10 +75,22 @@ class CreateChannelEnvironment(_BaseChannelEnvironment):
 
         # Keep track of any new enum channels.
         if enum is not None:
-            self.channel_enums[result] = self.enums[enum]
+            runtime = self.enums[enum]
+            self.channel_enums[result] = runtime
+            if runtime.default:
+                self[name] = runtime.default
 
         return self[name]
 
+    def add_fields(
+        self, name: str, fields: _BitFields, **channel_kwargs
+    ) -> None:
+        """Add bit fields to this channel environment."""
+
+        self.channel(name, kind=fields.raw, **channel_kwargs)
+        with self.names_pushed(name):
+            self.fields.add(fields, namespace=self._namespace, track=True)
+
     def int_channel(
         self,
         name: str,
@@ -171,6 +184,7 @@ class CreateChannelEnvironment(_BaseChannelEnvironment):
         items: _EnumMappingData = None,
         namespace: _Namespace = None,
         primitive: str = DEFAULT_ENUM_PRIMITIVE,
+        **kwargs,
     ) -> _RuntimeEnum:
         """Create a new enum from the environment."""
 
@@ -179,6 +193,7 @@ class CreateChannelEnvironment(_BaseChannelEnvironment):
             kind=kind,
             items=items,
             primitive=primitive,
+            **kwargs,
         )
         assert result is not None, f"Can't create enum '{name}'!"
         return result

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/channel/environment/sample.py

@@ -33,6 +33,7 @@ def sample_int_enum(
             "nine": 9,
             "ten": 10,
         },
+        default="three",
     )
 
 
@@ -99,6 +100,7 @@ def sample_fields(env: ChannelEnvironment, enum: str = "SampleEnum") -> None:
                 1,
                 commandable=True,
                 description="Sample bit flag.",
+                default=True,
             )
         )
         env.add_field(
@@ -109,13 +111,19 @@ def sample_fields(env: ChannelEnvironment, enum: str = "SampleEnum") -> None:
                 2,
                 enum=enum if enum else None,
                 commandable=True,
+                default="three" if enum else 3,
                 description="Sample bit field.",
             )
         )
         env.add_field(
             BitField(
-                env.namespace(name="field2"), prim, 4, 4, commandable=True
-            )
+                env.namespace(name="field2"),
+                prim,
+                4,
+                4,
+                default=0,
+                commandable=True,
+            ).set_slider()
         )
 
 

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/channel/registry.py

@@ -16,7 +16,6 @@ from vcorelib.io.types import JsonObject as _JsonObject
 # internal
 from runtimepy.channel import AnyChannel as _AnyChannel
 from runtimepy.channel import Channel as _Channel
-from runtimepy.channel import Default as _Default
 from runtimepy.channel.event.header import PrimitiveEventHeader
 from runtimepy.codec.protocol import Protocol
 from runtimepy.mapping import DEFAULT_PATTERN
@@ -29,7 +28,7 @@ from runtimepy.primitives.types.base import PythonPrimitive
 from runtimepy.registry import Registry as _Registry
 from runtimepy.registry.name import NameRegistry as _NameRegistry
 from runtimepy.registry.name import RegistryKey as _RegistryKey
-from runtimepy.ui.controls import Controlslike, normalize_controls
+from runtimepy.ui.controls import Controlslike, Default, normalize_controls
 
 
 class ChannelNameRegistry(_NameRegistry):
@@ -92,7 +91,7 @@ class ChannelRegistry(_Registry[_Channel[_Any]]):
         enum: _RegistryKey = None,
         scaling: ChannelScaling = None,
         description: str = None,
-        default: _Default = None,
+        default: Default = None,
         controls: Controlslike = None,
         **kwargs,
     ) -> _Optional[_AnyChannel]:

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/codec/protocol/base.py

@@ -47,6 +47,10 @@ class FieldSpec(NamedTuple):
     enum: _Optional[_RegistryKey] = None
     array_length: _Optional[int] = None
 
+    def is_array(self) -> bool:
+        """Determine if this instance is an array."""
+        return self.array_length is not None and self.array_length > 1
+
     def asdict(self) -> _JsonObject:
         """Obtain a dictionary representing this instance."""
 
@@ -91,14 +95,14 @@ class ProtocolBase(PrimitiveArray):
         self.alias = alias
 
         # Register the byte-order enumeration if it's not present.
-        self._enum_registry = enum_registry
-        if not self._enum_registry.get("ByteOrder"):
-            _ByteOrder.register_enum(self._enum_registry)
+        self.enum_registry = enum_registry
+        if not self.enum_registry.get("ByteOrder"):
+            _ByteOrder.register_enum(self.enum_registry)
 
         # Each instance gets its own array.
         if not isinstance(byte_order, _ByteOrder):
             byte_order = _ByteOrder(
-                self._enum_registry["ByteOrder"].get_int(byte_order)
+                self.enum_registry["ByteOrder"].get_int(byte_order)
             )
 
         super().__init__(byte_order=byte_order)
@@ -108,14 +112,14 @@ class ProtocolBase(PrimitiveArray):
         self.names = names
 
         if fields is None:
-            fields = BitFieldsManager(self.names, self._enum_registry)
+            fields = BitFieldsManager(self.names, self.enum_registry)
         self._fields = fields
 
         self._regular_fields: dict[str, list[_AnyPrimitive]] = {}
         self._enum_fields: dict[str, _RuntimeEnum] = {}
 
         # Keep track of the order that the protocol was created.
-        self._build: ProtocolBuild = []
+        self.build: ProtocolBuild = []
 
         # Keep track of named serializables.
         self.serializables: SerializableMap = {}
@@ -154,10 +158,10 @@ class ProtocolBase(PrimitiveArray):
         """Create another protocol instance from this one."""
 
         return self.__class__(
-            self._enum_registry,
+            self.enum_registry,
             names=self.names,
             fields=_copy(self._fields),
-            build=self._build,
+            build=self.build,
             byte_order=self.byte_order,
             identifier=self.id,
             identifier_primitive=self.id_primitive.kind.name,
@@ -183,7 +187,7 @@ class ProtocolBase(PrimitiveArray):
         self.register_name(name)
 
         instances = self.add_to_end(serializable, array_length=array_length)
-        self._build.append((name, len(instances)))
+        self.build.append((name, len(instances)))
 
         assert name not in self.serializables, name
         self.serializables[name] = instances
@@ -209,8 +213,9 @@ class ProtocolBase(PrimitiveArray):
 
         self.register_name(name)
 
+        runtime_enum = None
         if enum is not None:
-            runtime_enum = self._enum_registry[enum]
+            runtime_enum = self.enum_registry[enum]
             self._enum_fields[name] = runtime_enum
 
             # Allow the primitive type to be overridden when passed as a
@@ -221,13 +226,20 @@ class ProtocolBase(PrimitiveArray):
         assert kind is not None
         inst = _normalize_instance(kind)
 
+        # Set enum defaults.
+        if runtime_enum is not None and runtime_enum.default:
+            inst.value = runtime_enum.get_int(runtime_enum.default)
+
         assert name not in self._regular_fields, name
         self._regular_fields[name] = self.add(inst, array_length=array_length)
 
         if track:
-            self._build.append(
+            self.build.append(
                 FieldSpec(
-                    name, inst.kind.name, enum, array_length=array_length
+                    name,
+                    inst.kind.name,
+                    enum,
+                    array_length=array_length,
                 )
             )
 
@@ -240,7 +252,7 @@ class ProtocolBase(PrimitiveArray):
         if index is None:
             index = self._fields.add(fields)
 
-        self._build.append((index, name))
+        self.build.append((index, name))
         self.add_field(name, kind=fields.raw, track=False)
 
     @contextmanager
@@ -253,6 +265,14 @@ class ProtocolBase(PrimitiveArray):
         yield new
         self._add_bit_fields(name, new)
 
+    def get_primitive(self, name: str, index: int = 0) -> _AnyPrimitive:
+        """Get an underlying primitive instance."""
+        return self._regular_fields[name][index]
+
+    def get_fields(self, index: int) -> _BitFields:
+        """Get a bit-fields instance from its build identifier."""
+        return self._fields.fields[index]
+
     def value(
         self, name: str, resolve_enum: bool = True, index: int = 0
     ) -> ProtocolPrimitive:
@@ -261,7 +281,7 @@ class ProtocolBase(PrimitiveArray):
         val: ProtocolPrimitive = 0
 
         if name in self._regular_fields:
-            val = self._regular_fields[name][index].value
+            val = self.get_primitive(name, index=index).value
 
             # Resolve the enum value.
             if resolve_enum and name in self._enum_fields:

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/codec/protocol/json.py

@@ -74,7 +74,7 @@ class JsonProtocol(ProtocolBase):
         json_obj.update(
             {
                 name: _cast(_JsonValue, val.asdict())
-                for name, val in self._enum_registry.items.items()
+                for name, val in self.enum_registry.items.items()
                 if val.id in enum_ids and name not in json_obj
             }
         )
@@ -83,7 +83,7 @@ class JsonProtocol(ProtocolBase):
         build: list[
             _Union[tuple[int, str], _JsonObject, str, tuple[str, int]]
         ] = []
-        for item in self._build:
+        for item in self.build:
             if isinstance(item, FieldSpec):
                 build.append(item.asdict())
             else:
@@ -120,7 +120,9 @@ class JsonProtocol(ProtocolBase):
             if isinstance(item, dict):
                 build.append(
                     FieldSpec(
-                        item["name"], item["kind"], enum=item.get("enum")
+                        item["name"],
+                        item["kind"],
+                        enum=item.get("enum"),
                     )
                 )
             else:

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/codec/system/__init__.py

@@ -14,6 +14,7 @@ from vcorelib.namespace import CPP_DELIM, Namespace
 from runtimepy.codec.protocol import Protocol
 from runtimepy.enum import RuntimeEnum
 from runtimepy.enum.registry import DEFAULT_ENUM_PRIMITIVE, RuntimeIntEnum
+from runtimepy.mixins.logging import LogLevel
 from runtimepy.primitives.byte_order import (
     DEFAULT_BYTE_ORDER,
     ByteOrder,
@@ -65,7 +66,7 @@ class TypeSystem(LoggerMixin):
         self.root_namespace = global_namespace
 
         # Register enums.
-        for enum in [ByteOrder]:
+        for enum in [ByteOrder, LogLevel]:
             self.runtime_int_enum(enum)
 
         self.root_namespace = global_namespace.child(*namespace)
@@ -103,12 +104,15 @@ class TypeSystem(LoggerMixin):
         items: dict[str, int],
         *namespace: str,
         primitive: str = DEFAULT_ENUM_PRIMITIVE,
+        default: Union[str, bool, int] = None,
     ) -> None:
         """Register an enumeration."""
 
         name = self._name(name, *namespace, check_available=True)
 
-        enum = self._enums.enum(name, "int", items=items, primitive=primitive)
+        enum = self._enums.enum(
+            name, "int", items=items, primitive=primitive, default=default
+        )
         assert enum is not None
         self._register_primitive(name, enum.primitive)
 

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/control/source.py

@@ -62,7 +62,7 @@ class PrimitiveSource(RuntimeStruct, Generic[T]):
             )
 
 
-class DoubleSource(PrimitiveSource[Double]):
+class DoubleSource(PrimitiveSource[Double]):  # pylint:disable=abstract-method
     """A simple double output source."""
 
     kind = Double

runtimepy-5.15.0/runtimepy/data/404.md

@@ -0,0 +1,16 @@
+# Resource Not Found (404)
+
+---
+
+<span id="target-label">target: <a id="target"></a></span>
+<script>
+const target = new URLSearchParams(window.location.search).get("target");
+if (target) {
+  document.getElementById("target").href = target;
+  document.getElementById("target").innerHTML = target;
+} else {
+  document.getElementById("target-label").style.display = "none";
+}
+</script>
+
+home: [/](/)

{runtimepy-5.14.2 → runtimepy-5.15.0}/runtimepy/data/base.yaml

@@ -9,6 +9,9 @@ config:
   # Default redirects.
   http_redirects:
     "/": "/index.html"
+
+    # wait for #326
+    # "/index.html": "/mux.html"
     "/index.html": "/app.html"
 
   # Serve these applications by default at these paths.