rocket-welder-sdk 1.1.44__py3-none-any.whl → 1.1.46__py3-none-any.whl

rocket_welder_sdk/rocket_welder_client.py

@@ -15,7 +15,12 @@ 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 .graphics import ILayerCanvas, IStageSink, IStageWriter, RgbColor, StageSink
+from .high_level.connection_strings import (
+    GraphicsConnectionString,
+    KeyPointsConnectionString,
+    SegmentationConnectionString,
+)
 from .high_level.frame_sink_factory import FrameSinkFactory
 from .keypoints_protocol import IKeyPointsSink, IKeyPointsWriter, KeyPointsSink
 from .opencv_controller import OpenCvController
@@ -188,25 +193,26 @@ class RocketWelderClient:
 
     def start_with_writers(
         self,
-        on_frame: Callable[[Mat, ISegmentationResultWriter, IKeyPointsWriter, Mat], None],  # type: ignore[valid-type]
+        on_frame: Callable[[Mat, ISegmentationResultWriter, IKeyPointsWriter, IStageWriter, Mat], None],  # type: ignore[valid-type]
         cancellation_token: Optional[threading.Event] = None,
     ) -> None:
         """
-        Start receiving frames with segmentation and keypoints output support.
+        Start receiving frames with segmentation, keypoints, and graphics 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)
+        - STAGE_SINK_URL: URL for graphics/stage output (e.g., socket:///tmp/stage.sock)
 
         Args:
-            on_frame: Callback receiving (input_mat, seg_writer, kp_writer, output_mat).
+            on_frame: Callback receiving (input_mat, seg_writer, kp_writer, stage_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):
+            def process_frame(input_mat, seg_writer, kp_writer, stage_writer, output_mat):
                 # Run AI inference
                 result = ai_model.infer(input_mat)
 
@@ -218,6 +224,11 @@ class RocketWelderClient:
                 for kp in result.keypoints:
                     kp_writer.append(kp.id, kp.x, kp.y, kp.confidence)
 
+                # Draw graphics overlay
+                layer = stage_writer[0]
+                layer.set_font_size(24)
+                layer.draw_text("Detection count: 5", 10, 30)
+
                 # Copy/draw to output
                 output_mat[:] = input_mat
 
@@ -248,11 +259,13 @@ class RocketWelderClient:
             # Create sinks from environment
             seg_sink = self._get_or_create_segmentation_sink()
             kp_sink = self._get_or_create_keypoints_sink()
+            stage_sink = self._get_or_create_stage_sink()
 
             logger.info(
-                "Starting RocketWelder client with AI output support: seg=%s, kp=%s",
+                "Starting RocketWelder client with AI output support: seg=%s, kp=%s, stage=%s",
                 "configured" if seg_sink else "null",
                 "configured" if kp_sink else "null",
+                "configured" if stage_sink else "null",
             )
 
             # Wrapper callback that creates per-frame writers
@@ -269,23 +282,155 @@ class RocketWelderClient:
                         frame_metadata.frame_number,
                     )
                     # Use no-op writers
-                    on_frame(
-                        input_mat, _NoOpSegmentationWriter(), _NoOpKeyPointsWriter(), output_mat
-                    )
+                    with stage_sink.create_writer(frame_metadata.frame_number) as stage_writer:
+                        on_frame(
+                            input_mat,
+                            _NoOpSegmentationWriter(),
+                            _NoOpKeyPointsWriter(),
+                            stage_writer,
+                            output_mat,
+                        )
                     return
 
-                # Create per-frame writers from sinks
+                # Create per-frame writers from sinks (all auto-flush on context exit)
                 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:
+                ) as seg_writer, kp_sink.create_writer(
+                    frame_metadata.frame_number
+                ) as kp_writer, stage_sink.create_writer(
+                    frame_metadata.frame_number
+                ) as stage_writer:
                     # Call user callback with writers
-                    on_frame(input_mat, seg_writer, kp_writer, output_mat)
+                    on_frame(input_mat, seg_writer, kp_writer, stage_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 start_with_writers_oneway(
+        self,
+        on_frame: Callable[[Mat, ISegmentationResultWriter, IKeyPointsWriter, IStageWriter], None],  # type: ignore[valid-type]
+        cancellation_token: Optional[threading.Event] = None,
+    ) -> None:
+        """
+        Start receiving frames with writers in ONE-WAY mode (no output frame).
+
+        This is for inference-only containers that consume frames but don't produce
+        modified output. Data is streamed via Unix sockets for downstream consumers.
+
+        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)
+        - GRAPHICS_SINK_URL: URL for graphics/stage output (e.g., socket:///tmp/stage.sock)
+
+        Args:
+            on_frame: Callback receiving (input_mat, seg_writer, kp_writer, stage_writer).
+                     Note: NO output_mat parameter - this is one-way/sink mode.
+            cancellation_token: Optional cancellation token
+
+        Example:
+            def process_frame(input_mat, seg_writer, kp_writer, stage_writer):
+                # 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)
+
+                # Draw graphics overlay
+                layer = stage_writer[0]
+                layer.set_font_size(24)
+                layer.draw_text("Detection count: 5", 10, 30)
+
+                # NOTE: No output_mat - we don't modify frames in sink mode
+
+            client.start_with_writers_oneway(process_frame)
+
+        Raises:
+            RuntimeError: If already running
+            ValueError: If connection type is not supported
+        """
+        with self._lock:
+            if self._controller and self._controller.is_running:
+                raise RuntimeError("Client is already running")
+
+            # Create controller - OneWay mode uses OneWayShmController
+            if self._connection.protocol == Protocol.SHM:
+                if self._connection.connection_mode == ConnectionMode.DUPLEX:
+                    # For duplex mode, use the other method
+                    raise ValueError(
+                        "start_with_writers_oneway() is for OneWay mode. "
+                        "Use start_with_writers() for Duplex mode."
+                    )
+                self._controller = OneWayShmController(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()
+            stage_sink = self._get_or_create_stage_sink()
+
+            logger.info(
+                "Starting RocketWelder client with AI output support (one-way): seg=%s, kp=%s, stage=%s",
+                "configured" if seg_sink else "null",
+                "configured" if kp_sink else "null",
+                "configured" if stage_sink else "null",
+            )
+
+            # Track frame number manually for one-way mode (no FrameMetadata from controller)
+            frame_number_holder = [0]  # Use list to allow mutation in nested function
+
+            # Wrapper callback that creates per-frame writers
+            # OneWay controller provides only input Mat, no output Mat
+            def writer_callback_oneway(input_mat: Mat) -> None:  # type: ignore[valid-type]
+                frame_number_holder[0] += 1
+                frame_number = frame_number_holder[0]
+
+                # 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_number,
+                    )
+                    # Use no-op writers
+                    with stage_sink.create_writer(frame_number) as stage_writer:
+                        on_frame(
+                            input_mat,
+                            _NoOpSegmentationWriter(),
+                            _NoOpKeyPointsWriter(),
+                            stage_writer,
+                        )
+                    return
+
+                # Create per-frame writers from sinks (all auto-flush on context exit)
+                with seg_sink.create_writer(
+                    frame_number, caps.width, caps.height
+                ) as seg_writer, kp_sink.create_writer(
+                    frame_number
+                ) as kp_writer, stage_sink.create_writer(
+                    frame_number
+                ) as stage_writer:
+                    # Call user callback with writers (no output_mat for one-way)
+                    on_frame(input_mat, seg_writer, kp_writer, stage_writer)
+                    # Writers auto-flush on context exit
+
+            # Start the controller with our wrapper (single-Mat callback for OneWay)
+            self._controller.start(writer_callback_oneway, cancellation_token)
+            logger.info("RocketWelder client started with writers (one-way): %s", self._connection)
+
     def _get_or_create_segmentation_sink(self) -> ISegmentationResultSink:
         """Get or create segmentation result sink from environment."""
         import os
@@ -324,6 +469,23 @@ class RocketWelderClient:
             logger.warning("Failed to create keypoints sink from %s: %s", url, ex)
             return _NullKeyPointsSink()
 
+    def _get_or_create_stage_sink(self) -> IStageSink:
+        """Get or create graphics stage sink from environment."""
+        import os
+
+        url = os.environ.get("GRAPHICS_SINK_URL")
+        if not url:
+            logger.debug("GRAPHICS_SINK_URL not set, using null sink")
+            return _NullStageSink()
+
+        try:
+            cs = GraphicsConnectionString.parse(url)
+            frame_sink = FrameSinkFactory.create(cs.protocol, cs.address)
+            return StageSink(frame_sink=frame_sink, owns_sink=True)
+        except Exception as ex:
+            logger.warning("Failed to create graphics stage sink from %s: %s", url, ex)
+            return _NullStageSink()
+
     def stop(self) -> None:
         """Stop the client and clean up resources."""
         with self._lock:
@@ -620,3 +782,162 @@ class _NullSegmentationSink(ISegmentationResultSink):
     def close(self) -> None:
         """No-op close."""
         pass
+
+
+class _NoOpLayerCanvas(ILayerCanvas):
+    """No-op layer canvas that discards all drawing operations."""
+
+    @property
+    def layer_id(self) -> int:
+        """The layer ID."""
+        return 0
+
+    # Frame type
+    def master(self) -> None:
+        """No-op."""
+        pass
+
+    def remain(self) -> None:
+        """No-op."""
+        pass
+
+    def clear(self) -> None:
+        """No-op."""
+        pass
+
+    # Context state - Styling
+    def set_stroke(self, color: RgbColor) -> None:
+        """No-op."""
+        pass
+
+    def set_fill(self, color: RgbColor) -> None:
+        """No-op."""
+        pass
+
+    def set_thickness(self, width: int) -> None:
+        """No-op."""
+        pass
+
+    def set_font_size(self, size: int) -> None:
+        """No-op."""
+        pass
+
+    def set_font_color(self, color: RgbColor) -> None:
+        """No-op."""
+        pass
+
+    # Context state - Transforms
+    def translate(self, dx: float, dy: float) -> None:
+        """No-op."""
+        pass
+
+    def rotate(self, degrees: float) -> None:
+        """No-op."""
+        pass
+
+    def scale(self, sx: float, sy: float) -> None:
+        """No-op."""
+        pass
+
+    def skew(self, kx: float, ky: float) -> None:
+        """No-op."""
+        pass
+
+    def set_matrix(
+        self,
+        scale_x: float,
+        skew_x: float,
+        trans_x: float,
+        skew_y: float,
+        scale_y: float,
+        trans_y: float,
+    ) -> None:
+        """No-op."""
+        pass
+
+    # Context stack
+    def save(self) -> None:
+        """No-op."""
+        pass
+
+    def restore(self) -> None:
+        """No-op."""
+        pass
+
+    def reset_context(self) -> None:
+        """No-op."""
+        pass
+
+    # Draw operations
+    def draw_polygon(self, points: Any) -> None:
+        """No-op."""
+        pass
+
+    def draw_text(self, text: str, x: int, y: int) -> None:
+        """No-op."""
+        pass
+
+    def draw_circle(self, center_x: int, center_y: int, radius: int) -> None:
+        """No-op."""
+        pass
+
+    def draw_rectangle(self, x: int, y: int, width: int, height: int) -> None:
+        """No-op."""
+        pass
+
+    def draw_line(self, x1: int, y1: int, x2: int, y2: int) -> None:
+        """No-op."""
+        pass
+
+    def draw_jpeg(self, jpeg_data: bytes, x: int, y: int, width: int, height: int) -> None:
+        """No-op."""
+        pass
+
+
+# Singleton instance
+_NO_OP_LAYER_CANVAS = _NoOpLayerCanvas()
+
+
+class _NoOpStageWriter(IStageWriter):
+    """No-op stage writer that discards all graphics operations."""
+
+    @property
+    def frame_id(self) -> int:
+        """The frame ID."""
+        return 0
+
+    def __getitem__(self, layer_id: int) -> ILayerCanvas:
+        """Returns no-op layer canvas."""
+        return _NO_OP_LAYER_CANVAS
+
+    def layer(self, layer_id: int) -> ILayerCanvas:
+        """Returns no-op layer canvas."""
+        return _NO_OP_LAYER_CANVAS
+
+    def close(self) -> None:
+        """No-op close."""
+        pass
+
+    def __enter__(self) -> _NoOpStageWriter:
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        """Context manager exit."""
+        pass
+
+
+# Singleton instance
+_NO_OP_STAGE_WRITER = _NoOpStageWriter()
+
+
+class _NullStageSink(IStageSink):
+    """Null stage sink that creates no-op writers."""
+
+    def create_writer(self, frame_id: int) -> IStageWriter:
+        """Create a no-op writer."""
+        return _NO_OP_STAGE_WRITER
+
+    def close(self) -> None:
+        """No-op close."""
+        pass

rocket_welder_sdk/session_id.py

@@ -27,6 +27,7 @@ SESSION_ID_ENV_VAR = "SessionId"
 SEGMENTATION_SINK_URL_ENV = "SEGMENTATION_SINK_URL"
 KEYPOINTS_SINK_URL_ENV = "KEYPOINTS_SINK_URL"
 ACTIONS_SINK_URL_ENV = "ACTIONS_SINK_URL"
+GRAPHICS_SINK_URL_ENV = "GRAPHICS_SINK_URL"
 
 
 def parse_session_id(session_id: str) -> uuid.UUID:

{rocket_welder_sdk-1.1.44.dist-info → rocket_welder_sdk-1.1.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.44
+Version: 1.1.46
 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.44.dist-info → rocket_welder_sdk-1.1.46.dist-info}/RECORD

@@ -1,4 +1,4 @@
-rocket_welder_sdk/__init__.py,sha256=r2zUZzUMZuAPUy5Sat5EWaxeocIjRbdqBDoC1i0C89w,3413
+rocket_welder_sdk/__init__.py,sha256=5hcsNb0zu8dtRHD9sgCAi4YbWJe-1g6cl9jSuLQZk_U,3889
 rocket_welder_sdk/binary_frame_reader.py,sha256=5IyYO7yv07gLpQ9Toyw1zLkTrnqHLjxIeMVRn8B40-E,6270
 rocket_welder_sdk/binary_frame_writer.py,sha256=2-VEJNHw0fL30TXsCBHyhHltvgx7KUahmbamwdSU8sw,6658
 rocket_welder_sdk/bytes_size.py,sha256=Myl29-wyWCIYdbMmgaxXebT8Dz8_Fwcr3fnfaNW81P0,7463
@@ -12,16 +12,22 @@ rocket_welder_sdk/keypoints_protocol.py,sha256=kN8ok6Ptpgl4txoQE9DpKhMoI7zr73vTw
 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=VqxP-GkJKCZCjGZq2tVJ7v5yrh-ztXxlF3CT__818vg,23384
+rocket_welder_sdk/rocket_welder_client.py,sha256=4jfusvxMxAU5j2NXiOhYzgWEC1VNFFk_XXv7QEvwmSU,34481
 rocket_welder_sdk/segmentation_result.py,sha256=b3xpv6AZyWzm924cd1RfXwCuEwdkPL5TUA0gzT3HpBA,29153
-rocket_welder_sdk/session_id.py,sha256=9GM4T6xmcNxR9gxZnDUlQGviNd3x3hT71q8y85XtH6g,1884
+rocket_welder_sdk/session_id.py,sha256=YgnDwmdOcdJTXIObjkrzIkxU2gbMzNko1h1ms4lNIfU,1928
 rocket_welder_sdk/varint.py,sha256=SmffemQCXToRzs3lb7hWQWDY7NmKv4XG_Wb0oeMrb_I,5058
 rocket_welder_sdk/external_controls/__init__.py,sha256=ldOLGhLLS5BQL8m4VKFYV0SvsNNlV2tghlc7rkqadU8,699
 rocket_welder_sdk/external_controls/contracts.py,sha256=3DU6pdpteN50gF2fsS7C2279dGjDa0tZLrLntkBa2LM,2607
 rocket_welder_sdk/external_controls/contracts_old.py,sha256=XWriuXJZu5caTSS0bcTIOZcKnj-IRCm96voA4gqLBfU,2980
+rocket_welder_sdk/graphics/__init__.py,sha256=4sKaqeu391WfVX1c_TDxAbucy7OJF8Aw8CG77NeggFA,1230
+rocket_welder_sdk/graphics/layer_canvas.py,sha256=FcgrrCaI-2XlVOs4qYTGvpJQdVw_NP2V7D4a1LgLtS4,4580
+rocket_welder_sdk/graphics/protocol.py,sha256=57GOx9rlKGojm7jnXdM2t3bpa4Ykii1o3wQtQ5IO-Hs,1357
+rocket_welder_sdk/graphics/rgb_color.py,sha256=do6y362CTROiLMqbQwdvJF07L8wMWRv3n7-PVWP-Flk,3497
+rocket_welder_sdk/graphics/stage.py,sha256=2hgkKGCxLxcZ64cHBKgxxFHSZOlLue236x5f43cmYk0,15538
+rocket_welder_sdk/graphics/vector_graphics_encoder.py,sha256=lD3cIOAVL_JvKZayIQ_TaQ5fa8S6d9Q45C91PubHMbk,16483
 rocket_welder_sdk/high_level/__init__.py,sha256=OKbI3l0PFo1Cb_v0kbv16Wr05urz8heVGps0dJcTcG4,1507
 rocket_welder_sdk/high_level/client.py,sha256=rVnnrn68PEvc68p5acuOBZfEjobWWed8XcssTRzxNr8,11502
-rocket_welder_sdk/high_level/connection_strings.py,sha256=3EpFafyrmX_QNhs2nPscC63EMg5ikscvthu-0C6xC1c,9861
+rocket_welder_sdk/high_level/connection_strings.py,sha256=1Hp72V5qDngHGXyjBRFMckz365BMpGVjb3PMSGvCtow,12531
 rocket_welder_sdk/high_level/data_context.py,sha256=SXJvDpDBFi8Lm4XqSRSHK7YUUHuugXGo4ZRCb6_z5l0,4833
 rocket_welder_sdk/high_level/frame_sink_factory.py,sha256=tLhMV_qnY-ZUtffIzhycM9znNjYguRumba4vphpNx7E,3493
 rocket_welder_sdk/high_level/schema.py,sha256=2Vv0rDwahtGswWB_ceaCdc7JDtmbkx4wE2jQePzeTpU,5367
@@ -39,7 +45,7 @@ rocket_welder_sdk/ui/icons.py,sha256=DcDklZkPmiEzlOD4IR7VTJOtGPCuuh_OM_WN7ScghWE
 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.44.dist-info/METADATA,sha256=XszsJzlnvEQCiPGYl-QxGK6TCTEYmWvi0AzvlHOqYKA,24739
-rocket_welder_sdk-1.1.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rocket_welder_sdk-1.1.44.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
-rocket_welder_sdk-1.1.44.dist-info/RECORD,,
+rocket_welder_sdk-1.1.46.dist-info/METADATA,sha256=SxDcR5ndRmpZSNO9fWlsVAns7NJ6h4aJCxlkl2Bq8ZA,24739
+rocket_welder_sdk-1.1.46.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+rocket_welder_sdk-1.1.46.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
+rocket_welder_sdk-1.1.46.dist-info/RECORD,,

{rocket_welder_sdk-1.1.44.dist-info → rocket_welder_sdk-1.1.46.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any