rocket-welder-sdk 1.1.35.dev12__tar.gz → 1.1.36__tar.gz

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/PKG-INFO

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

@@ -0,0 +1 @@
+1.1.36

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk/high_level/__init__.py

@@ -23,6 +23,7 @@ from .data_context import (
     IKeyPointsDataContext,
     ISegmentationDataContext,
 )
+from .frame_sink_factory import FrameSinkFactory
 from .schema import (
     IKeyPointsSchema,
     ISegmentationSchema,
@@ -35,6 +36,7 @@ from .transport_protocol import (
 )
 
 __all__ = [
+    "FrameSinkFactory",
     "IKeyPointsDataContext",
     "IKeyPointsSchema",
     "ISegmentationDataContext",

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk/high_level/client.py

@@ -32,13 +32,13 @@ from .data_context import (
     KeyPointsDataContext,
     SegmentationDataContext,
 )
+from .frame_sink_factory import FrameSinkFactory
 from .schema import (
     IKeyPointsSchema,
     ISegmentationSchema,
     KeyPointsSchema,
     SegmentationSchema,
 )
-from .transport_protocol import TransportKind
 
 if TYPE_CHECKING:
     from rocket_welder_sdk.keypoints_protocol import KeyPointsSink
@@ -203,35 +203,8 @@ class RocketWelderClient:
         return kp_ctx, seg_ctx
 
     def _create_frame_sink(self, protocol: Any, address: str) -> IFrameSink:
-        """Create frame sink from protocol."""
-        from rocket_welder_sdk.transport import NngFrameSink
-        from rocket_welder_sdk.transport.stream_transport import StreamFrameSink
-        from rocket_welder_sdk.transport.unix_socket_transport import UnixSocketFrameSink
-
-        from .transport_protocol import TransportProtocol
-
-        if not isinstance(protocol, TransportProtocol):
-            raise TypeError(f"Expected TransportProtocol, got {type(protocol)}")
-
-        if protocol.kind == TransportKind.FILE:
-            logger.debug("Creating file sink: %s", address)
-            file_handle = open(address, "wb")
-            try:
-                return StreamFrameSink(file_handle)
-            except Exception:
-                file_handle.close()
-                raise
-        elif protocol.kind == TransportKind.SOCKET:
-            logger.debug("Creating Unix socket sink: %s", address)
-            return UnixSocketFrameSink.connect(address)
-        elif protocol.kind in (TransportKind.NNG_PUSH_IPC, TransportKind.NNG_PUSH_TCP):
-            logger.debug("Creating NNG pusher: %s", address)
-            return NngFrameSink.create_pusher(address)
-        elif protocol.kind in (TransportKind.NNG_PUB_IPC, TransportKind.NNG_PUB_TCP):
-            logger.debug("Creating NNG publisher: %s", address)
-            return NngFrameSink.create_publisher(address)
-        else:
-            raise ValueError(f"Unsupported protocol: {protocol}")
+        """Create frame sink from protocol using FrameSinkFactory."""
+        return FrameSinkFactory.create(protocol, address, logger_instance=logger)
 
     def close(self) -> None:
         """Release resources."""

rocket_welder_sdk-1.1.36/rocket_welder_sdk/high_level/frame_sink_factory.py

@@ -0,0 +1,118 @@
+"""
+Factory for creating IFrameSink instances from parsed protocol and address.
+
+Does NOT parse URLs - use SegmentationConnectionString or KeyPointsConnectionString for parsing.
+
+This mirrors the C# FrameSinkFactory class for API consistency.
+
+Usage:
+    from rocket_welder_sdk.high_level import FrameSinkFactory, SegmentationConnectionString
+
+    cs = SegmentationConnectionString.parse("socket:///tmp/seg.sock")
+    sink = FrameSinkFactory.create(cs.protocol, cs.address)
+
+    # For null sink (no output configured):
+    sink = FrameSinkFactory.create_null()
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from .transport_protocol import TransportProtocol
+
+if TYPE_CHECKING:
+    from rocket_welder_sdk.transport.frame_sink import IFrameSink
+
+logger = logging.getLogger(__name__)
+
+
+class FrameSinkFactory:
+    """
+    Factory for creating IFrameSink instances from parsed protocol and address.
+
+    Does NOT parse URLs - use SegmentationConnectionString or KeyPointsConnectionString for parsing.
+
+    Mirrors C# RocketWelder.SDK.Transport.FrameSinkFactory.
+    """
+
+    @staticmethod
+    def create(
+        protocol: Optional[TransportProtocol],
+        address: str,
+        *,
+        logger_instance: Optional[logging.Logger] = None,
+    ) -> IFrameSink:
+        """
+        Create a frame sink from parsed protocol and address.
+
+        Returns NullFrameSink if protocol is None (no URL specified).
+
+        Args:
+            protocol: The transport protocol (from ConnectionString.protocol), or None
+            address: The address (file path, socket path, or NNG address)
+            logger_instance: Optional logger for diagnostics
+
+        Returns:
+            An IFrameSink connected to the specified address, or NullFrameSink if protocol is None
+
+        Raises:
+            ValueError: If protocol is not supported for sinks
+
+        Example:
+            cs = SegmentationConnectionString.parse("socket:///tmp/seg.sock")
+            sink = FrameSinkFactory.create(cs.protocol, cs.address)
+        """
+        from rocket_welder_sdk.transport import NngFrameSink, NullFrameSink
+        from rocket_welder_sdk.transport.stream_transport import StreamFrameSink
+        from rocket_welder_sdk.transport.unix_socket_transport import UnixSocketFrameSink
+
+        log = logger_instance or logger
+
+        # Handle None protocol - return null sink
+        if protocol is None:
+            log.debug("No protocol specified, using NullFrameSink")
+            return NullFrameSink.instance()
+
+        if not isinstance(protocol, TransportProtocol):
+            raise TypeError(f"Expected TransportProtocol, got {type(protocol).__name__}")
+
+        if protocol.is_file:
+            log.info("Creating file frame sink at: %s", address)
+            file_handle = open(address, "wb")  # noqa: SIM115
+            return StreamFrameSink(file_handle)
+
+        if protocol.is_socket:
+            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)
+
+            if protocol.is_pub:
+                return NngFrameSink.create_publisher(address)
+            if protocol.is_push:
+                return NngFrameSink.create_pusher(address)
+
+            raise ValueError(
+                f"NNG protocol '{protocol.schema}' is not supported for sinks "
+                "(only pub and push are supported)"
+            )
+
+        raise ValueError(f"Transport protocol '{protocol.schema}' is not supported for frame sinks")
+
+    @staticmethod
+    def create_null() -> IFrameSink:
+        """
+        Create a null frame sink that discards all data.
+
+        Use when no output URL is configured.
+        """
+        from rocket_welder_sdk.transport import NullFrameSink
+
+        return NullFrameSink.instance()
+
+
+# Re-export for convenience
+__all__ = ["FrameSinkFactory"]

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk/high_level/schema.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Dict, List, Any
+from typing import Any, Dict, List
 
 
 @dataclass(frozen=True)
@@ -190,8 +190,6 @@ class SegmentationSchema(ISegmentationSchema):
         metadata: Dict[str, Any] = {
             "version": 1,
             "type": "segmentation",
-            "classes": [
-                {"classId": c.class_id, "name": c.name} for c in self._classes.values()
-            ],
+            "classes": [{"classId": c.class_id, "name": c.name} for c in self._classes.values()],
         }
         return json.dumps(metadata, indent=2)

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk/transport/__init__.py

@@ -4,7 +4,7 @@ Transport layer for RocketWelder SDK.
 Provides transport-agnostic frame sink/source abstractions for protocols.
 """
 
-from .frame_sink import IFrameSink
+from .frame_sink import IFrameSink, NullFrameSink
 from .frame_source import IFrameSource
 from .nng_transport import NngFrameSink, NngFrameSource
 from .stream_transport import StreamFrameSink, StreamFrameSource
@@ -20,6 +20,7 @@ __all__ = [
     "IFrameSource",
     "NngFrameSink",
     "NngFrameSource",
+    "NullFrameSink",
     "StreamFrameSink",
     "StreamFrameSource",
     "TcpFrameSink",

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk/transport/frame_sink.py

@@ -75,3 +75,48 @@ class IFrameSink(ABC):
     async def close_async(self) -> None:
         """Close the sink and release resources asynchronously."""
         pass
+
+
+class NullFrameSink(IFrameSink):
+    """
+    A frame sink that discards all data.
+
+    Use when no output URL is configured or for testing.
+    Singleton pattern - use NullFrameSink.instance() to get the shared instance.
+    """
+
+    _instance: "NullFrameSink | None" = None
+
+    def __new__(cls) -> "NullFrameSink":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def instance(cls) -> "NullFrameSink":
+        """Get the singleton instance."""
+        return cls()
+
+    def write_frame(self, frame_data: bytes) -> None:
+        """Discards the frame data (no-op)."""
+        pass
+
+    async def write_frame_async(self, frame_data: bytes) -> None:
+        """Discards the frame data (no-op)."""
+        pass
+
+    def flush(self) -> None:
+        """No-op flush."""
+        pass
+
+    async def flush_async(self) -> None:
+        """No-op flush."""
+        pass
+
+    def close(self) -> None:
+        """No-op close (singleton, never actually closed)."""
+        pass
+
+    async def close_async(self) -> None:
+        """No-op close (singleton, never actually closed)."""
+        pass

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.35.dev12
+Version: 1.1.36
 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.35.dev12 → rocket_welder_sdk-1.1.36}/rocket_welder_sdk.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ rocket_welder_sdk/high_level/__init__.py
 rocket_welder_sdk/high_level/client.py
 rocket_welder_sdk/high_level/connection_strings.py
 rocket_welder_sdk/high_level/data_context.py
+rocket_welder_sdk/high_level/frame_sink_factory.py
 rocket_welder_sdk/high_level/schema.py
 rocket_welder_sdk/high_level/transport_protocol.py
 rocket_welder_sdk/transport/__init__.py

{rocket_welder_sdk-1.1.35.dev12 → rocket_welder_sdk-1.1.36}/tests/test_high_level_api.py

@@ -363,7 +363,10 @@ class TestKeyPointsSchema:
         json_str = schema.get_metadata_json()
         assert "nose" in json_str
         assert "left_eye" in json_str
-        assert '"version": "1.0"' in json_str
+        assert '"version": 1' in json_str
+        assert '"type": "keypoints"' in json_str
+        assert '"id": 0' in json_str
+        assert '"id": 1' in json_str
 
 
 class TestSegmentationSchema:
@@ -423,7 +426,10 @@ class TestSegmentationSchema:
         json_str = schema.get_metadata_json()
         assert "person" in json_str
         assert "car" in json_str
-        assert '"version": "1.0"' in json_str
+        assert '"version": 1' in json_str
+        assert '"type": "segmentation"' in json_str
+        assert '"classId": 1' in json_str
+        assert '"classId": 2' in json_str
 
 
 class TestKeyPointDefinition:

rocket_welder_sdk-1.1.35.dev12/VERSION

@@ -1 +0,0 @@
-1.1.35.dev12