rocket-welder-sdk 1.1.38.dev22__py3-none-any.whl → 1.1.38.dev23__py3-none-any.whl

rocket_welder_sdk/__init__.py

@@ -12,9 +12,21 @@ from .connection_string import ConnectionMode, ConnectionString, Protocol
 from .controllers import DuplexShmController, IController, OneWayShmController
 from .frame_metadata import FRAME_METADATA_SIZE, FrameMetadata, GstVideoFormat
 from .gst_metadata import GstCaps, GstMetadata
+from .keypoints_protocol import (
+    IKeyPointsSink,
+    IKeyPointsWriter,
+    KeyPointsSink,
+    KeyPointsWriter,
+)
 from .opencv_controller import OpenCvController
 from .periodic_timer import PeriodicTimer, PeriodicTimerSync
 from .rocket_welder_client import RocketWelderClient
+from .segmentation_result import (
+    ISegmentationResultSink,
+    ISegmentationResultWriter,
+    SegmentationResultSink,
+    SegmentationResultWriter,
+)
 from .session_id import (
     # Explicit URL functions (PREFERRED - set by rocket-welder2)
     ACTIONS_SINK_URL_ENV,
@@ -74,12 +86,20 @@ __all__ = [
     "GstMetadata",
     "GstVideoFormat",
     "IController",
+    "IKeyPointsSink",
+    "IKeyPointsWriter",
+    "ISegmentationResultSink",
+    "ISegmentationResultWriter",
+    "KeyPointsSink",
+    "KeyPointsWriter",
     "OneWayShmController",
     "OpenCvController",
     "PeriodicTimer",
     "PeriodicTimerSync",
     "Protocol",
     "RocketWelderClient",
+    "SegmentationResultSink",
+    "SegmentationResultWriter",
     "get_actions_url",
     "get_actions_url_from_env",
     "get_configured_nng_urls",

rocket_welder_sdk/controllers.py

@@ -758,6 +758,13 @@ class DuplexShmController(IController):
 
             # GstCaps must be available for width/height/format
             # (FrameMetadata no longer contains these - they're stream-level, not per-frame)
+            # If not available yet, try to read metadata again (race condition with C# Server)
+            if not self._gst_caps and self._duplex_server and self._duplex_server.request_reader:
+                logger.debug("GstCaps not available, attempting to read metadata again...")
+                metadata = self._duplex_server.request_reader.get_metadata()
+                if metadata:
+                    self._on_metadata(metadata)
+
             if not self._gst_caps:
                 logger.warning(
                     "GstCaps not available, skipping frame %d", frame_metadata.frame_number

rocket_welder_sdk/gst_metadata.py

@@ -54,11 +54,14 @@ class GstCaps:
     @classmethod
     def parse(cls, caps_string: str) -> GstCaps:
         """
-        Parse GStreamer caps string.
-        Example: "video/x-raw, format=(string)RGB, width=(int)640, height=(int)480, framerate=(fraction)30/1"
+        Parse GStreamer caps string or simple format string.
+
+        Supports two formats:
+        1. Full GStreamer format: "video/x-raw, format=(string)RGB, width=(int)640, height=(int)480"
+        2. Simple format: "640x480 RGB" or "640x480 RGB @ 30.00fps"
 
         Args:
-            caps_string: GStreamer caps string
+            caps_string: Caps string in either format
 
         Returns:
             GstCaps instance
@@ -71,9 +74,50 @@ class GstCaps:
 
         caps_string = caps_string.strip()
 
+        # Try simple format first: "WIDTHxHEIGHT FORMAT" or "WIDTHxHEIGHT FORMAT @ FPS"
+        # Example: "320x240 BGR" or "1920x1080 RGB @ 30.00fps"
+        simple_match = re.match(r"^(\d+)x(\d+)\s+(\w+)(?:\s*@\s*([\d.]+)\s*fps)?$", caps_string)
+        if simple_match:
+            width = int(simple_match.group(1))
+            height = int(simple_match.group(2))
+            format_str = simple_match.group(3)
+            fps_str = simple_match.group(4)
+
+            framerate_num = None
+            framerate_den = None
+            if fps_str:
+                # Convert float FPS to fraction
+                fps = float(fps_str)
+                # Use common framerates or default to fps/1
+                if abs(fps - 30.0) < 0.01:
+                    framerate_num, framerate_den = 30, 1
+                elif abs(fps - 29.97) < 0.01:
+                    framerate_num, framerate_den = 30000, 1001
+                elif abs(fps - 25.0) < 0.01:
+                    framerate_num, framerate_den = 25, 1
+                elif abs(fps - 60.0) < 0.01:
+                    framerate_num, framerate_den = 60, 1
+                elif abs(fps - 59.94) < 0.01:
+                    framerate_num, framerate_den = 60000, 1001
+                else:
+                    framerate_num, framerate_den = int(fps * 1000), 1000
+
+            depth_type, channels, bytes_per_pixel = cls._map_gstreamer_format_to_numpy(format_str)
+            return cls(
+                width=width,
+                height=height,
+                format=format_str,
+                depth_type=depth_type,
+                channels=channels,
+                bytes_per_pixel=bytes_per_pixel,
+                framerate_num=framerate_num,
+                framerate_den=framerate_den,
+                caps_string=None,  # Not a real GStreamer caps string
+            )
+
         # Check if it's a video caps
         if not caps_string.startswith("video/x-raw"):
-            raise ValueError(f"Not a video/x-raw caps string: {caps_string}")
+            raise ValueError(f"Not a video/x-raw caps string or simple format: {caps_string}")
 
         try:
             # Parse width

rocket_welder_sdk/high_level/frame_sink_factory.py

@@ -84,8 +84,8 @@ class FrameSinkFactory:
             return StreamFrameSink(file_handle)
 
         if protocol.is_socket:
-            log.info("Creating Unix socket frame sink at: %s", address)
-            return UnixSocketFrameSink.connect(address)
+            log.info("Creating Unix socket frame sink (server/bind) at: %s", address)
+            return UnixSocketFrameSink.bind(address)
 
         if protocol.is_nng:
             log.info("Creating NNG frame sink (%s) at: %s", protocol.schema, address)

rocket_welder_sdk/rocket_welder_client.py

@@ -15,7 +15,15 @@ import numpy as np
 from .connection_string import ConnectionMode, ConnectionString, Protocol
 from .controllers import DuplexShmController, IController, OneWayShmController
 from .frame_metadata import FrameMetadata  # noqa: TC001 - used at runtime in callbacks
+from .high_level.connection_strings import KeyPointsConnectionString, SegmentationConnectionString
+from .high_level.frame_sink_factory import FrameSinkFactory
+from .keypoints_protocol import IKeyPointsSink, IKeyPointsWriter, KeyPointsSink
 from .opencv_controller import OpenCvController
+from .segmentation_result import (
+    ISegmentationResultSink,
+    ISegmentationResultWriter,
+    SegmentationResultSink,
+)
 from .session_id import (
     get_configured_nng_urls,
     get_nng_urls_from_env,
@@ -246,6 +254,144 @@ class RocketWelderClient:
             self._controller.start(actual_callback, cancellation_token)  # type: ignore[arg-type]
             logger.info("RocketWelder client started with %s", self._connection)
 
+    def start_with_writers(
+        self,
+        on_frame: Callable[[Mat, ISegmentationResultWriter, IKeyPointsWriter, Mat], None],  # type: ignore[valid-type]
+        cancellation_token: Optional[threading.Event] = None,
+    ) -> None:
+        """
+        Start receiving frames with segmentation and keypoints output support.
+
+        Creates sinks for streaming AI results to rocket-welder2.
+
+        Configuration via environment variables:
+        - SEGMENTATION_SINK_URL: URL for segmentation output (e.g., socket:///tmp/seg.sock)
+        - KEYPOINTS_SINK_URL: URL for keypoints output (e.g., socket:///tmp/kp.sock)
+
+        Args:
+            on_frame: Callback receiving (input_mat, seg_writer, kp_writer, output_mat).
+                     The writers are created per-frame and auto-flush on context exit.
+            cancellation_token: Optional cancellation token
+
+        Example:
+            def process_frame(input_mat, seg_writer, kp_writer, output_mat):
+                # Run AI inference
+                result = ai_model.infer(input_mat)
+
+                # Write segmentation results
+                for instance in result.instances:
+                    seg_writer.append(instance.class_id, instance.instance_id, instance.points)
+
+                # Write keypoints
+                for kp in result.keypoints:
+                    kp_writer.append(kp.id, kp.x, kp.y, kp.confidence)
+
+                # Copy/draw to output
+                output_mat[:] = input_mat
+
+            client.start_with_writers(process_frame)
+
+        Raises:
+            RuntimeError: If already running
+            ValueError: If connection type is not supported or not duplex mode
+        """
+        with self._lock:
+            if self._controller and self._controller.is_running:
+                raise RuntimeError("Client is already running")
+
+            # This overload requires duplex mode
+            if self._connection.connection_mode != ConnectionMode.DUPLEX:
+                raise ValueError("start_with_writers() requires duplex connection mode")
+
+            # Create controller
+            if self._connection.protocol == Protocol.SHM:
+                self._controller = DuplexShmController(self._connection)
+            elif self._connection.protocol == Protocol.FILE or bool(
+                self._connection.protocol & Protocol.MJPEG  # type: ignore[operator]
+            ):
+                self._controller = OpenCvController(self._connection)
+            else:
+                raise ValueError(f"Unsupported protocol: {self._connection.protocol}")
+
+            # Create sinks from environment
+            seg_sink = self._get_or_create_segmentation_sink()
+            kp_sink = self._get_or_create_keypoints_sink()
+
+            logger.info(
+                "Starting RocketWelder client with AI output support: seg=%s, kp=%s",
+                "configured" if seg_sink else "null",
+                "configured" if kp_sink else "null",
+            )
+
+            # Wrapper callback that creates per-frame writers
+            def writer_callback(
+                frame_metadata: FrameMetadata, input_mat: Mat, output_mat: Mat  # type: ignore[valid-type]
+            ) -> None:
+                # Get caps from controller metadata (width/height for segmentation)
+                metadata = self._controller.get_metadata() if self._controller else None
+                caps = metadata.caps if metadata else None
+
+                if caps is None:
+                    logger.warning(
+                        "GstCaps not available for frame %d, using no-op writers",
+                        frame_metadata.frame_number,
+                    )
+                    # Use no-op writers
+                    on_frame(
+                        input_mat, _NoOpSegmentationWriter(), _NoOpKeyPointsWriter(), output_mat
+                    )
+                    return
+
+                # Create per-frame writers from sinks
+                with seg_sink.create_writer(
+                    frame_metadata.frame_number, caps.width, caps.height
+                ) as seg_writer, kp_sink.create_writer(frame_metadata.frame_number) as kp_writer:
+                    # Call user callback with writers
+                    on_frame(input_mat, seg_writer, kp_writer, output_mat)
+                    # Writers auto-flush on context exit
+
+            # Start the controller with our wrapper
+            self._controller.start(writer_callback, cancellation_token)  # type: ignore[arg-type]
+            logger.info("RocketWelder client started with writers: %s", self._connection)
+
+    def _get_or_create_segmentation_sink(self) -> ISegmentationResultSink:
+        """Get or create segmentation result sink from environment."""
+        import os
+
+        url = os.environ.get("SEGMENTATION_SINK_URL")
+        if not url:
+            logger.debug("SEGMENTATION_SINK_URL not set, using null sink")
+            return _NullSegmentationSink()
+
+        try:
+            cs = SegmentationConnectionString.parse(url)
+            frame_sink = FrameSinkFactory.create(cs.protocol, cs.address)
+            return SegmentationResultSink(frame_sink=frame_sink, owns_sink=True)
+        except Exception as ex:
+            logger.warning("Failed to create segmentation sink from %s: %s", url, ex)
+            return _NullSegmentationSink()
+
+    def _get_or_create_keypoints_sink(self) -> IKeyPointsSink:
+        """Get or create keypoints sink from environment."""
+        import os
+
+        url = os.environ.get("KEYPOINTS_SINK_URL")
+        if not url:
+            logger.debug("KEYPOINTS_SINK_URL not set, using null sink")
+            return _NullKeyPointsSink()
+
+        try:
+            cs = KeyPointsConnectionString.parse(url)
+            frame_sink = FrameSinkFactory.create(cs.protocol, cs.address)
+            return KeyPointsSink(
+                frame_sink=frame_sink,
+                master_frame_interval=cs.master_frame_interval,
+                owns_sink=True,
+            )
+        except Exception as ex:
+            logger.warning("Failed to create keypoints sink from %s: %s", url, ex)
+            return _NullKeyPointsSink()
+
     def stop(self) -> None:
         """Stop the client and clean up resources."""
         with self._lock:
@@ -495,3 +641,59 @@ class RocketWelderClient:
             f"shm://{buffer_name}?size={buffer_size}&metadata={metadata_size}&mode=Duplex"
         )
         return cls(connection_str)
+
+
+# No-op implementations for when sinks are not configured
+
+
+class _NoOpKeyPointsWriter(IKeyPointsWriter):
+    """No-op keypoints writer that discards all data."""
+
+    def append(self, keypoint_id: int, x: int, y: int, confidence: float) -> None:
+        """Discard keypoint data."""
+        pass
+
+    def append_point(self, keypoint_id: int, point: tuple, confidence: float) -> None:  # type: ignore[type-arg]
+        """Discard keypoint data."""
+        pass
+
+    def close(self) -> None:
+        """No-op close."""
+        pass
+
+
+class _NoOpSegmentationWriter(ISegmentationResultWriter):
+    """No-op segmentation writer that discards all data."""
+
+    def append(self, class_id: int, instance_id: int, points: Any) -> None:
+        """Discard segmentation data."""
+        pass
+
+    def close(self) -> None:
+        """No-op close."""
+        pass
+
+
+class _NullKeyPointsSink(IKeyPointsSink):
+    """Null keypoints sink that creates no-op writers."""
+
+    def create_writer(self, frame_id: int) -> IKeyPointsWriter:
+        """Create a no-op writer."""
+        return _NoOpKeyPointsWriter()
+
+    @staticmethod
+    def read(json_definition: str, blob_stream: Any) -> Any:
+        """Not supported for null sink."""
+        raise NotImplementedError("NullKeyPointsSink does not support reading")
+
+
+class _NullSegmentationSink(ISegmentationResultSink):
+    """Null segmentation sink that creates no-op writers."""
+
+    def create_writer(self, frame_id: int, width: int, height: int) -> ISegmentationResultWriter:
+        """Create a no-op writer."""
+        return _NoOpSegmentationWriter()
+
+    def close(self) -> None:
+        """No-op close."""
+        pass

rocket_welder_sdk/segmentation_result.py

@@ -21,6 +21,7 @@ Features:
 
 import io
 import struct
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import BinaryIO, Iterator, List, Optional, Tuple, Union
 
@@ -418,3 +419,134 @@ class SegmentationResultReader:
     def __exit__(self, *args: object) -> None:
         """Context manager exit."""
         pass
+
+
+class ISegmentationResultWriter(ABC):
+    """Interface for writing segmentation results for a single frame."""
+
+    @abstractmethod
+    def append(
+        self,
+        class_id: int,
+        instance_id: int,
+        points: Union[List[Point], PointArray],
+    ) -> None:
+        """
+        Append an instance with contour points.
+
+        Args:
+            class_id: Object class ID (0-255)
+            instance_id: Instance ID within class (0-255)
+            points: List of (x, y) tuples or NumPy array of shape (N, 2)
+        """
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """Flush and close the writer."""
+        pass
+
+    def __enter__(self) -> "ISegmentationResultWriter":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        """Context manager exit."""
+        self.close()
+
+
+class ISegmentationResultSink(ABC):
+    """
+    Factory for creating segmentation result writers per frame (transport-agnostic).
+
+    Mirrors C# ISegmentationResultSink interface.
+    """
+
+    @abstractmethod
+    def create_writer(self, frame_id: int, width: int, height: int) -> ISegmentationResultWriter:
+        """
+        Create a writer for the current frame.
+
+        Args:
+            frame_id: Unique frame identifier
+            width: Frame width in pixels
+            height: Frame height in pixels
+
+        Returns:
+            Segmentation result writer for this frame
+        """
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the sink and release resources."""
+        pass
+
+    def __enter__(self) -> "ISegmentationResultSink":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        """Context manager exit."""
+        self.close()
+
+
+class SegmentationResultSink(ISegmentationResultSink):
+    """
+    Transport-agnostic segmentation result sink.
+
+    Creates writers for each frame that serialize to the underlying IFrameSink.
+
+    Thread-safe: No (caller must synchronize)
+    """
+
+    def __init__(
+        self,
+        stream: Optional[BinaryIO] = None,
+        *,
+        frame_sink: Optional[IFrameSink] = None,
+        owns_sink: bool = False,
+    ) -> None:
+        """
+        Initialize segmentation result sink.
+
+        Args:
+            stream: BinaryIO stream (convenience - auto-wraps in StreamFrameSink)
+            frame_sink: IFrameSink to write frames to (keyword-only, transport-agnostic)
+            owns_sink: If True, closes the sink on disposal (keyword-only)
+
+        Note:
+            Either stream or frame_sink must be provided (not both).
+            For convenience, stream is the primary parameter (auto-wraps in StreamFrameSink).
+            For transport-agnostic usage, use frame_sink= keyword argument.
+        """
+        if frame_sink is None and stream is None:
+            raise TypeError("Either stream or frame_sink must be provided")
+
+        if frame_sink is not None and stream is not None:
+            raise TypeError("Cannot provide both stream and frame_sink")
+
+        # Convenience: auto-wrap stream in StreamFrameSink
+        if stream is not None:
+            self._frame_sink: IFrameSink = StreamFrameSink(stream, leave_open=False)
+            self._owns_sink = True
+        else:
+            assert frame_sink is not None
+            self._frame_sink = frame_sink
+            self._owns_sink = owns_sink
+
+    def create_writer(self, frame_id: int, width: int, height: int) -> ISegmentationResultWriter:
+        """Create a writer for the current frame."""
+        # SegmentationResultWriter implements the write methods we need
+        # We return it as ISegmentationResultWriter
+        return SegmentationResultWriter(  # type: ignore[return-value]
+            frame_id=frame_id,
+            width=width,
+            height=height,
+            frame_sink=self._frame_sink,
+        )
+
+    def close(self) -> None:
+        """Close the sink and release resources."""
+        if self._owns_sink:
+            self._frame_sink.close()

rocket_welder_sdk/transport/unix_socket_transport.py

@@ -22,19 +22,26 @@ class UnixSocketFrameSink(IFrameSink):
     Each frame is prefixed with a 4-byte little-endian length header.
     """
 
-    def __init__(self, sock: socket.socket, leave_open: bool = False):
+    def __init__(
+        self,
+        sock: socket.socket,
+        leave_open: bool = False,
+        server: Optional["UnixSocketServer"] = None,
+    ):
         """
         Create a Unix socket frame sink.
 
         Args:
             sock: Connected Unix domain socket
             leave_open: If True, doesn't close socket on close
+            server: Optional server to clean up on close (used by bind())
         """
         if sock.family != socket.AF_UNIX:
             raise ValueError("Socket must be a Unix domain socket")
 
         self._socket = sock
         self._leave_open = leave_open
+        self._server = server
         self._closed = False
 
     @classmethod
@@ -69,6 +76,45 @@ class UnixSocketFrameSink(IFrameSink):
         await loop.sock_connect(sock, socket_path)
         return cls(sock, leave_open=False)
 
+    @classmethod
+    def bind(cls, socket_path: str) -> "UnixSocketFrameSink":
+        """
+        Bind to a Unix socket path as a server and wait for a client to connect.
+
+        Use this when the SDK is the producer (server) and rocket-welder2 is
+        the consumer (client).
+
+        Args:
+            socket_path: Path to Unix socket file
+
+        Returns:
+            Frame sink connected to the first client
+
+        Note:
+            This is the server-side counterpart to connect().
+            The server binds and listens, then blocks until a client connects.
+        """
+        server = UnixSocketServer(socket_path)
+        server.start()
+        client_socket = server.accept()
+        return cls(client_socket, leave_open=False, server=server)
+
+    @classmethod
+    async def bind_async(cls, socket_path: str) -> "UnixSocketFrameSink":
+        """
+        Bind to a Unix socket path as a server and wait asynchronously for a client.
+
+        Args:
+            socket_path: Path to Unix socket file
+
+        Returns:
+            Frame sink connected to the first client
+        """
+        server = UnixSocketServer(socket_path)
+        server.start()
+        client_socket = await server.accept_async()
+        return cls(client_socket, leave_open=False, server=server)
+
     def write_frame(self, frame_data: bytes) -> None:
         """Write frame with 4-byte length prefix to Unix socket."""
         if self._closed:
@@ -112,6 +158,10 @@ class UnixSocketFrameSink(IFrameSink):
             with contextlib.suppress(OSError):
                 self._socket.shutdown(socket.SHUT_WR)
             self._socket.close()
+        # Clean up server if we created one via bind()
+        if self._server is not None:
+            self._server.stop()
+            self._server = None
 
     async def close_async(self) -> None:
         """Close the Unix socket sink asynchronously."""

{rocket_welder_sdk-1.1.38.dev22.dist-info → rocket_welder_sdk-1.1.38.dev23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.38.dev22
+Version: 1.1.38.dev23
 Summary: High-performance video streaming SDK for RocketWelder services using ZeroBuffer IPC
 Home-page: https://github.com/modelingevolution/rocket-welder-sdk
 Author: ModelingEvolution

{rocket_welder_sdk-1.1.38.dev22.dist-info → rocket_welder_sdk-1.1.38.dev23.dist-info}/RECORD

@@ -1,15 +1,15 @@
-rocket_welder_sdk/__init__.py,sha256=pcYOCqqYuK8oJwkFRnWej4uNfEkuYWXP6jcUhPSLgrc,3041
+rocket_welder_sdk/__init__.py,sha256=xAy90cHORXwtphmNrvWaNs-YP4MAx3GIOZX_jJoIWxs,3530
 rocket_welder_sdk/bytes_size.py,sha256=Myl29-wyWCIYdbMmgaxXebT8Dz8_Fwcr3fnfaNW81P0,7463
 rocket_welder_sdk/connection_string.py,sha256=NIC6OiOXF-DeBFCWzgMFOWsenrSS45hY81j_HLMSpgo,9974
-rocket_welder_sdk/controllers.py,sha256=tPfQ2GZRfLbj-M21uAa9X3cFzrBBvqSbxTUxPiaZ5xc,32690
+rocket_welder_sdk/controllers.py,sha256=uuVyKsNHtpaIzQt8pXCAu7SywoFa7cfww8VSa4LNi_E,33130
 rocket_welder_sdk/frame_metadata.py,sha256=TMLIY47cIdIlxqk9xj7I3M8FZFmZ3GcVoLZht7prjQM,3929
-rocket_welder_sdk/gst_metadata.py,sha256=jEQvZX4BdR6OR3lqp12PV-HEXZhcxfiS010diA2CbMM,14213
+rocket_welder_sdk/gst_metadata.py,sha256=6Ov-DekGsKNuAo3UIc-g9fh4_SAPdHYQTnnPqCK3Ks0,16180
 rocket_welder_sdk/keypoints_protocol.py,sha256=NKiSPrevWG4_RrD6jtFxPjwftlaPWe1CqoFVKRMwp4k,21858
 rocket_welder_sdk/opencv_controller.py,sha256=MDM6_yFBB9BaMa5jnZRqw7xZZB-WuLr7EPrrfHQ2DK4,9905
 rocket_welder_sdk/periodic_timer.py,sha256=hnObybmrnf3J47QrNKJhYAytLKwria016123NvPRfQ0,9369
 rocket_welder_sdk/py.typed,sha256=0cXFZXmes4Y-vnl4lO3HtyyyWaFNw85B7tJdFeCtHDc,67
-rocket_welder_sdk/rocket_welder_client.py,sha256=0SNsrP9SePTHNLbfKyt-71UYs2owrZwesiwOXNglI4c,18515
-rocket_welder_sdk/segmentation_result.py,sha256=q3n8m1sooPcattfXisL9em5gZKbEZ1ueGqeXfOrdaHY,13417
+rocket_welder_sdk/rocket_welder_client.py,sha256=dhjjak7F6xTlLZDVl7TPPiX0KpyWb0DQhrTP3GrkuPM,26655
+rocket_welder_sdk/segmentation_result.py,sha256=c2C42C9l8iaRyTWR6ZOL1kLO4jHP_yjeVMf5DaKkY8E,17525
 rocket_welder_sdk/session_id.py,sha256=sRhzQw90shqq_DJVtrsSggcGZ775kz7cRfbI-1LMeSA,7027
 rocket_welder_sdk/external_controls/__init__.py,sha256=ldOLGhLLS5BQL8m4VKFYV0SvsNNlV2tghlc7rkqadU8,699
 rocket_welder_sdk/external_controls/contracts.py,sha256=3DU6pdpteN50gF2fsS7C2279dGjDa0tZLrLntkBa2LM,2607
@@ -18,7 +18,7 @@ rocket_welder_sdk/high_level/__init__.py,sha256=jzLaAhmay_k03gaPgv9fdfBjn6b1xbiQ
 rocket_welder_sdk/high_level/client.py,sha256=IFnbO9JI1KhnCljHiwFZbhx4qMW_z8BdTz4uAi0d7TA,8284
 rocket_welder_sdk/high_level/connection_strings.py,sha256=q1uZJQ7mt1RR-E8MJzIwG6vz3Ddruoc3pTCdTvg_pe4,10434
 rocket_welder_sdk/high_level/data_context.py,sha256=SXJvDpDBFi8Lm4XqSRSHK7YUUHuugXGo4ZRCb6_z5l0,4833
-rocket_welder_sdk/high_level/frame_sink_factory.py,sha256=x2E6w03lj3p1x1Im18K9kAhcWCwx52EMp9waLFFdCQ0,3989
+rocket_welder_sdk/high_level/frame_sink_factory.py,sha256=JeQXp7_OoAQzcAb6XOsBt_Ewen_KbvYQ82YLDyx71tQ,4000
 rocket_welder_sdk/high_level/schema.py,sha256=2Vv0rDwahtGswWB_ceaCdc7JDtmbkx4wE2jQePzeTpU,5367
 rocket_welder_sdk/high_level/transport_protocol.py,sha256=EFF0bgNn9hxRMj67FwU6MVu-UiEFINSGhd2VC8agrgc,7393
 rocket_welder_sdk/transport/__init__.py,sha256=iU5keW_VYHybvGBkDX1AxcCp9IhYvbqPBegu-w9IPX8,787
@@ -27,14 +27,14 @@ rocket_welder_sdk/transport/frame_source.py,sha256=G1rBAQS1AgOOdtASB0_CYon8g20hU
 rocket_welder_sdk/transport/nng_transport.py,sha256=o-qgcmHCGnwtdPe-mwwrC-a9H0rgS-VdH2QvU-6kFlI,5838
 rocket_welder_sdk/transport/stream_transport.py,sha256=FhxFlZT-CTo6aPq6VclM1A_ecqfeHcwR4Ty1vmlt3W0,5886
 rocket_welder_sdk/transport/tcp_transport.py,sha256=Tui6nKgu50C1KV_UDANQKgVK3M52XN7zrkZTcWIpGmY,4745
-rocket_welder_sdk/transport/unix_socket_transport.py,sha256=6N_V5nsoxlI5-oR1watCxU-jWVbXw4OQGhcTvCkKZh4,10612
+rocket_welder_sdk/transport/unix_socket_transport.py,sha256=t44Q2Fj6fMv53Ll561hN35-ZbHPdAQt0t9tUAXoL0rY,12245
 rocket_welder_sdk/ui/__init__.py,sha256=5-fCkv3vG0VVVZkselrifkMmx8d51EJp3nNT9mt4JK4,886
 rocket_welder_sdk/ui/controls.py,sha256=cRBxdUDWMOYlCxtw1PV11fTlte6qLxSfCGpr9bQiLcE,11162
 rocket_welder_sdk/ui/icons.py,sha256=DcDklZkPmiEzlOD4IR7VTJOtGPCuuh_OM_WN7ScghWE,8934592
 rocket_welder_sdk/ui/ui_events_projection.py,sha256=siiNhjLEBOPfTKw1ZhOPGkwIN5rLDH7V9VCZTNrhEtQ,7836
 rocket_welder_sdk/ui/ui_service.py,sha256=uRdpyJGoCQmtOli_HKSrxLwhZYG-XRuHIYdkmFz1zNk,12026
 rocket_welder_sdk/ui/value_types.py,sha256=f7OA_9zgXEDPoITc8v8SfAR23I4XeFhE3E2_GcAbR6k,1616
-rocket_welder_sdk-1.1.38.dev22.dist-info/METADATA,sha256=fG5X2oIqKbgHx25V4k0Q7W7LgzExHp3V7fdV0x3E_2k,24853
-rocket_welder_sdk-1.1.38.dev22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rocket_welder_sdk-1.1.38.dev22.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
-rocket_welder_sdk-1.1.38.dev22.dist-info/RECORD,,
+rocket_welder_sdk-1.1.38.dev23.dist-info/METADATA,sha256=H4xaBC0-0Klx4Z7Egg16M9QuV0UE7Gjl2hurUDyNB_U,24853
+rocket_welder_sdk-1.1.38.dev23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rocket_welder_sdk-1.1.38.dev23.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
+rocket_welder_sdk-1.1.38.dev23.dist-info/RECORD,,