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

runtimepy/net/udp/connection.py

@@ -12,9 +12,11 @@ from typing import Any as _Any
 from typing import Optional as _Optional
 from typing import TypeVar as _TypeVar
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.net import IpHost, get_free_socket, normalize_host
-from runtimepy.net.connection import BinaryMessage as _BinaryMessage
 from runtimepy.net.connection import Connection as _Connection
 from runtimepy.net.connection import EchoConnection as _EchoConnection
 from runtimepy.net.connection import NullConnection as _NullConnection
@@ -86,11 +88,13 @@ class UdpConnection(_Connection, _TransportMixin):
 
     @_abstractmethod
     async def process_datagram(
-        self, data: bytes, addr: tuple[str, int]
+        self, data: BinaryMessage, addr: tuple[str, int]
     ) -> bool:
         """Process a datagram."""
 
-    def sendto(self, data: bytes, addr: IpHostTuplelike = None) -> None:
+    def sendto(
+        self, data: BinaryMessage, addr: IpHostTuplelike = None
+    ) -> None:
         """Send to a specific address."""
 
         try:
@@ -108,7 +112,7 @@ class UdpConnection(_Connection, _TransportMixin):
         """Enqueue a text message to send."""
         self.sendto(data.encode(), addr=self.remote_address)
 
-    def send_binary(self, data: _BinaryMessage) -> None:
+    def send_binary(self, data: BinaryMessage) -> None:
         """Enqueue a binary message to send."""
         self.sendto(data, addr=self.remote_address)
 
@@ -216,7 +220,7 @@ class EchoUdpConnection(UdpConnection, _EchoConnection):
     """An echo connection for UDP."""
 
     async def process_datagram(
-        self, data: bytes, addr: tuple[str, int]
+        self, data: BinaryMessage, addr: tuple[str, int]
     ) -> bool:
         """Process a datagram."""
 
@@ -228,7 +232,7 @@ class NullUdpConnection(UdpConnection, _NullConnection):
     """A null UDP connection."""
 
     async def process_datagram(
-        self, data: bytes, addr: tuple[str, int]
+        self, data: BinaryMessage, addr: tuple[str, int]
     ) -> bool:
         """Process a datagram."""
         return True

runtimepy/net/udp/protocol.py

@@ -6,14 +6,13 @@ A module implementing a DatagramProtocol for UdpConnection.
 import asyncio as _asyncio
 from asyncio import DatagramProtocol as _DatagramProtocol
 import logging
-from typing import Tuple as _Tuple
 
 # third-party
+from vcorelib.io import BinaryMessage
 from vcorelib.logging import LoggerMixin, LoggerType
 from vcorelib.math import RateLimiter
 
 # internal
-from runtimepy.net.connection import BinaryMessage as _BinaryMessage
 from runtimepy.net.connection import Connection as _Connection
 
 
@@ -26,13 +25,13 @@ class UdpQueueProtocol(_DatagramProtocol):
     def __init__(self) -> None:
         """Initialize this protocol."""
 
-        self.queue: _asyncio.Queue[
-            _Tuple[_BinaryMessage, _Tuple[str, int]]
-        ] = _asyncio.Queue()
+        self.queue: _asyncio.Queue[tuple[BinaryMessage, tuple[str, int]]] = (
+            _asyncio.Queue()
+        )
 
         self.log_limiter = RateLimiter.from_s(1.0)
 
-    def datagram_received(self, data: bytes, addr: _Tuple[str, int]) -> None:
+    def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
         """Handle incoming data."""
         self.queue.put_nowait((data, addr))
 

runtimepy/net/udp/queue.py

@@ -5,10 +5,13 @@ A module implementing a simple queue-based UDP interface.
 # built-in
 from asyncio import Queue
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.net.udp.connection import UdpConnection
 
-DatagramQueue = Queue[tuple[bytes, tuple[str, int]]]
+DatagramQueue = Queue[tuple[BinaryMessage, tuple[str, int]]]
 
 
 class QueueUdpConnection(UdpConnection):
@@ -21,7 +24,7 @@ class QueueUdpConnection(UdpConnection):
         self.datagrams = Queue()
 
     async def process_datagram(
-        self, data: bytes, addr: tuple[str, int]
+        self, data: BinaryMessage, addr: tuple[str, int]
     ) -> bool:
         """Process a datagram."""
         self.datagrams.put_nowait((data, addr))

runtimepy/net/udp/tftp/base.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import BinaryIO, Callable
 
 # third-party
+from vcorelib.io import BinaryMessage
 from vcorelib.math import metrics_time_ns
 
 # internal
@@ -353,7 +354,7 @@ class BaseTftpConnection(UdpConnection):
         self.endpoint(addr).handle_error(error_code, message)
 
     async def process_datagram(
-        self, data: bytes, addr: tuple[str, int]
+        self, data: BinaryMessage, addr: tuple[str, int]
     ) -> bool:
         """Process a datagram."""
 

runtimepy/net/websocket/connection.py

@@ -20,6 +20,7 @@ from typing import Union as _Union
 
 # third-party
 from vcorelib.asyncio import log_exceptions as _log_exceptions
+from vcorelib.io import BinaryMessage
 import websockets
 from websockets.asyncio.client import ClientConnection as _ClientConnection
 from websockets.asyncio.server import Server as _Server
@@ -29,7 +30,7 @@ from websockets.exceptions import ConnectionClosed as _ConnectionClosed
 
 # internal
 from runtimepy.net import sockname as _sockname
-from runtimepy.net.connection import BinaryMessage, Connection
+from runtimepy.net.connection import Connection
 from runtimepy.net.connection import EchoConnection as _EchoConnection
 from runtimepy.net.connection import NullConnection as _NullConnection
 from runtimepy.net.manager import ConnectionManager as _ConnectionManager
@@ -41,6 +42,17 @@ V = _TypeVar("V")
 LOG = _getLogger(__name__)
 
 
+async def websocket_connect(uri: str, **kwargs) -> _ClientConnection:
+    """Attempt to connect a websocket interface."""
+
+    # Defaults.
+    kwargs.setdefault("use_ssl", uri.startswith("wss"))
+
+    return await getattr(websockets, "connect")(  # type: ignore
+        uri, **handle_possible_ssl(**kwargs)
+    )
+
+
 class WebsocketConnection(Connection):
     """A simple websocket connection interface."""
 
@@ -54,6 +66,10 @@ class WebsocketConnection(Connection):
         self.protocol = protocol
         super().__init__(self.protocol.logger, **kwargs)
 
+        # Store connection-instantiation arguments (for connection restarting).
+        self._uri: str = ""
+        self._conn_kwargs: dict[str, _Any] = {}
+
     async def _handle_connection_closed(
         self, task: _Awaitable[V]
     ) -> _Optional[V]:
@@ -81,7 +97,9 @@ class WebsocketConnection(Connection):
 
     async def _send_binay_message(self, data: BinaryMessage) -> None:
         """Send a binary message."""
-        await self._handle_connection_closed(self.protocol.send(data))
+        await self._handle_connection_closed(
+            self.protocol.send(data),  # type: ignore
+        )
         self.metrics.tx.increment(len(data))
 
     async def close(self) -> None:
@@ -94,12 +112,30 @@ class WebsocketConnection(Connection):
     ) -> T:
         """Connect a client to an endpoint."""
 
-        kwargs.setdefault("use_ssl", uri.startswith("wss"))
+        inst = cls(await websocket_connect(uri, **kwargs), markdown=markdown)
 
-        protocol = await getattr(websockets, "connect")(
-            uri, **handle_possible_ssl(**kwargs)
-        )
-        return cls(protocol, markdown=markdown)
+        # Stored for connection restart capability.
+        inst._uri = uri
+        inst._conn_kwargs = {**kwargs}
+
+        return inst
+
+    async def restart(self) -> bool:
+        """
+        Reset necessary underlying state for this connection to 'process'
+        again.
+        """
+
+        result = False
+
+        if self._uri:
+            with _suppress(TimeoutError, OSError):
+                self.protocol = await websocket_connect(
+                    self._uri, **self._conn_kwargs
+                )
+                result = True
+
+        return result
 
     @classmethod
     @_asynccontextmanager
@@ -113,7 +149,13 @@ class WebsocketConnection(Connection):
         async with getattr(websockets, "connect")(
             uri, **handle_possible_ssl(**kwargs)
         ) as protocol:
-            yield cls(protocol, markdown=markdown)
+            inst = cls(protocol, markdown=markdown)
+
+            # Stored for connection restart capability.
+            inst._uri = uri
+            inst._conn_kwargs = {**kwargs}
+
+            yield inst
 
     @classmethod
     def server_handler(

runtimepy/primitives/array/__init__.py

@@ -9,6 +9,9 @@ from struct import unpack as _unpack
 from typing import NamedTuple
 from typing import cast as _cast
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.primitives import AnyPrimitive as _AnyPrimitive
 from runtimepy.primitives import Primitivelike as _Primitivelike
@@ -42,8 +45,6 @@ class PrimitiveArray(Serializable):
         """Initialize this primitive array."""
 
         self._primitives: list[_AnyPrimitive] = []
-        self.byte_order = byte_order
-        self._format: str = self.byte_order.fmt
 
         # Keep track of a quick lookup for converting between element indices
         # and byte indices.
@@ -53,12 +54,13 @@ class PrimitiveArray(Serializable):
         self.size = 0
         self.chain = None
 
+        super().__init__(byte_order=byte_order, chain=chain)
+        self._format: str = self.byte_order.fmt
+
         # Add initial items.
         for item in primitives:
             self.add(item)
 
-        super().__init__(byte_order=self.byte_order, chain=chain)
-
         self._fragments: list["PrimitiveArray"] = []
         self._fragment_specs: list[ArrayFragmentSpec] = []
 
@@ -236,7 +238,7 @@ class PrimitiveArray(Serializable):
         """Get bytes from a fragment."""
         return bytes(self._fragments[index])
 
-    def update(self, data: bytes, timestamp_ns: int = None) -> int:
+    def update(self, data: BinaryMessage, timestamp_ns: int = None) -> int:
         """Update primitive values from a bytes instance."""
 
         for primitive, item in zip(

runtimepy/primitives/base.py

@@ -13,6 +13,7 @@ from typing import Iterator as _Iterator
 from typing import TypeVar as _TypeVar
 
 # third-party
+from vcorelib.io import BinaryMessage
 from vcorelib.math import default_time_ns, nano_str
 from vcorelib.math.keeper import TimeSource
 
@@ -243,7 +244,7 @@ class Primitive(_Generic[T]):
         stream.write(self.binary(byte_order=byte_order))
         return self.kind.size
 
-    def update(self, data: bytes, byte_order: _ByteOrder = None) -> T:
+    def update(self, data: BinaryMessage, byte_order: _ByteOrder = None) -> T:
         """Update this primitive from a bytes object."""
 
         if byte_order is None:
@@ -269,7 +270,7 @@ class Primitive(_Generic[T]):
         return cls.kind.encode(value, byte_order=byte_order)
 
     @classmethod
-    def decode(cls, data: bytes, byte_order: _ByteOrder = None) -> T:
+    def decode(cls, data: BinaryMessage, byte_order: _ByteOrder = None) -> T:
         """Decode a primitive of this type from provided data."""
 
         if byte_order is None:

runtimepy/primitives/field/__init__.py

@@ -3,6 +3,7 @@ A module implementing bit flags and fields.
 """
 
 # built-in
+from typing import Optional as _Optional
 from typing import cast as _cast
 
 # third-party
@@ -14,6 +15,12 @@ from runtimepy.mixins.regex import CHANNEL_PATTERN as _CHANNEL_PATTERN
 from runtimepy.mixins.regex import RegexMixin as _RegexMixin
 from runtimepy.primitives.int import UnsignedInt as _UnsignedInt
 from runtimepy.registry.name import RegistryKey as _RegistryKey
+from runtimepy.ui.controls import (
+    Controls,
+    Controlslike,
+    bit_slider,
+    normalize_controls,
+)
 
 
 class BitFieldBase:
@@ -26,6 +33,8 @@ class BitFieldBase:
         width: int,
         commandable: bool = False,
         description: str = None,
+        controls: Controlslike = None,
+        default: _Optional[int | bool | str] = None,
     ) -> None:
         """Initialize this bit-field."""
 
@@ -34,6 +43,11 @@ class BitFieldBase:
         self.commandable = commandable
         self.description = description
 
+        if controls:
+            controls = normalize_controls(controls)
+        self.controls: _Optional[Controls] = controls  # type: ignore
+        self.default = default
+
         # Compute a bit-mask for this field.
         self.width = width
         self.mask = (2**self.width) - 1
@@ -46,7 +60,7 @@ class BitFieldBase:
 
         result = ""
 
-        for idx in range(self.raw.size * 8):
+        for idx in reversed(range(self.raw.size * 8)):
             val = 1 << idx
             if val & self.shifted_mask:
                 result += "^"
@@ -96,11 +110,17 @@ class BitField(BitFieldBase, _RegexMixin, _EnumMixin):
         enum: _RegistryKey = None,
         commandable: bool = False,
         description: str = None,
+        **kwargs,
     ) -> None:
         """Initialize this bit-field."""
 
         super().__init__(
-            raw, index, width, commandable=commandable, description=description
+            raw,
+            index,
+            width,
+            commandable=commandable,
+            description=description,
+            **kwargs,
         )
 
         # Verify bit-field parameters.
@@ -118,6 +138,13 @@ class BitField(BitFieldBase, _RegexMixin, _EnumMixin):
         self.name = name
         self._enum = enum
 
+    def set_slider(self) -> "BitField":
+        """Set slider controls for this bit field."""
+
+        assert self.controls is None
+        self.controls = bit_slider(self.width, False)
+        return self
+
     def asdict(self) -> _JsonObject:
         """Get this field as a dictionary."""
 
@@ -131,6 +158,10 @@ class BitField(BitFieldBase, _RegexMixin, _EnumMixin):
             result["enum"] = self.enum
         if self.commandable:
             result["commandable"] = True
+        if self.controls:
+            result["controls"] = self.controls  # type: ignore
+        if self.default is not None:
+            result["default"] = self.default
         return result
 
 
@@ -145,6 +176,7 @@ class BitFlag(BitField):
         enum: _RegistryKey = None,
         commandable: bool = False,
         description: str = None,
+        **kwargs,
     ) -> None:
         """Initialize this bit flag."""
 
@@ -156,6 +188,7 @@ class BitFlag(BitField):
             enum=enum,
             commandable=commandable,
             description=description,
+            **kwargs,
         )
 
     def clear(self) -> None:

runtimepy/primitives/field/fields.py

@@ -73,6 +73,8 @@ class BitFields(_RuntimepyDictCodec):
                     enum=enum,
                     description=desc,
                     commandable=commandable,
+                    controls=item.get("controls"),
+                    default=item.get("default"),
                 )
                 flag(value)
                 item["index"] = flag.index
@@ -84,6 +86,8 @@ class BitFields(_RuntimepyDictCodec):
                     enum=enum,
                     description=desc,
                     commandable=commandable,
+                    controls=item.get("controls"),
+                    default=item.get("default"),
                 )
                 field(value)
                 item["index"] = field.index
@@ -229,10 +233,15 @@ class BitFields(_RuntimepyDictCodec):
 
     @classmethod
     def new(
-        cls: type[T], value: _Primitivelike | _AnyPrimitive = "uint8"
+        cls: type[T], value: _Primitivelike | _AnyPrimitive = "uint8", **kwargs
     ) -> T:
         """Create a new bit-field storage entity."""
 
         return cls.create(
-            {"type": _cast(str, value), "fields": [], "finalized": False}
+            {
+                "type": _cast(str, value),
+                "fields": [],
+                "finalized": False,
+                **kwargs,
+            }
         )

runtimepy/primitives/field/manager/base.py

@@ -14,6 +14,7 @@ from typing import cast as _cast
 from vcorelib.io import ARBITER as _ARBITER
 from vcorelib.io.types import EncodeResult as _EncodeResult
 from vcorelib.io.types import JsonObject as _JsonObject
+from vcorelib.namespace import Namespace
 from vcorelib.paths import Pathlike as _Pathlike
 
 # internal
@@ -86,7 +87,12 @@ class BitFieldsManagerBase:
         """Encode this bit-fields manager to a file."""
         return fields_to_file(path, self.fields, **kwargs)
 
-    def add(self, fields: _BitFields) -> int:
+    def add(
+        self,
+        fields: _BitFields,
+        namespace: Namespace = None,
+        track: bool = False,
+    ) -> int:
         """Add new bit-fields to manage."""
 
         # Ensure that new fields can't be added after the current fields
@@ -97,7 +103,12 @@ class BitFieldsManagerBase:
         self.fields.append(fields)
 
         # Register fields into the lookup structure.
+        to_add = {}
         for name, field in fields.fields.items():
+            if namespace is not None:
+                name = namespace.namespace(name=name, track=track)
+                to_add[name] = field
+
             ident = self.registry.register_name(name)
             assert ident is not None, "Couldn't register bit-field '{name}'!"
             assert name not in self.lookup, name
@@ -105,7 +116,13 @@ class BitFieldsManagerBase:
 
             # Also store the enum mapping.
             if field.is_enum:
-                self.enum_lookup[name] = self.enums[field.enum]
+                runtime = self.enums[field.enum]
+                self.enum_lookup[name] = runtime
+                if runtime.default:
+                    self.set(name, runtime.default)
+
+        # Add possible namespaced-name mappings.
+        fields.fields.update(to_add)
 
         return index
 

runtimepy/primitives/serializable/base.py

@@ -11,6 +11,7 @@ from typing import TypeVar
 
 # third-party
 from vcorelib import DEFAULT_ENCODING
+from vcorelib.io import BinaryMessage
 
 # internal
 from runtimepy.primitives.byte_order import (
@@ -133,7 +134,7 @@ class Serializable(ABC):
         )
 
     @abstractmethod
-    def update(self, data: bytes, timestamp_ns: int = None) -> int:
+    def update(self, data: BinaryMessage, timestamp_ns: int = None) -> int:
         """Update this serializable from a bytes instance."""
 
     def update_str(self, data: str, timestamp_ns: int = None) -> int:
@@ -158,7 +159,9 @@ class Serializable(ABC):
 
         return result
 
-    def update_chain(self, data: bytes, timestamp_ns: int = None) -> int:
+    def update_chain(
+        self, data: BinaryMessage, timestamp_ns: int = None
+    ) -> int:
         """Update this serializable from a bytes instance."""
 
         with _BytesIO(data) as stream:

runtimepy/primitives/serializable/fixed.py

@@ -5,6 +5,9 @@ A module implementing a fixed-size bytes serializable.
 # built-in
 from copy import copy as _copy
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.primitives.serializable.base import Serializable
 
@@ -31,11 +34,11 @@ class FixedChunk(Serializable):
         """Get this serializable as a bytes instance."""
         return self.data
 
-    def update(self, data: bytes, timestamp_ns: int = None) -> int:
+    def update(self, data: BinaryMessage, timestamp_ns: int = None) -> int:
         """Update this serializable from a bytes instance."""
 
         del timestamp_ns
 
-        self.data = data
+        self.data = bytes(data)
         self.size = len(self.data)
         return self.size

runtimepy/primitives/serializable/prefixed.py

@@ -7,6 +7,9 @@ primitive prefix to determine the size of the chunk portion.
 from typing import BinaryIO as _BinaryIO
 from typing import TypeVar
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.primitives import Primitivelike, UnsignedInt, create
 from runtimepy.primitives.byte_order import (
@@ -44,7 +47,7 @@ class PrefixedChunk(Serializable):
         """Get this chunk as a string."""
         return str(self.chunk)
 
-    def update(self, data: bytes, timestamp_ns: int = None) -> int:
+    def update(self, data: BinaryMessage, timestamp_ns: int = None) -> int:
         """Update this serializable from a bytes instance."""
 
         size = self.chunk.update(data, timestamp_ns=timestamp_ns)

runtimepy/primitives/types/base.py

@@ -14,6 +14,9 @@ from typing import TypeVar as _TypeVar
 from typing import Union as _Union
 from typing import cast as _cast
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.primitives.byte_order import (
     DEFAULT_BYTE_ORDER as _DEFAULT_BYTE_ORDER,
@@ -134,7 +137,7 @@ class PrimitiveType(_Generic[T]):
         return _pack(byte_order.fmt + self.format, value)
 
     def decode(
-        self, data: bytes, byte_order: _ByteOrder = _DEFAULT_BYTE_ORDER
+        self, data: BinaryMessage, byte_order: _ByteOrder = _DEFAULT_BYTE_ORDER
     ) -> PythonPrimitive:
         """Decode primitive based on this type."""
         return _unpack(byte_order.fmt + self.format, data)[0]  # type: ignore

runtimepy/primitives/types/bounds.py

@@ -31,9 +31,15 @@ class IntegerBounds(NamedTuple):
         return max(self.min, min(val, self.max))
 
     @staticmethod
-    def create(byte_count: int, signed: bool) -> "IntegerBounds":
+    def create_bit(bit_count: int, signed: bool) -> "IntegerBounds":
         """Compute maximum and minimum values given size and signedness."""
 
-        min_val = 0 if not signed else -1 * (2 ** (byte_count * 8 - 1))
-        width = 8 * byte_count if not signed else 8 * byte_count - 1
-        return IntegerBounds(min_val, (2**width) - 1)
+        return IntegerBounds(
+            0 if not signed else -1 * (2 ** (bit_count - 1)),
+            (2 ** (bit_count if not signed else bit_count - 1)) - 1,
+        )
+
+    @staticmethod
+    def create(byte_count: int, signed: bool) -> "IntegerBounds":
+        """Compute maximum and minimum values given size and signedness."""
+        return IntegerBounds.create_bit(8 * byte_count, signed)

runtimepy/registry/__init__.py

@@ -20,6 +20,7 @@ from vcorelib.io.types import JsonValue as _JsonValue
 from runtimepy.registry.item import RegistryItem as _RegistryItem
 from runtimepy.registry.name import NameRegistry as _NameRegistry
 from runtimepy.registry.name import RegistryKey as _RegistryKey
+from runtimepy.registry.name import is_registry_key as _is_registry_key
 from runtimepy.schemas import RuntimepyDictCodec as _RuntimepyDictCodec
 
 T = _TypeVar("T", bound=_RegistryItem)
@@ -66,6 +67,15 @@ class Registry(_RuntimepyDictCodec, _Generic[T]):
             for name, item in self.items.items()
         }
 
+    def register_from_other(self, other: "Registry[T]") -> None:
+        """Register missing elements from another registry."""
+
+        for name, instance in other.items.items():
+            if name in self.items:
+                assert self.items[name].id == instance.id, (name, instance)
+            else:
+                assert self.register(name, instance), (name, instance)
+
     def register(self, name: str, item: T) -> bool:
         """Attempt to register a new item."""
 
@@ -100,6 +110,16 @@ class Registry(_RuntimepyDictCodec, _Generic[T]):
             result = self.items[name]
         return result
 
+    def registry_normalize(self, key: _RegistryKey | T) -> T:
+        """Attempt to get an item from a registry key."""
+
+        if _is_registry_key(key):
+            result: T = self[_cast(str, key)]
+        else:
+            result = _cast(T, key)
+
+        return result
+
     def __getitem__(self, key: _RegistryKey) -> T:
         """Get a registry item."""
 

runtimepy/registry/name.py

@@ -3,6 +3,7 @@ A simple name-to-identifier registry interface.
 """
 
 # built-in
+from typing import Any as _Any
 from typing import MutableMapping as _MutableMapping
 from typing import Optional as _Optional
 from typing import Union as _Union
@@ -15,6 +16,11 @@ KeyToName = _MutableMapping[int, str]
 NameToKey = _MutableMapping[str, int]
 
 
+def is_registry_key(data: _Any) -> bool:
+    """Determine if this data is a registry key."""
+    return isinstance(data, (int, str))
+
+
 class NameRegistry(_TwoWayNameMapping[int]):
     """A simple class for keeping track of name-to-identifier mappings."""