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

runtimepy/net/stream/base.py

@@ -6,9 +6,11 @@ A module implementing a base, stream-oriented connection interface.
 from io import BytesIO as _BytesIO
 from typing import BinaryIO as _BinaryIO
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.message import MessageProcessor
-from runtimepy.net.connection import BinaryMessage
 from runtimepy.net.connection import Connection as _Connection
 
 
@@ -58,7 +60,7 @@ class PrefixedMessageConnection(_Connection):
         return True
 
     async def process_binary(
-        self, data: bytes, addr: tuple[str, int] = None
+        self, data: BinaryMessage, addr: tuple[str, int] = None
     ) -> bool:
         """Process an incoming message."""
 

runtimepy/net/tcp/connection.py

@@ -17,10 +17,12 @@ from typing import Optional as _Optional
 from typing import TypeVar as _TypeVar
 from typing import Union as _Union
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.net import sockname as _sockname
 from runtimepy.net.backoff import ExponentialBackoff
-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
@@ -91,7 +93,7 @@ class TcpConnection(_Connection, _TransportMixin):
         """Determine if this connection uses SSL."""
         return self._transport.get_extra_info("sslcontext") is not None
 
-    async def _await_message(self) -> _Optional[_Union[_BinaryMessage, str]]:
+    async def _await_message(self) -> _Optional[_Union[BinaryMessage, str]]:
         """Await the next message. Return None on error or failure."""
 
         data = await self._protocol.queue.get()
@@ -103,7 +105,7 @@ class TcpConnection(_Connection, _TransportMixin):
         """Enqueue a text message to send."""
         self.send_binary(data.encode())
 
-    def send_binary(self, data: _BinaryMessage) -> None:
+    def send_binary(self, data: BinaryMessage) -> None:
         """Enqueue a binary message tos end."""
         self._transport.write(data)
         self.metrics.tx.increment(len(data))

runtimepy/net/tcp/http/__init__.py

@@ -11,6 +11,7 @@ from typing import Any, Awaitable, Callable, Optional, Tuple, Union, cast
 
 # third-party
 from vcorelib import DEFAULT_ENCODING
+from vcorelib.io import BinaryMessage
 
 # internal
 from runtimepy import PKG_NAME, VERSION
@@ -19,18 +20,18 @@ from runtimepy.net.http.header import RequestHeader
 from runtimepy.net.http.response import AsyncResponse, ResponseHeader
 from runtimepy.net.tcp.connection import TcpConnection as _TcpConnection
 
-HttpResult = Optional[bytes | AsyncResponse]
+HttpResult = Optional[BinaryMessage | AsyncResponse]
 
 #
 # async def handler(
 #     response: ResponseHeader,
 #     request: RequestHeader,
-#     request_data: Optional[bytes],
+#     request_data: Optional[bytearray],
 # ) -> HttpResult:
 #     """Sample handler."""
 #
 HttpRequestHandler = Callable[
-    [ResponseHeader, RequestHeader, Optional[bytes]],
+    [ResponseHeader, RequestHeader, Optional[bytearray]],
     Awaitable[HttpResult],
 ]
 HttpResponse = Tuple[ResponseHeader, HttpResult]
@@ -99,7 +100,7 @@ class HttpConnection(_TcpConnection):
         self,
         response: ResponseHeader,
         request: RequestHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> HttpResult:
         """Sample handler."""
 
@@ -107,7 +108,7 @@ class HttpConnection(_TcpConnection):
         self,
         response: ResponseHeader,
         request: RequestHeader,
-        request_data: Optional[bytes],
+        request_data: Optional[bytearray],
     ) -> HttpResult:
         """Sample handler."""
 
@@ -115,7 +116,7 @@ class HttpConnection(_TcpConnection):
         self,
         response: ResponseHeader,
         request_header: RequestHeader,
-        request_data: Optional[bytes] = None,
+        request_data: Optional[bytearray] = None,
     ) -> HttpResult:
         """Process an individual request."""
 
@@ -141,7 +142,7 @@ class HttpConnection(_TcpConnection):
         return result
 
     async def request(
-        self, request: RequestHeader, data: Optional[bytes] = None
+        self, request: RequestHeader, data: Optional[BinaryMessage] = None
     ) -> HttpResponse:
         """Make an HTTP request."""
 
@@ -157,7 +158,7 @@ class HttpConnection(_TcpConnection):
         return result
 
     async def request_json(
-        self, request: RequestHeader, data: Optional[bytes] = None
+        self, request: RequestHeader, data: Optional[BinaryMessage] = None
     ) -> Any:
         """
         Perform a request and convert the response to a data structure by
@@ -191,7 +192,7 @@ class HttpConnection(_TcpConnection):
 
         header.log(self.logger, True)
 
-    async def process_binary(self, data: bytes) -> bool:
+    async def process_binary(self, data: BinaryMessage) -> bool:
         """Process a binary frame."""
 
         for header, payload in self.processor.ingest(

runtimepy/net/tcp/protocol.py

@@ -9,10 +9,10 @@ from logging import getLogger as _getLogger
 from typing import Optional as _Optional
 
 # third-party
+from vcorelib.io import BinaryMessage
 from vcorelib.logging import LoggerType as _LoggerType
 
 # internal
-from runtimepy.net.connection import BinaryMessage as _BinaryMessage
 from runtimepy.net.connection import Connection as _Connection
 from runtimepy.net.mixin import (
     BinaryMessageQueueMixin as _BinaryMessageQueueMixin,
@@ -26,7 +26,7 @@ class QueueProtocol(_BinaryMessageQueueMixin, _Protocol):
     logger: _LoggerType
     conn: _Connection
 
-    def data_received(self, data: _BinaryMessage) -> None:
+    def data_received(self, data: BinaryMessage) -> None:
         """Handle incoming data."""
         self.queue.put_nowait(data)
 

runtimepy/net/tcp/scpi/__init__.py

@@ -5,6 +5,9 @@ A module implementing an SCPI interface.
 # built-in
 import asyncio
 
+# third-party
+from vcorelib.io import BinaryMessage
+
 # internal
 from runtimepy.net.arbiter.tcp import TcpConnectionFactory
 from runtimepy.net.tcp import TcpConnection
@@ -34,9 +37,9 @@ class ScpiConnection(TcpConnection):
 
         return True
 
-    async def process_binary(self, data: bytes) -> bool:
+    async def process_binary(self, data: BinaryMessage) -> bool:
         """Process a binary frame."""
-        return await self.process_text(data.decode())
+        return await self.process_text(bytes(data).decode())
 
     async def send_command(
         self,

runtimepy/net/tcp/telnet/__init__.py

@@ -10,6 +10,7 @@ from typing import BinaryIO as _BinaryIO
 
 # third-party
 from vcorelib import DEFAULT_ENCODING
+from vcorelib.io import BinaryMessage
 
 # internal
 from runtimepy.net.tcp.connection import TcpConnection as _TcpConnection
@@ -65,7 +66,7 @@ class Telnet(_TcpConnection):
     ) -> None:
         """Process a telnet option."""
 
-    async def process_binary(self, data: bytes) -> bool:
+    async def process_binary(self, data: BinaryMessage) -> bool:
         """Process a binary frame."""
 
         result = True

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
@@ -28,8 +29,9 @@ from websockets.asyncio.server import serve as _serve
 from websockets.exceptions import ConnectionClosed as _ConnectionClosed
 
 # internal
+from runtimepy.net import normalize_host as _normalize_host
 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 +43,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."""
 
@@ -52,7 +65,17 @@ class WebsocketConnection(Connection):
         """Initialize this connection."""
 
         self.protocol = protocol
-        super().__init__(self.protocol.logger, **kwargs)
+        super().__init__(
+            _getLogger(
+                f"W {_normalize_host(*self.protocol.local_address)} -> "
+                f"{_normalize_host(*self.protocol.remote_address)}"
+            ),
+            **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]
@@ -81,7 +104,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 +119,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 +156,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,
+            }
         )