rocket-welder-sdk 1.1.42__tar.gz → 1.1.44__tar.gz

{rocket_welder_sdk-1.1.42 → rocket_welder_sdk-1.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.42
+Version: 1.1.44
 Summary: High-performance video streaming SDK for RocketWelder services using ZeroBuffer IPC
 Home-page: https://github.com/modelingevolution/rocket-welder-sdk
 Author: ModelingEvolution
@@ -32,8 +32,6 @@ Requires-Dist: zerobuffer-ipc>=1.1.17
 Requires-Dist: pydantic>=2.5.0
 Requires-Dist: py-micro-plumberd>=0.1.8
 Requires-Dist: typing-extensions>=4.0.0
-Provides-Extra: nng
-Requires-Dist: pynng>=0.7.2; extra == "nng"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -42,7 +40,6 @@ Requires-Dist: black>=22.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
-Requires-Dist: pynng>=0.7.2; extra == "dev"
 Dynamic: author
 Dynamic: home-page
 Dynamic: requires-python

rocket_welder_sdk-1.1.44/VERSION

@@ -0,0 +1 @@
+1.1.44

{rocket_welder_sdk-1.1.42 → rocket_welder_sdk-1.1.44}/pyproject.toml

@@ -42,9 +42,6 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-nng = [
-    "pynng>=0.7.2",
-]
 dev = [
     "pytest>=7.0",
     "pytest-cov>=4.0",
@@ -53,7 +50,6 @@ dev = [
     "mypy>=1.0",
     "ruff>=0.1.0",
     "types-setuptools",
-    "pynng>=0.7.2",
 ]
 
 [project.urls]
@@ -96,8 +92,8 @@ module = [
     "py_micro_plumberd.*",
     "esdbclient",
     "esdbclient.*",
-    "pynng",
-    "pynng.*",
+    "websockets",
+    "websockets.*",
 ]
 ignore_missing_imports = true
 
@@ -147,7 +143,7 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]  # imported but unused
 "tests/*" = ["S101"]  # use of assert
-"examples/*" = ["N999", "SIM112"]  # Module names and env var casing (matches C# SDK)
+"examples/*" = ["N999", "SIM112", "F401", "SIM108"]  # Module names, env var casing, unused imports, if/else style
 
 [tool.pytest.ini_options]
 minversion = "7.0"

{rocket_welder_sdk-1.1.42 → rocket_welder_sdk-1.1.44}/rocket_welder_sdk/__init__.py

@@ -7,9 +7,13 @@ High-performance video streaming using shared memory (ZeroBuffer) for zero-copy
 import logging
 import os
 
+from .binary_frame_reader import BinaryFrameReader
+from .binary_frame_writer import BinaryFrameWriter
 from .bytes_size import BytesSize
+from .confidence import Confidence
 from .connection_string import ConnectionMode, ConnectionString, Protocol
 from .controllers import DuplexShmController, IController, OneWayShmController
+from .delta_frame import DeltaFrame
 from .frame_metadata import FRAME_METADATA_SIZE, FrameMetadata, GstVideoFormat
 from .gst_metadata import GstCaps, GstMetadata
 from .keypoints_protocol import (
@@ -23,27 +27,21 @@ from .periodic_timer import PeriodicTimer, PeriodicTimerSync
 from .rocket_welder_client import RocketWelderClient
 from .segmentation_result import (
     ISegmentationResultSink,
+    ISegmentationResultSource,
     ISegmentationResultWriter,
+    SegmentationFrame,
+    SegmentationProtocol,
     SegmentationResultSink,
+    SegmentationResultSource,
     SegmentationResultWriter,
 )
 from .session_id import (
-    # Explicit URL functions (PREFERRED - set by rocket-welder2)
+    # Explicit URL environment variable names (set by rocket-welder2)
     ACTIONS_SINK_URL_ENV,
     KEYPOINTS_SINK_URL_ENV,
     SEGMENTATION_SINK_URL_ENV,
-    # SessionId-derived URL functions (fallback for backwards compatibility)
-    get_actions_url,
-    get_actions_url_from_env,
-    get_configured_nng_urls,
-    get_keypoints_url,
-    get_keypoints_url_from_env,
-    get_nng_urls,
-    get_nng_urls_from_env,
-    get_segmentation_url,
-    get_segmentation_url_from_env,
+    # SessionId parsing
     get_session_id_from_env,
-    has_explicit_nng_urls,
     parse_session_id,
 )
 
@@ -76,10 +74,14 @@ __all__ = [
     "FRAME_METADATA_SIZE",
     "KEYPOINTS_SINK_URL_ENV",
     "SEGMENTATION_SINK_URL_ENV",
+    "BinaryFrameReader",
+    "BinaryFrameWriter",
     "BytesSize",
     "Client",
+    "Confidence",
     "ConnectionMode",
     "ConnectionString",
+    "DeltaFrame",
     "DuplexShmController",
     "FrameMetadata",
     "GstCaps",
@@ -89,6 +91,7 @@ __all__ = [
     "IKeyPointsSink",
     "IKeyPointsWriter",
     "ISegmentationResultSink",
+    "ISegmentationResultSource",
     "ISegmentationResultWriter",
     "KeyPointsSink",
     "KeyPointsWriter",
@@ -98,18 +101,11 @@ __all__ = [
     "PeriodicTimerSync",
     "Protocol",
     "RocketWelderClient",
+    "SegmentationFrame",
+    "SegmentationProtocol",
     "SegmentationResultSink",
+    "SegmentationResultSource",
     "SegmentationResultWriter",
-    "get_actions_url",
-    "get_actions_url_from_env",
-    "get_configured_nng_urls",
-    "get_keypoints_url",
-    "get_keypoints_url_from_env",
-    "get_nng_urls",
-    "get_nng_urls_from_env",
-    "get_segmentation_url",
-    "get_segmentation_url_from_env",
     "get_session_id_from_env",
-    "has_explicit_nng_urls",
     "parse_session_id",
 ]

rocket_welder_sdk-1.1.44/rocket_welder_sdk/binary_frame_reader.py

@@ -0,0 +1,222 @@
+"""
+Zero-allocation binary reader for parsing streaming protocol data.
+Matches C# BinaryFrameReader ref struct from RocketWelder.SDK.Protocols.
+
+Designed for high-performance frame decoding in real-time video processing.
+"""
+
+from __future__ import annotations
+
+import struct
+from typing import Union
+
+from .varint import read_varint, read_zigzag
+
+
+class BinaryFrameReader:
+    """
+    Binary reader for parsing streaming protocol data.
+
+    Reads data from a bytes-like object with position tracking.
+    All multi-byte integers are read as little-endian.
+
+    Attributes:
+        position: Current read position in the buffer.
+    """
+
+    __slots__ = ("_data", "_position")
+
+    def __init__(self, data: Union[bytes, bytearray, memoryview]) -> None:
+        """
+        Initialize reader with data buffer.
+
+        Args:
+            data: Source data buffer (bytes, bytearray, or memoryview)
+        """
+        if isinstance(data, memoryview):
+            self._data = bytes(data)
+        else:
+            self._data = bytes(data)
+        self._position = 0
+
+    @property
+    def has_more(self) -> bool:
+        """Returns True if there is more data to read."""
+        return self._position < len(self._data)
+
+    @property
+    def position(self) -> int:
+        """Current read position in the buffer."""
+        return self._position
+
+    @position.setter
+    def position(self, value: int) -> None:
+        """Set the current read position."""
+        self._position = value
+
+    @property
+    def remaining(self) -> int:
+        """Remaining bytes available to read."""
+        return len(self._data) - self._position
+
+    def read_byte(self) -> int:
+        """
+        Read a single byte.
+
+        Returns:
+            The byte value (0-255)
+
+        Raises:
+            EOFError: If no more data available
+        """
+        if self._position >= len(self._data):
+            raise EOFError("Unexpected end of data")
+        value = self._data[self._position]
+        self._position += 1
+        return value
+
+    def read_uint64_le(self) -> int:
+        """
+        Read an unsigned 64-bit integer (little-endian).
+
+        Returns:
+            The unsigned 64-bit value
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + 8 > len(self._data):
+            raise EOFError("Not enough data for UInt64")
+        (value,) = struct.unpack_from("<Q", self._data, self._position)
+        self._position += 8
+        return int(value)
+
+    def read_int32_le(self) -> int:
+        """
+        Read a signed 32-bit integer (little-endian).
+
+        Returns:
+            The signed 32-bit value
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + 4 > len(self._data):
+            raise EOFError("Not enough data for Int32")
+        (value,) = struct.unpack_from("<i", self._data, self._position)
+        self._position += 4
+        return int(value)
+
+    def read_uint16_le(self) -> int:
+        """
+        Read an unsigned 16-bit integer (little-endian).
+
+        Returns:
+            The unsigned 16-bit value
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + 2 > len(self._data):
+            raise EOFError("Not enough data for UInt16")
+        (value,) = struct.unpack_from("<H", self._data, self._position)
+        self._position += 2
+        return int(value)
+
+    def read_single_le(self) -> float:
+        """
+        Read a 32-bit floating point (little-endian).
+
+        Returns:
+            The 32-bit float value
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + 4 > len(self._data):
+            raise EOFError("Not enough data for Single")
+        (value,) = struct.unpack_from("<f", self._data, self._position)
+        self._position += 4
+        return float(value)
+
+    def read_varint(self) -> int:
+        """
+        Read a varint-encoded unsigned 32-bit integer.
+
+        Returns:
+            The decoded unsigned value
+
+        Raises:
+            EOFError: If buffer ends before varint completes
+            ValueError: If varint is malformed
+        """
+        value, bytes_read = read_varint(self._data, self._position)
+        self._position += bytes_read
+        return value
+
+    def read_zigzag_varint(self) -> int:
+        """
+        Read a ZigZag-encoded signed integer (varint format).
+
+        Returns:
+            The decoded signed value
+
+        Raises:
+            EOFError: If buffer ends before varint completes
+            ValueError: If varint is malformed
+        """
+        value, bytes_read = read_zigzag(self._data, self._position)
+        self._position += bytes_read
+        return value
+
+    def read_string(self, length: int) -> str:
+        """
+        Read a UTF-8 encoded string of specified length.
+
+        Args:
+            length: Number of bytes to read
+
+        Returns:
+            The decoded UTF-8 string
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + length > len(self._data):
+            raise EOFError(f"Not enough data for string of length {length}")
+        value = self._data[self._position : self._position + length].decode("utf-8")
+        self._position += length
+        return value
+
+    def skip(self, count: int) -> None:
+        """
+        Skip a specified number of bytes.
+
+        Args:
+            count: Number of bytes to skip
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + count > len(self._data):
+            raise EOFError(f"Cannot skip {count} bytes, only {self.remaining} remaining")
+        self._position += count
+
+    def read_bytes(self, length: int) -> bytes:
+        """
+        Read raw bytes.
+
+        Args:
+            length: Number of bytes to read
+
+        Returns:
+            The raw bytes
+
+        Raises:
+            EOFError: If not enough data available
+        """
+        if self._position + length > len(self._data):
+            raise EOFError(f"Not enough data for {length} bytes")
+        value = self._data[self._position : self._position + length]
+        self._position += length
+        return value

rocket_welder_sdk-1.1.44/rocket_welder_sdk/binary_frame_writer.py

@@ -0,0 +1,213 @@
+"""
+Zero-allocation binary writer for encoding streaming protocol data.
+Matches C# BinaryFrameWriter ref struct from RocketWelder.SDK.Protocols.
+
+Symmetric counterpart to BinaryFrameReader for round-trip testing.
+Designed for high-performance frame encoding in real-time video processing.
+"""
+
+from __future__ import annotations
+
+import struct
+from typing import Union
+
+from .varint import MAX_BYTES_UINT32, get_byte_count, write_varint, write_zigzag
+
+
+class BinaryFrameWriter:
+    """
+    Binary writer for encoding streaming protocol data.
+
+    Writes data to a pre-allocated bytearray buffer with position tracking.
+    All multi-byte integers are written as little-endian.
+
+    Attributes:
+        position: Current write position in the buffer.
+    """
+
+    __slots__ = ("_buffer", "_position")
+
+    def __init__(self, buffer: bytearray) -> None:
+        """
+        Initialize writer with a buffer.
+
+        Args:
+            buffer: Destination buffer (bytearray)
+        """
+        self._buffer = buffer
+        self._position = 0
+
+    @classmethod
+    def with_capacity(cls, capacity: int) -> BinaryFrameWriter:
+        """
+        Create a writer with a new buffer of specified capacity.
+
+        Args:
+            capacity: Size of buffer to create
+
+        Returns:
+            New BinaryFrameWriter instance
+        """
+        return cls(bytearray(capacity))
+
+    @property
+    def position(self) -> int:
+        """Current write position in the buffer."""
+        return self._position
+
+    @property
+    def remaining(self) -> int:
+        """Remaining bytes available to write."""
+        return len(self._buffer) - self._position
+
+    @property
+    def written_bytes(self) -> bytes:
+        """Returns the portion of the buffer that has been written to."""
+        return bytes(self._buffer[: self._position])
+
+    @property
+    def written_view(self) -> memoryview:
+        """Returns a memoryview of the written portion of the buffer."""
+        return memoryview(self._buffer)[: self._position]
+
+    def write_byte(self, value: int) -> None:
+        """
+        Write a single byte.
+
+        Args:
+            value: Byte value (0-255)
+
+        Raises:
+            OverflowError: If buffer is full
+        """
+        if self._position >= len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for byte")
+        self._buffer[self._position] = value
+        self._position += 1
+
+    def write_uint64_le(self, value: int) -> None:
+        """
+        Write an unsigned 64-bit integer (little-endian).
+
+        Args:
+            value: Unsigned 64-bit value
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + 8 > len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for UInt64")
+        struct.pack_into("<Q", self._buffer, self._position, value)
+        self._position += 8
+
+    def write_int32_le(self, value: int) -> None:
+        """
+        Write a signed 32-bit integer (little-endian).
+
+        Args:
+            value: Signed 32-bit value
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + 4 > len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for Int32")
+        struct.pack_into("<i", self._buffer, self._position, value)
+        self._position += 4
+
+    def write_uint16_le(self, value: int) -> None:
+        """
+        Write an unsigned 16-bit integer (little-endian).
+
+        Args:
+            value: Unsigned 16-bit value
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + 2 > len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for UInt16")
+        struct.pack_into("<H", self._buffer, self._position, value)
+        self._position += 2
+
+    def write_single_le(self, value: float) -> None:
+        """
+        Write a 32-bit floating point (little-endian).
+
+        Args:
+            value: 32-bit float value
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + 4 > len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for Single")
+        struct.pack_into("<f", self._buffer, self._position, value)
+        self._position += 4
+
+    def write_varint(self, value: int) -> None:
+        """
+        Write a varint-encoded unsigned 32-bit integer.
+
+        Args:
+            value: Unsigned value to encode
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        # Check if we have worst-case space or exact space needed
+        # (intentionally nested for optimization - fast check first)
+        if self._position + MAX_BYTES_UINT32 > len(self._buffer):  # noqa: SIM102
+            if self._position + get_byte_count(value) > len(self._buffer):
+                raise OverflowError("Buffer overflow: not enough space for varint")
+
+        bytes_written = write_varint(self._buffer, self._position, value)
+        self._position += bytes_written
+
+    def write_zigzag_varint(self, value: int) -> None:
+        """
+        Write a ZigZag-encoded signed integer (varint format).
+
+        Args:
+            value: Signed value to encode
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + MAX_BYTES_UINT32 > len(self._buffer):
+            raise OverflowError("Buffer overflow: not enough space for varint")
+
+        bytes_written = write_zigzag(self._buffer, self._position, value)
+        self._position += bytes_written
+
+    def write_bytes(self, source: Union[bytes, bytearray, memoryview]) -> None:
+        """
+        Write raw bytes from a bytes-like object.
+
+        Args:
+            source: Source bytes to write
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        if self._position + len(source) > len(self._buffer):
+            raise OverflowError(f"Buffer overflow: not enough space for {len(source)} bytes")
+        self._buffer[self._position : self._position + len(source)] = source
+        self._position += len(source)
+
+    def write_string(self, value: str) -> None:
+        """
+        Write a UTF-8 encoded string.
+
+        Args:
+            value: String to encode and write
+
+        Raises:
+            OverflowError: If not enough space in buffer
+        """
+        encoded = value.encode("utf-8")
+        self.write_bytes(encoded)
+
+    def reset(self) -> None:
+        """Reset position to beginning of buffer."""
+        self._position = 0