rocket-welder-sdk 1.1.43__py3-none-any.whl → 1.1.45__py3-none-any.whl

rocket_welder_sdk/high_level/client.py

@@ -2,18 +2,24 @@
 RocketWelderClient - High-level API matching C# RocketWelder.SDK.
 
 Usage:
-    with RocketWelderClient.from_environment() as client:
+    with RocketWelderClientFactory.from_environment() as client:
         # Define schema
         nose = client.keypoints.define_point("nose")
         person = client.segmentation.define_class(1, "person")
 
         # Start processing
         client.start(process_frame)
+
+Alternatively:
+    # Using class methods directly
+    with RocketWelderClient.from_environment() as client:
+        ...
 """
 
 from __future__ import annotations
 
 import logging
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
@@ -50,6 +56,73 @@ Mat: TypeAlias = npt.NDArray[np.uint8]
 logger = logging.getLogger(__name__)
 
 
+class IRocketWelderClient(ABC):
+    """
+    Main entry point for RocketWelder SDK high-level API.
+
+    Provides schema definitions and frame processing loop.
+    Matches C# IRocketWelderClient interface.
+    """
+
+    @property
+    @abstractmethod
+    def keypoints(self) -> IKeyPointsSchema:
+        """Schema for defining keypoints."""
+        pass
+
+    @property
+    @abstractmethod
+    def segmentation(self) -> ISegmentationSchema:
+        """Schema for defining segmentation classes."""
+        pass
+
+    @abstractmethod
+    def start(
+        self,
+        process_frame: Callable[[Mat, ISegmentationDataContext, IKeyPointsDataContext, Mat], None],
+    ) -> None:
+        """
+        Start the processing loop with full context (keypoints + segmentation).
+
+        Args:
+            process_frame: Callback for each frame with:
+                - input_frame: Source video frame (Mat)
+                - segmentation: Segmentation data context
+                - keypoints: KeyPoints data context
+                - output_frame: Output frame for visualization (Mat)
+        """
+        pass
+
+    @abstractmethod
+    def start_keypoints(
+        self,
+        process_frame: Callable[[Mat, IKeyPointsDataContext, Mat], None],
+    ) -> None:
+        """Start the processing loop (keypoints only)."""
+        pass
+
+    @abstractmethod
+    def start_segmentation(
+        self,
+        process_frame: Callable[[Mat, ISegmentationDataContext, Mat], None],
+    ) -> None:
+        """Start the processing loop (segmentation only)."""
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release resources."""
+        pass
+
+    def __enter__(self) -> IRocketWelderClient:
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        """Context manager exit."""
+        self.close()
+
+
 @dataclass
 class RocketWelderClientOptions:
     """Configuration options for RocketWelderClient."""
@@ -72,11 +145,12 @@ class RocketWelderClientOptions:
         )
 
 
-class RocketWelderClient:
+class RocketWelderClient(IRocketWelderClient):
     """
     High-level client for RocketWelder SDK.
 
-    Mirrors C# RocketWelder.SDK.IRocketWelderClient interface.
+    Implements IRocketWelderClient interface.
+    Mirrors C# RocketWelder.SDK.RocketWelderClientImpl.
     """
 
     def __init__(self, options: RocketWelderClientOptions) -> None:
@@ -233,3 +307,40 @@ class RocketWelderClient:
 
     def __exit__(self, *args: object) -> None:
         self.close()
+
+
+class RocketWelderClientFactory:
+    """
+    Factory for creating RocketWelderClient instances.
+
+    Matches C# RocketWelderClientFactory static class.
+    """
+
+    @staticmethod
+    def from_environment() -> IRocketWelderClient:
+        """
+        Creates a client configured from environment variables.
+
+        Environment variables:
+        - VIDEO_SOURCE or CONNECTION_STRING: Video input
+        - KEYPOINTS_CONNECTION_STRING: KeyPoints output
+        - SEGMENTATION_CONNECTION_STRING: Segmentation output
+
+        Returns:
+            IRocketWelderClient configured from environment.
+        """
+        options = RocketWelderClientOptions.from_environment()
+        return RocketWelderClient(options)
+
+    @staticmethod
+    def create(options: Optional[RocketWelderClientOptions] = None) -> IRocketWelderClient:
+        """
+        Creates a client with explicit configuration.
+
+        Args:
+            options: Configuration options. If None, uses defaults.
+
+        Returns:
+            IRocketWelderClient with the specified configuration.
+        """
+        return RocketWelderClient(options or RocketWelderClientOptions())

rocket_welder_sdk/high_level/connection_strings.py

@@ -4,10 +4,8 @@ Strongly-typed connection strings with parsing support.
 Connection string format: protocol://path?param1=value1&param2=value2
 
 Examples:
-    nng+push+ipc://tmp/keypoints?masterFrameInterval=300
-    nng+pub+tcp://localhost:5555
     file:///path/to/output.bin
-    socket:///tmp/my.sock
+    socket:///tmp/my.sock?masterFrameInterval=300
 """
 
 from __future__ import annotations
@@ -148,8 +146,6 @@ class KeyPointsConnectionString:
     Supported protocols:
     - file:///path/to/file.bin - File output (absolute path)
     - socket:///tmp/socket.sock - Unix domain socket
-    - nng+push+ipc://tmp/keypoints - NNG Push over IPC
-    - nng+push+tcp://host:port - NNG Push over TCP
 
     Supported parameters:
     - masterFrameInterval: Interval between master frames (default: 300)
@@ -164,7 +160,7 @@ class KeyPointsConnectionString:
     @classmethod
     def default(cls) -> KeyPointsConnectionString:
         """Default connection string for KeyPoints."""
-        return cls.parse("nng+push+ipc://tmp/rocket-welder-keypoints?masterFrameInterval=300")
+        return cls.parse("socket:///tmp/rocket-welder-keypoints.sock?masterFrameInterval=300")
 
     @classmethod
     def from_environment(
@@ -217,9 +213,6 @@ class KeyPointsConnectionString:
         elif protocol.is_socket:
             # socket:///tmp/sock -> /tmp/sock
             address = path_part if path_part.startswith("/") else "/" + path_part
-        elif protocol.is_nng:
-            # NNG protocols need proper address format
-            address = protocol.create_nng_address(path_part)
         else:
             return None
 
@@ -249,8 +242,6 @@ class SegmentationConnectionString:
     Supported protocols:
     - file:///path/to/file.bin - File output (absolute path)
     - socket:///tmp/socket.sock - Unix domain socket
-    - nng+push+ipc://tmp/segmentation - NNG Push over IPC
-    - nng+push+tcp://host:port - NNG Push over TCP
     """
 
     value: str
@@ -261,7 +252,7 @@ class SegmentationConnectionString:
     @classmethod
     def default(cls) -> SegmentationConnectionString:
         """Default connection string for Segmentation."""
-        return cls.parse("nng+push+ipc://tmp/rocket-welder-segmentation")
+        return cls.parse("socket:///tmp/rocket-welder-segmentation.sock")
 
     @classmethod
     def from_environment(
@@ -314,9 +305,91 @@ class SegmentationConnectionString:
         elif protocol.is_socket:
             # socket:///tmp/sock -> /tmp/sock
             address = path_part if path_part.startswith("/") else "/" + path_part
-        elif protocol.is_nng:
-            # NNG protocols need proper address format
-            address = protocol.create_nng_address(path_part)
+        else:
+            return None
+
+        return cls(
+            value=s,
+            protocol=protocol,
+            address=address,
+            parameters=parameters,
+        )
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass(frozen=True)
+class GraphicsConnectionString:
+    """
+    Strongly-typed connection string for Stage (graphics) output.
+
+    Supported protocols:
+    - file:///path/to/file.bin - File output (absolute path)
+    - socket:///tmp/socket.sock - Unix domain socket
+    """
+
+    value: str
+    protocol: TransportProtocol
+    address: str
+    parameters: Dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def default(cls) -> GraphicsConnectionString:
+        """Default connection string for Stage."""
+        return cls.parse("socket:///tmp/rocket-welder-stage.sock")
+
+    @classmethod
+    def from_environment(
+        cls, variable_name: str = "STAGE_CONNECTION_STRING"
+    ) -> GraphicsConnectionString:
+        """Create from environment variable or use default."""
+        value = os.environ.get(variable_name)
+        return cls.parse(value) if value else cls.default()
+
+    @classmethod
+    def parse(cls, s: str) -> GraphicsConnectionString:
+        """Parse a connection string."""
+        result = cls.try_parse(s)
+        if result is None:
+            raise ValueError(f"Invalid Graphics connection string: {s}")
+        return result
+
+    @classmethod
+    def try_parse(cls, s: str) -> Optional[GraphicsConnectionString]:
+        """Try to parse a connection string."""
+        if not s or not s.strip():
+            return None
+
+        s = s.strip()
+        parameters: Dict[str, str] = {}
+
+        # Extract query parameters
+        endpoint_part = s
+        if "?" in s:
+            endpoint_part, query = s.split("?", 1)
+            for key, values in parse_qs(query).items():
+                parameters[key.lower()] = values[0] if values else ""
+
+        # Parse protocol and address
+        scheme_end = endpoint_part.find("://")
+        if scheme_end <= 0:
+            return None
+
+        schema_str = endpoint_part[:scheme_end]
+        path_part = endpoint_part[scheme_end + 3 :]  # skip "://"
+
+        protocol = TransportProtocol.try_parse(schema_str)
+        if protocol is None:
+            return None
+
+        # Build address based on protocol type
+        if protocol.is_file:
+            # file:///absolute/path -> /absolute/path
+            address = path_part if path_part.startswith("/") else "/" + path_part
+        elif protocol.is_socket:
+            # socket:///tmp/sock -> /tmp/sock
+            address = path_part if path_part.startswith("/") else "/" + path_part
         else:
             return None
 

rocket_welder_sdk/high_level/frame_sink_factory.py

@@ -51,7 +51,7 @@ class FrameSinkFactory:
 
         Args:
             protocol: The transport protocol (from ConnectionString.protocol), or None
-            address: The address (file path, socket path, or NNG address)
+            address: The address (file path or socket path)
             logger_instance: Optional logger for diagnostics
 
         Returns:
@@ -64,7 +64,7 @@ class FrameSinkFactory:
             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 import NullFrameSink
         from rocket_welder_sdk.transport.stream_transport import StreamFrameSink
         from rocket_welder_sdk.transport.unix_socket_transport import UnixSocketFrameSink
 
@@ -87,19 +87,6 @@ class FrameSinkFactory:
             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)
-
-            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

rocket_welder_sdk/high_level/transport_protocol.py

@@ -1,13 +1,11 @@
 """
 Unified transport protocol as a value type.
 
-Supports: file://, socket://, nng+push+ipc://, nng+push+tcp://, etc.
+Supports: file://, socket://
 
 Examples:
     file:///home/user/output.bin   - absolute file path
     socket:///tmp/my.sock          - Unix domain socket
-    nng+push+ipc://tmp/keypoints   - NNG Push over IPC
-    nng+push+tcp://host:5555       - NNG Push over TCP
 """
 
 from __future__ import annotations
@@ -25,61 +23,21 @@ class TransportKind(Enum):
     SOCKET = auto()
     """Unix domain socket (direct, no messaging library)."""
 
-    NNG_PUSH_IPC = auto()
-    """NNG Push over IPC."""
-
-    NNG_PUSH_TCP = auto()
-    """NNG Push over TCP."""
-
-    NNG_PULL_IPC = auto()
-    """NNG Pull over IPC."""
-
-    NNG_PULL_TCP = auto()
-    """NNG Pull over TCP."""
-
-    NNG_PUB_IPC = auto()
-    """NNG Pub over IPC."""
-
-    NNG_PUB_TCP = auto()
-    """NNG Pub over TCP."""
-
-    NNG_SUB_IPC = auto()
-    """NNG Sub over IPC."""
-
-    NNG_SUB_TCP = auto()
-    """NNG Sub over TCP."""
-
 
 class TransportProtocol:
     """
     Unified transport protocol specification as a value type.
 
-    Supports: file://, socket://, nng+push+ipc://, nng+push+tcp://, etc.
+    Supports: file://, socket://
     """
 
     # Predefined protocols
     File: TransportProtocol
     Socket: TransportProtocol
-    NngPushIpc: TransportProtocol
-    NngPushTcp: TransportProtocol
-    NngPullIpc: TransportProtocol
-    NngPullTcp: TransportProtocol
-    NngPubIpc: TransportProtocol
-    NngPubTcp: TransportProtocol
-    NngSubIpc: TransportProtocol
-    NngSubTcp: TransportProtocol
 
     _SCHEMA_MAP: ClassVar[Dict[str, TransportKind]] = {
         "file": TransportKind.FILE,
         "socket": TransportKind.SOCKET,
-        "nng+push+ipc": TransportKind.NNG_PUSH_IPC,
-        "nng+push+tcp": TransportKind.NNG_PUSH_TCP,
-        "nng+pull+ipc": TransportKind.NNG_PULL_IPC,
-        "nng+pull+tcp": TransportKind.NNG_PULL_TCP,
-        "nng+pub+ipc": TransportKind.NNG_PUB_IPC,
-        "nng+pub+tcp": TransportKind.NNG_PUB_TCP,
-        "nng+sub+ipc": TransportKind.NNG_SUB_IPC,
-        "nng+sub+tcp": TransportKind.NNG_SUB_TCP,
     }
 
     _KIND_TO_SCHEMA: ClassVar[Dict[TransportKind, str]] = {}
@@ -95,7 +53,7 @@ class TransportProtocol:
 
     @property
     def schema(self) -> str:
-        """The schema string (e.g., 'file', 'socket', 'nng+push+ipc')."""
+        """The schema string (e.g., 'file', 'socket')."""
         return self._schema
 
     # Classification properties
@@ -110,82 +68,6 @@ class TransportProtocol:
         """True if this is a Unix socket transport."""
         return self._kind == TransportKind.SOCKET
 
-    @property
-    def is_nng(self) -> bool:
-        """True if this is any NNG-based transport."""
-        return self._kind in {
-            TransportKind.NNG_PUSH_IPC,
-            TransportKind.NNG_PUSH_TCP,
-            TransportKind.NNG_PULL_IPC,
-            TransportKind.NNG_PULL_TCP,
-            TransportKind.NNG_PUB_IPC,
-            TransportKind.NNG_PUB_TCP,
-            TransportKind.NNG_SUB_IPC,
-            TransportKind.NNG_SUB_TCP,
-        }
-
-    @property
-    def is_push(self) -> bool:
-        """True if this is a Push pattern."""
-        return self._kind in {TransportKind.NNG_PUSH_IPC, TransportKind.NNG_PUSH_TCP}
-
-    @property
-    def is_pull(self) -> bool:
-        """True if this is a Pull pattern."""
-        return self._kind in {TransportKind.NNG_PULL_IPC, TransportKind.NNG_PULL_TCP}
-
-    @property
-    def is_pub(self) -> bool:
-        """True if this is a Pub pattern."""
-        return self._kind in {TransportKind.NNG_PUB_IPC, TransportKind.NNG_PUB_TCP}
-
-    @property
-    def is_sub(self) -> bool:
-        """True if this is a Sub pattern."""
-        return self._kind in {TransportKind.NNG_SUB_IPC, TransportKind.NNG_SUB_TCP}
-
-    @property
-    def is_ipc(self) -> bool:
-        """True if this uses IPC layer."""
-        return self._kind in {
-            TransportKind.NNG_PUSH_IPC,
-            TransportKind.NNG_PULL_IPC,
-            TransportKind.NNG_PUB_IPC,
-            TransportKind.NNG_SUB_IPC,
-        }
-
-    @property
-    def is_tcp(self) -> bool:
-        """True if this uses TCP layer."""
-        return self._kind in {
-            TransportKind.NNG_PUSH_TCP,
-            TransportKind.NNG_PULL_TCP,
-            TransportKind.NNG_PUB_TCP,
-            TransportKind.NNG_SUB_TCP,
-        }
-
-    def create_nng_address(self, path_or_host: str) -> str:
-        """
-        Create the NNG address from a path/host.
-
-        For IPC: ipc:///path
-        For TCP: tcp://host:port
-
-        Raises:
-            ValueError: If this is not an NNG protocol.
-        """
-        if not self.is_nng:
-            raise ValueError(f"Cannot create NNG address for {self._kind} transport")
-
-        if self.is_ipc:
-            # IPC paths need leading "/" for absolute paths
-            if not path_or_host.startswith("/"):
-                return f"ipc:///{path_or_host}"
-            return f"ipc://{path_or_host}"
-
-        # TCP
-        return f"tcp://{path_or_host}"
-
     def __str__(self) -> str:
         return self._schema
 
@@ -202,7 +84,7 @@ class TransportProtocol:
 
     @classmethod
     def parse(cls, s: str) -> TransportProtocol:
-        """Parse a protocol string (e.g., 'nng+push+ipc')."""
+        """Parse a protocol string (e.g., 'file', 'socket')."""
         result = cls.try_parse(s)
         if result is None:
             raise ValueError(f"Invalid transport protocol: {s}")
@@ -225,14 +107,6 @@ class TransportProtocol:
 # Initialize predefined protocols
 TransportProtocol.File = TransportProtocol(TransportKind.FILE, "file")
 TransportProtocol.Socket = TransportProtocol(TransportKind.SOCKET, "socket")
-TransportProtocol.NngPushIpc = TransportProtocol(TransportKind.NNG_PUSH_IPC, "nng+push+ipc")
-TransportProtocol.NngPushTcp = TransportProtocol(TransportKind.NNG_PUSH_TCP, "nng+push+tcp")
-TransportProtocol.NngPullIpc = TransportProtocol(TransportKind.NNG_PULL_IPC, "nng+pull+ipc")
-TransportProtocol.NngPullTcp = TransportProtocol(TransportKind.NNG_PULL_TCP, "nng+pull+tcp")
-TransportProtocol.NngPubIpc = TransportProtocol(TransportKind.NNG_PUB_IPC, "nng+pub+ipc")
-TransportProtocol.NngPubTcp = TransportProtocol(TransportKind.NNG_PUB_TCP, "nng+pub+tcp")
-TransportProtocol.NngSubIpc = TransportProtocol(TransportKind.NNG_SUB_IPC, "nng+sub+ipc")
-TransportProtocol.NngSubTcp = TransportProtocol(TransportKind.NNG_SUB_TCP, "nng+sub+tcp")
 
 # Initialize reverse lookup map
 TransportProtocol._KIND_TO_SCHEMA = {v: k for k, v in TransportProtocol._SCHEMA_MAP.items()}