rocket-welder-sdk 1.1.38__tar.gz → 1.1.38.dev18__tar.gz

{rocket_welder_sdk-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.38
+Version: 1.1.38.dev18
 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.dev18/VERSION

@@ -0,0 +1 @@
+1.1.38.dev18

{rocket_welder_sdk-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/__init__.py

@@ -12,21 +12,9 @@ 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,
@@ -86,20 +74,12 @@ __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-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/controllers.py

@@ -758,13 +758,6 @@ 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-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/gst_metadata.py

@@ -54,14 +54,11 @@ class GstCaps:
     @classmethod
     def parse(cls, caps_string: str) -> GstCaps:
         """
-        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"
+        Parse GStreamer caps string.
+        Example: "video/x-raw, format=(string)RGB, width=(int)640, height=(int)480, framerate=(fraction)30/1"
 
         Args:
-            caps_string: Caps string in either format
+            caps_string: GStreamer caps string
 
         Returns:
             GstCaps instance
@@ -74,50 +71,9 @@ 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 or simple format: {caps_string}")
+            raise ValueError(f"Not a video/x-raw caps string: {caps_string}")
 
         try:
             # Parse width

{rocket_welder_sdk-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/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 (server/bind) at: %s", address)
-            return UnixSocketFrameSink.bind(address)
+            log.info("Creating Unix socket frame sink at: %s", address)
+            return UnixSocketFrameSink.connect(address)
 
         if protocol.is_nng:
             log.info("Creating NNG frame sink (%s) at: %s", protocol.schema, address)

{rocket_welder_sdk-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/rocket_welder_client.py

@@ -15,15 +15,7 @@ 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,
@@ -254,144 +246,6 @@ 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:
@@ -641,59 +495,3 @@ 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-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/segmentation_result.py

@@ -21,7 +21,6 @@ Features:
 
 import io
 import struct
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import BinaryIO, Iterator, List, Optional, Tuple, Union
 
@@ -419,134 +418,3 @@ 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-1.1.38 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk/transport/unix_socket_transport.py

@@ -22,26 +22,19 @@ 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,
-        server: Optional["UnixSocketServer"] = None,
-    ):
+    def __init__(self, sock: socket.socket, leave_open: bool = False):
         """
         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
@@ -76,45 +69,6 @@ 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:
@@ -158,10 +112,6 @@ 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 → rocket_welder_sdk-1.1.38.dev18}/rocket_welder_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.38
+Version: 1.1.38.dev18
 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/VERSION

@@ -1 +0,0 @@
-1.1.38