rocket-welder-sdk 1.1.34__py3-none-any.whl → 1.1.34.dev7__py3-none-any.whl

rocket_welder_sdk/controllers.py

@@ -338,7 +338,7 @@ class OneWayShmController(IController):
         Matches C# CreateMat behavior - creates Mat wrapping the data.
 
         Frame data layout from GStreamer zerosink:
-        [FrameMetadata (16 bytes)][Pixel Data (WxHxC bytes)]
+        [FrameMetadata (16 bytes)][Pixel Data (W×H×C bytes)]
 
         Args:
             frame: ZeroBuffer frame

rocket_welder_sdk/frame_metadata.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import struct
 from dataclasses import dataclass
-from typing import ClassVar, Dict, Optional
+from typing import Optional
 
 # Size of the FrameMetadata structure in bytes
 FRAME_METADATA_SIZE = 16
@@ -113,7 +113,7 @@ class GstVideoFormat:
     GRAY16_BE = 26
     GRAY16_LE = 27
 
-    _FORMAT_NAMES: ClassVar[Dict[int, str]] = {
+    _FORMAT_NAMES: dict[int, str] = {
         0: "UNKNOWN",
         2: "I420",
         3: "YV12",

rocket_welder_sdk/high_level/__init__.py

@@ -1,18 +1,26 @@
 """
 High-level API for RocketWelder SDK.
 
-Mirrors C# RocketWelder.SDK API for consistent developer experience.
+Provides a simplified, user-friendly API for common video processing workflows
+with automatic transport management and schema definitions.
 
 Example:
-    from rocket_welder_sdk.high_level import RocketWelderClient
+    from rocket_welder_sdk.high_level import RocketWelderClient, Transport
 
-    with RocketWelderClient.from_environment() as client:
+    async with RocketWelderClient.from_environment() as client:
+        # Define keypoints schema
         nose = client.keypoints.define_point("nose")
+        left_eye = client.keypoints.define_point("left_eye")
+
+        # Define segmentation classes
         person = client.segmentation.define_class(1, "person")
-        client.start(process_frame)
+
+        async for input_frame, seg_ctx, kp_ctx, output_frame in client.start():
+            # Process frame...
+            kp_ctx.add(nose, x=100, y=200, confidence=0.95)
+            seg_ctx.add(person, instance_id=0, points=contour_points)
 """
 
-from .client import RocketWelderClient, RocketWelderClientOptions
 from .connection_strings import (
     KeyPointsConnectionString,
     SegmentationConnectionString,
@@ -26,11 +34,15 @@ from .data_context import (
 from .schema import (
     IKeyPointsSchema,
     ISegmentationSchema,
-    KeyPointDefinition,
+    KeyPoint,
     SegmentClass,
 )
 from .transport_protocol import (
-    TransportKind,
+    MessagingLibrary,
+    MessagingPattern,
+    Transport,
+    TransportBuilder,
+    TransportLayer,
     TransportProtocol,
 )
 
@@ -39,13 +51,15 @@ __all__ = [
     "IKeyPointsSchema",
     "ISegmentationDataContext",
     "ISegmentationSchema",
-    "KeyPointDefinition",
+    "KeyPoint",
     "KeyPointsConnectionString",
-    "RocketWelderClient",
-    "RocketWelderClientOptions",
+    "MessagingLibrary",
+    "MessagingPattern",
     "SegmentClass",
     "SegmentationConnectionString",
-    "TransportKind",
+    "Transport",
+    "TransportBuilder",
+    "TransportLayer",
     "TransportProtocol",
     "VideoSourceConnectionString",
     "VideoSourceType",

rocket_welder_sdk/high_level/connection_strings.py

@@ -6,8 +6,7 @@ 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
+    file://path/to/output.bin
 """
 
 from __future__ import annotations
@@ -145,19 +144,19 @@ class KeyPointsConnectionString:
     """
     Strongly-typed connection string for KeyPoints output.
 
-    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 protocols (composable with + operator):
+    - Transport.Nng + Transport.Push + Transport.Ipc → nng+push+ipc://tmp/keypoints
+    - Transport.Nng + Transport.Push + Transport.Tcp → nng+push+tcp://host:port
+    - file://path/to/file.bin - File output
 
     Supported parameters:
     - masterFrameInterval: Interval between master frames (default: 300)
     """
 
     value: str
-    protocol: TransportProtocol
-    address: str
+    protocol: Optional[TransportProtocol] = None
+    is_file: bool = False
+    address: str = ""
     master_frame_interval: int = 300
     parameters: Dict[str, str] = field(default_factory=dict)
 
@@ -200,26 +199,25 @@ class KeyPointsConnectionString:
 
         # 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
-        elif protocol.is_nng:
-            # NNG protocols need proper address format
-            address = protocol.create_nng_address(path_part)
+        if scheme_end > 0:
+            protocol_str = endpoint_part[:scheme_end]
+            path_part = endpoint_part[scheme_end + 3 :]  # skip "://"
+
+            if protocol_str.lower() == "file":
+                address = "/" + path_part  # Restore absolute path
+                is_file = True
+                protocol = None
+            else:
+                protocol = TransportProtocol.try_parse(protocol_str)
+                if protocol is None:
+                    return None
+                address = protocol.create_nng_address(path_part)
+                is_file = False
+        elif s.startswith("/"):
+            # Assume absolute file path
+            address = s
+            is_file = True
+            protocol = None
         else:
             return None
 
@@ -232,6 +230,7 @@ class KeyPointsConnectionString:
         return cls(
             value=s,
             protocol=protocol,
+            is_file=is_file,
             address=address,
             master_frame_interval=master_frame_interval,
             parameters=parameters,
@@ -246,16 +245,16 @@ class SegmentationConnectionString:
     """
     Strongly-typed connection string for Segmentation output.
 
-    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
+    Supported protocols (composable with + operator):
+    - Transport.Nng + Transport.Push + Transport.Ipc → nng+push+ipc://tmp/segmentation
+    - Transport.Nng + Transport.Push + Transport.Tcp → nng+push+tcp://host:port
+    - file://path/to/file.bin - File output
     """
 
     value: str
-    protocol: TransportProtocol
-    address: str
+    protocol: Optional[TransportProtocol] = None
+    is_file: bool = False
+    address: str = ""
     parameters: Dict[str, str] = field(default_factory=dict)
 
     @classmethod
@@ -297,32 +296,32 @@ class SegmentationConnectionString:
 
         # 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
-        elif protocol.is_nng:
-            # NNG protocols need proper address format
-            address = protocol.create_nng_address(path_part)
+        if scheme_end > 0:
+            protocol_str = endpoint_part[:scheme_end]
+            path_part = endpoint_part[scheme_end + 3 :]  # skip "://"
+
+            if protocol_str.lower() == "file":
+                address = "/" + path_part  # Restore absolute path
+                is_file = True
+                protocol = None
+            else:
+                protocol = TransportProtocol.try_parse(protocol_str)
+                if protocol is None:
+                    return None
+                address = protocol.create_nng_address(path_part)
+                is_file = False
+        elif s.startswith("/"):
+            # Assume absolute file path
+            address = s
+            is_file = True
+            protocol = None
         else:
             return None
 
         return cls(
             value=s,
             protocol=protocol,
+            is_file=is_file,
             address=address,
             parameters=parameters,
         )

rocket_welder_sdk/high_level/data_context.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from rocket_welder_sdk.keypoints_protocol import IKeyPointsWriter
     from rocket_welder_sdk.segmentation_result import SegmentationResultWriter
 
-    from .schema import KeyPointDefinition, SegmentClass
+    from .schema import KeyPoint, SegmentClass
 
 # Type aliases
 Point = Tuple[int, int]
@@ -37,12 +37,12 @@ class IKeyPointsDataContext(ABC):
         pass
 
     @abstractmethod
-    def add(self, point: KeyPointDefinition, x: int, y: int, confidence: float) -> None:
+    def add(self, point: KeyPoint, x: int, y: int, confidence: float) -> None:
         """
         Add a keypoint detection for this frame.
 
         Args:
-            point: KeyPointDefinition from schema definition
+            point: KeyPoint from schema definition
             x: X coordinate in pixels
             y: Y coordinate in pixels
             confidence: Detection confidence (0.0 to 1.0)
@@ -50,22 +50,17 @@ class IKeyPointsDataContext(ABC):
         pass
 
     @abstractmethod
-    def add_point(self, point: KeyPointDefinition, position: Point, confidence: float) -> None:
+    def add_point(self, point: KeyPoint, position: Point, confidence: float) -> None:
         """
         Add a keypoint detection using a Point tuple.
 
         Args:
-            point: KeyPointDefinition from schema definition
+            point: KeyPoint from schema definition
             position: (x, y) tuple
             confidence: Detection confidence (0.0 to 1.0)
         """
         pass
 
-    @abstractmethod
-    def commit(self) -> None:
-        """Commit the context (called automatically when delegate returns)."""
-        pass
-
 
 class ISegmentationDataContext(ABC):
     """
@@ -97,11 +92,6 @@ class ISegmentationDataContext(ABC):
         """
         pass
 
-    @abstractmethod
-    def commit(self) -> None:
-        """Commit the context (called automatically when delegate returns)."""
-        pass
-
 
 class KeyPointsDataContext(IKeyPointsDataContext):
     """Implementation of keypoints data context."""
@@ -111,6 +101,8 @@ class KeyPointsDataContext(IKeyPointsDataContext):
         frame_id: int,
         writer: IKeyPointsWriter,
     ) -> None:
+        from .schema import KeyPoint  # noqa: F401
+
         self._frame_id = frame_id
         self._writer = writer
 
@@ -118,11 +110,11 @@ class KeyPointsDataContext(IKeyPointsDataContext):
     def frame_id(self) -> int:
         return self._frame_id
 
-    def add(self, point: KeyPointDefinition, x: int, y: int, confidence: float) -> None:
+    def add(self, point: KeyPoint, x: int, y: int, confidence: float) -> None:
         """Add a keypoint detection for this frame."""
         self._writer.append(point.id, x, y, confidence)
 
-    def add_point(self, point: KeyPointDefinition, position: Point, confidence: float) -> None:
+    def add_point(self, point: KeyPoint, position: Point, confidence: float) -> None:
         """Add a keypoint detection using a Point tuple."""
         self._writer.append_point(point.id, position, confidence)
 
@@ -139,6 +131,8 @@ class SegmentationDataContext(ISegmentationDataContext):
         frame_id: int,
         writer: SegmentationResultWriter,
     ) -> None:
+        from .schema import SegmentClass  # noqa: F401
+
         self._frame_id = frame_id
         self._writer = writer
 

rocket_welder_sdk/high_level/schema.py

@@ -10,11 +10,11 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Dict, List, Any
+from typing import Dict, List
 
 
 @dataclass(frozen=True)
-class KeyPointDefinition:
+class KeyPoint:
     """
     A keypoint definition with ID and name.
 
@@ -26,7 +26,7 @@ class KeyPointDefinition:
     name: str
 
     def __str__(self) -> str:
-        return f"KeyPointDefinition({self.id}, '{self.name}')"
+        return f"KeyPoint({self.id}, '{self.name}')"
 
 
 @dataclass(frozen=True)
@@ -54,7 +54,7 @@ class IKeyPointsSchema(ABC):
     """
 
     @abstractmethod
-    def define_point(self, name: str) -> KeyPointDefinition:
+    def define_point(self, name: str) -> KeyPoint:
         """
         Define a new keypoint.
 
@@ -62,13 +62,13 @@ class IKeyPointsSchema(ABC):
             name: Human-readable name for the keypoint (e.g., "nose", "left_eye")
 
         Returns:
-            KeyPointDefinition handle for use with IKeyPointsDataContext.add()
+            KeyPoint handle for use with IKeyPointsDataContext.add()
         """
         pass
 
     @property
     @abstractmethod
-    def defined_points(self) -> List[KeyPointDefinition]:
+    def defined_points(self) -> List[KeyPoint]:
         """Get all defined keypoints."""
         pass
 
@@ -116,41 +116,34 @@ class KeyPointsSchema(IKeyPointsSchema):
     """Implementation of keypoints schema."""
 
     def __init__(self) -> None:
-        self._points: Dict[str, KeyPointDefinition] = {}
+        self._points: Dict[str, KeyPoint] = {}
         self._next_id = 0
 
-    def define_point(self, name: str) -> KeyPointDefinition:
+    def define_point(self, name: str) -> KeyPoint:
         """Define a new keypoint."""
         if name in self._points:
             raise ValueError(f"Keypoint '{name}' already defined")
 
-        point = KeyPointDefinition(id=self._next_id, name=name)
+        point = KeyPoint(id=self._next_id, name=name)
         self._points[name] = point
         self._next_id += 1
         return point
 
     @property
-    def defined_points(self) -> List[KeyPointDefinition]:
+    def defined_points(self) -> List[KeyPoint]:
         """Get all defined keypoints."""
         return list(self._points.values())
 
     def get_metadata_json(self) -> str:
-        """
-        Get JSON metadata for serialization.
-
-        Format matches C# SDK:
-        {
-            "version": 1,
-            "type": "keypoints",
-            "points": [{"id": 0, "name": "nose"}, ...]
-        }
-        """
-        metadata: Dict[str, Any] = {
-            "version": 1,
-            "type": "keypoints",
-            "points": [{"id": p.id, "name": p.name} for p in self._points.values()],
-        }
-        return json.dumps(metadata, indent=2)
+        """Get JSON metadata for serialization."""
+        return json.dumps(
+            {
+                "version": "1.0",
+                "compute_module_name": "",
+                "points": {p.name: p.id for p in self._points.values()},
+            },
+            indent=2,
+        )
 
 
 class SegmentationSchema(ISegmentationSchema):
@@ -177,21 +170,11 @@ class SegmentationSchema(ISegmentationSchema):
         return list(self._classes.values())
 
     def get_metadata_json(self) -> str:
-        """
-        Get JSON metadata for serialization.
-
-        Format matches C# SDK:
-        {
-            "version": 1,
-            "type": "segmentation",
-            "classes": [{"classId": 1, "name": "person"}, ...]
-        }
-        """
-        metadata: Dict[str, Any] = {
-            "version": 1,
-            "type": "segmentation",
-            "classes": [
-                {"classId": c.class_id, "name": c.name} for c in self._classes.values()
-            ],
-        }
-        return json.dumps(metadata, indent=2)
+        """Get JSON metadata for serialization."""
+        return json.dumps(
+            {
+                "version": "1.0",
+                "classes": {str(c.class_id): c.name for c in self._classes.values()},
+            },
+            indent=2,
+        )

rocket_welder_sdk/high_level/transport_protocol.py

@@ -1,204 +1,103 @@
 """
-Unified transport protocol as a value type.
+Transport protocol types with composable + operator.
 
-Supports: file://, socket://, nng+push+ipc://, nng+push+tcp://, etc.
-
-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
+Allows building transport protocols like:
+    protocol = Transport.Nng + Transport.Push + Transport.Ipc
+    # Results in TransportProtocol("nng", "push", "ipc")
 """
 
 from __future__ import annotations
 
-from enum import Enum, auto
-from typing import ClassVar, Dict, Optional
-
-
-class TransportKind(Enum):
-    """Transport kind enumeration."""
-
-    FILE = auto()
-    """File output."""
-
-    SOCKET = auto()
-    """Unix domain socket (direct, no messaging library)."""
+from dataclasses import dataclass
+from typing import Optional
 
-    NNG_PUSH_IPC = auto()
-    """NNG Push over IPC."""
 
-    NNG_PUSH_TCP = auto()
-    """NNG Push over TCP."""
+@dataclass(frozen=True)
+class MessagingLibrary:
+    """Messaging library (nng, zeromq, etc.)."""
 
-    NNG_PULL_IPC = auto()
-    """NNG Pull over IPC."""
+    name: str
 
-    NNG_PULL_TCP = auto()
-    """NNG Pull over TCP."""
+    def __add__(self, pattern: MessagingPattern) -> TransportBuilder:
+        """Compose with messaging pattern: Nng + Push."""
+        return TransportBuilder(library=self, pattern=pattern)
 
-    NNG_PUB_IPC = auto()
-    """NNG Pub over IPC."""
+    def __str__(self) -> str:
+        return self.name
 
-    NNG_PUB_TCP = auto()
-    """NNG Pub over TCP."""
 
-    NNG_SUB_IPC = auto()
-    """NNG Sub over IPC."""
+@dataclass(frozen=True)
+class MessagingPattern:
+    """Messaging pattern (push/pull, pub/sub, etc.)."""
 
-    NNG_SUB_TCP = auto()
-    """NNG Sub over TCP."""
+    name: str
 
+    def __str__(self) -> str:
+        return self.name
 
-class TransportProtocol:
-    """
-    Unified transport protocol specification as a value type.
-
-    Supports: file://, socket://, nng+push+ipc://, nng+push+tcp://, etc.
-    """
-
-    # 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]] = {}
-
-    def __init__(self, kind: TransportKind, schema: str) -> None:
-        self._kind = kind
-        self._schema = schema
 
-    @property
-    def kind(self) -> TransportKind:
-        """The transport kind."""
-        return self._kind
+@dataclass(frozen=True)
+class TransportLayer:
+    """Transport layer (ipc, tcp, etc.)."""
 
-    @property
-    def schema(self) -> str:
-        """The schema string (e.g., 'file', 'socket', 'nng+push+ipc')."""
-        return self._schema
+    name: str
+    uri_prefix: str
 
-    # Classification properties
+    def __str__(self) -> str:
+        return self.name
 
-    @property
-    def is_file(self) -> bool:
-        """True if this is a file transport."""
-        return self._kind == TransportKind.FILE
 
-    @property
-    def is_socket(self) -> bool:
-        """True if this is a Unix socket transport."""
-        return self._kind == TransportKind.SOCKET
+@dataclass(frozen=True)
+class TransportBuilder:
+    """Builder for constructing transport protocols."""
 
-    @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,
-        }
+    library: MessagingLibrary
+    pattern: MessagingPattern
 
-    @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}
+    def __add__(self, layer: TransportLayer) -> TransportProtocol:
+        """Compose with transport layer: (Nng + Push) + Ipc."""
+        return TransportProtocol(library=self.library, pattern=self.pattern, layer=layer)
 
-    @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}
+    def __str__(self) -> str:
+        return f"{self.library}+{self.pattern}"
 
-    @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}
+@dataclass(frozen=True)
+class TransportProtocol:
+    """Complete transport protocol specification."""
 
-    @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,
-        }
+    library: MessagingLibrary
+    pattern: MessagingPattern
+    layer: TransportLayer
 
     @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 protocol_string(self) -> str:
+        """Protocol string for parsing (e.g., 'nng+push+ipc')."""
+        return f"{self.library}+{self.pattern}+{self.layer}"
 
     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.
+        For IPC: adds leading "/" to make absolute path
+        For TCP: uses as-is
         """
-        if not self.is_nng:
-            raise ValueError(f"Cannot create NNG address for {self._kind} transport")
+        if self.layer == Transport.Ipc and not path_or_host.startswith("/"):
+            return f"{self.layer.uri_prefix}/{path_or_host}"
+        return f"{self.layer.uri_prefix}{path_or_host}"
 
-        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}"
+    @property
+    def is_push(self) -> bool:
+        """Check if this is a push pattern."""
+        return self.pattern == Transport.Push
 
-        # TCP
-        return f"tcp://{path_or_host}"
+    @property
+    def is_pub(self) -> bool:
+        """Check if this is a pub pattern."""
+        return self.pattern == Transport.Pub
 
     def __str__(self) -> str:
-        return self._schema
-
-    def __repr__(self) -> str:
-        return f"TransportProtocol({self._kind.name}, '{self._schema}')"
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, TransportProtocol):
-            return self._kind == other._kind
-        return False
-
-    def __hash__(self) -> int:
-        return hash(self._kind)
+        return self.protocol_string
 
     @classmethod
     def parse(cls, s: str) -> TransportProtocol:
@@ -209,30 +108,59 @@ class TransportProtocol:
         return result
 
     @classmethod
-    def try_parse(cls, s: Optional[str]) -> Optional[TransportProtocol]:
+    def try_parse(cls, s: str) -> Optional[TransportProtocol]:
         """Try to parse a protocol string."""
         if not s:
             return None
 
-        schema = s.lower().strip()
-        kind = cls._SCHEMA_MAP.get(schema)
-        if kind is None:
+        parts = s.lower().split("+")
+        if len(parts) != 3:
+            return None
+
+        # Parse library
+        if parts[0] == "nng":
+            library = Transport.Nng
+        else:
+            return None
+
+        # Parse pattern
+        if parts[1] == "push":
+            pattern = Transport.Push
+        elif parts[1] == "pull":
+            pattern = Transport.Pull
+        elif parts[1] == "pub":
+            pattern = Transport.Pub
+        elif parts[1] == "sub":
+            pattern = Transport.Sub
+        else:
             return None
 
-        return cls(kind, schema)
+        # Parse layer
+        if parts[2] == "ipc":
+            layer = Transport.Ipc
+        elif parts[2] == "tcp":
+            layer = Transport.Tcp
+        else:
+            return None
+
+        return cls(library=library, pattern=pattern, layer=layer)
+
+
+class Transport:
+    """Static helpers for building transport protocols using + operator."""
+
+    # Messaging libraries
+    Nng: MessagingLibrary = MessagingLibrary("nng")
 
+    # Messaging patterns
+    Push: MessagingPattern = MessagingPattern("push")
+    Pull: MessagingPattern = MessagingPattern("pull")
+    Pub: MessagingPattern = MessagingPattern("pub")
+    Sub: MessagingPattern = MessagingPattern("sub")
 
-# 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")
+    # Transport layers
+    Ipc: TransportLayer = TransportLayer("ipc", "ipc://")
+    Tcp: TransportLayer = TransportLayer("tcp", "tcp://")
 
-# Initialize reverse lookup map
-TransportProtocol._KIND_TO_SCHEMA = {v: k for k, v in TransportProtocol._SCHEMA_MAP.items()}
+    # File output (not a real transport)
+    File: str = "file"

{rocket_welder_sdk-1.1.34.dist-info → rocket_welder_sdk-1.1.34.dev7.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
 rocket_welder_sdk/__init__.py,sha256=pcYOCqqYuK8oJwkFRnWej4uNfEkuYWXP6jcUhPSLgrc,3041
 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/frame_metadata.py,sha256=TMLIY47cIdIlxqk9xj7I3M8FZFmZ3GcVoLZht7prjQM,3929
+rocket_welder_sdk/controllers.py,sha256=WY3fgUUrlicA_ibDhvsfsF0ucD7RuoHuL-BWojAhjtQ,32692
+rocket_welder_sdk/frame_metadata.py,sha256=8AbCgSQ17QeCHSzdQiSN0E1KxE5rrNpOlTYZ2em8kes,3903
 rocket_welder_sdk/gst_metadata.py,sha256=jEQvZX4BdR6OR3lqp12PV-HEXZhcxfiS010diA2CbMM,14213
 rocket_welder_sdk/keypoints_protocol.py,sha256=NKiSPrevWG4_RrD6jtFxPjwftlaPWe1CqoFVKRMwp4k,21858
 rocket_welder_sdk/opencv_controller.py,sha256=MDM6_yFBB9BaMa5jnZRqw7xZZB-WuLr7EPrrfHQ2DK4,9905
@@ -14,12 +14,11 @@ rocket_welder_sdk/session_id.py,sha256=sRhzQw90shqq_DJVtrsSggcGZ775kz7cRfbI-1LMe
 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/high_level/__init__.py,sha256=C1Gan74Ce_JQZKJmXhpP3L3O11wvOClesBVaAxRZQaA,1305
-rocket_welder_sdk/high_level/client.py,sha256=kVtxpzP9qZgv-SYG_0glDckHapEod4MFl5NQ75TR_b4,9584
-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/schema.py,sha256=7F5DfPACHUfOpbJE4YZJRpro9VL8tLa6Kt9ZJuY7R7w,5397
-rocket_welder_sdk/high_level/transport_protocol.py,sha256=EFF0bgNn9hxRMj67FwU6MVu-UiEFINSGhd2VC8agrgc,7393
+rocket_welder_sdk/high_level/__init__.py,sha256=5oTCBL2qMGonCytHDckmX1b1U97-7Xb8Bg9Z70nR7fc,1759
+rocket_welder_sdk/high_level/connection_strings.py,sha256=4undnkbWZ837vY-o6ybIj1827F2VlUbCJX4m3Filz-s,10469
+rocket_welder_sdk/high_level/data_context.py,sha256=Pmwsl9MgBfKA9BqmBJmAVRvnaqPdjnq2rZEA_pzzYsw,4585
+rocket_welder_sdk/high_level/schema.py,sha256=UlefNAV2UL9eO_Th2q19a7tf_eoaeLE92fYZ5LNq7-M,4849
+rocket_welder_sdk/high_level/transport_protocol.py,sha256=lvLVHikW_MNZhXqaXlyXscT68OklyMbGs8DnDEMCtgE,4515
 rocket_welder_sdk/transport/__init__.py,sha256=DYmZpohGPU7RhS6EdVT_BwCy5MZzyTQ6Eymm8TpmxJ8,751
 rocket_welder_sdk/transport/frame_sink.py,sha256=16dUefZF1QJv62Ig0ezPR6nEho_7A3WJu4M9_PPMqJM,2164
 rocket_welder_sdk/transport/frame_source.py,sha256=G1rBAQS1AgOOdtASB0_CYon8g20hUGXpP2exCp5hlhk,2169
@@ -33,7 +32,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.34.dist-info/METADATA,sha256=zI8JTjId1nm1yfU6y-10l4vKl2vOiJqj6uL4GZUfkVc,24847
-rocket_welder_sdk-1.1.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rocket_welder_sdk-1.1.34.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
-rocket_welder_sdk-1.1.34.dist-info/RECORD,,
+rocket_welder_sdk-1.1.34.dev7.dist-info/METADATA,sha256=qUlyc_-dz2TRBVvqqV6N38UvFF9Gb6r-Vw1PsqppeYw,24852
+rocket_welder_sdk-1.1.34.dev7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rocket_welder_sdk-1.1.34.dev7.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
+rocket_welder_sdk-1.1.34.dev7.dist-info/RECORD,,

rocket_welder_sdk/high_level/client.py

@@ -1,262 +0,0 @@
-"""
-RocketWelderClient - High-level API matching C# RocketWelder.SDK.
-
-Usage:
-    with RocketWelderClient.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)
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-import numpy as np
-import numpy.typing as npt
-from typing_extensions import TypeAlias
-
-from .connection_strings import (
-    KeyPointsConnectionString,
-    SegmentationConnectionString,
-    VideoSourceConnectionString,
-)
-from .data_context import (
-    IKeyPointsDataContext,
-    ISegmentationDataContext,
-    KeyPointsDataContext,
-    SegmentationDataContext,
-)
-from .schema import (
-    IKeyPointsSchema,
-    ISegmentationSchema,
-    KeyPointsSchema,
-    SegmentationSchema,
-)
-from .transport_protocol import TransportKind
-
-if TYPE_CHECKING:
-    from rocket_welder_sdk.keypoints_protocol import KeyPointsSink
-    from rocket_welder_sdk.transport.frame_sink import IFrameSink
-
-# Type alias for OpenCV Mat (numpy array)
-Mat: TypeAlias = npt.NDArray[np.uint8]
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class RocketWelderClientOptions:
-    """Configuration options for RocketWelderClient."""
-
-    video_source: VideoSourceConnectionString = field(
-        default_factory=VideoSourceConnectionString.default
-    )
-    keypoints: KeyPointsConnectionString = field(default_factory=KeyPointsConnectionString.default)
-    segmentation: SegmentationConnectionString = field(
-        default_factory=SegmentationConnectionString.default
-    )
-
-    @classmethod
-    def from_environment(cls) -> RocketWelderClientOptions:
-        """Create from environment variables."""
-        return cls(
-            video_source=VideoSourceConnectionString.from_environment(),
-            keypoints=KeyPointsConnectionString.from_environment(),
-            segmentation=SegmentationConnectionString.from_environment(),
-        )
-
-
-class RocketWelderClient:
-    """
-    High-level client for RocketWelder SDK.
-
-    Mirrors C# RocketWelder.SDK.IRocketWelderClient interface.
-    """
-
-    def __init__(self, options: RocketWelderClientOptions) -> None:
-        self._options = options
-        self._keypoints_schema = KeyPointsSchema()
-        self._segmentation_schema = SegmentationSchema()
-        self._keypoints_sink: Optional[KeyPointsSink] = None
-        self._keypoints_frame_sink: Optional[IFrameSink] = None
-        self._segmentation_frame_sink: Optional[IFrameSink] = None
-        self._closed = False
-        logger.debug("RocketWelderClient created with options: %s", options)
-
-    @classmethod
-    def from_environment(cls) -> RocketWelderClient:
-        """Create client from environment variables."""
-        logger.info("Creating RocketWelderClient from environment variables")
-        return cls(RocketWelderClientOptions.from_environment())
-
-    @classmethod
-    def create(cls, options: Optional[RocketWelderClientOptions] = None) -> RocketWelderClient:
-        """Create client with explicit options."""
-        return cls(options or RocketWelderClientOptions())
-
-    @property
-    def keypoints(self) -> IKeyPointsSchema:
-        """Schema for defining keypoints."""
-        return self._keypoints_schema
-
-    @property
-    def segmentation(self) -> ISegmentationSchema:
-        """Schema for defining segmentation classes."""
-        return self._segmentation_schema
-
-    def start(
-        self,
-        process_frame: Callable[[Mat, ISegmentationDataContext, IKeyPointsDataContext, Mat], None],
-    ) -> None:
-        """Start with both keypoints and segmentation."""
-        self._run_loop(process_frame, use_keypoints=True, use_segmentation=True)
-
-    def start_keypoints(
-        self,
-        process_frame: Callable[[Mat, IKeyPointsDataContext, Mat], None],
-    ) -> None:
-        """Start with keypoints only."""
-        self._run_loop(process_frame, use_keypoints=True, use_segmentation=False)
-
-    def start_segmentation(
-        self,
-        process_frame: Callable[[Mat, ISegmentationDataContext, Mat], None],
-    ) -> None:
-        """Start with segmentation only."""
-        self._run_loop(process_frame, use_keypoints=False, use_segmentation=True)
-
-    def _run_loop(
-        self,
-        process_frame: Callable[..., None],
-        use_keypoints: bool,
-        use_segmentation: bool,
-    ) -> None:
-        """Run processing loop."""
-        from rocket_welder_sdk.keypoints_protocol import KeyPointsSink
-
-        logger.info(
-            "Starting processing loop (keypoints=%s, segmentation=%s)",
-            use_keypoints,
-            use_segmentation,
-        )
-
-        # Initialize sinks
-        if use_keypoints:
-            cs = self._options.keypoints
-            logger.info("Initializing keypoints sink: %s -> %s", cs.protocol, cs.address)
-            self._keypoints_frame_sink = self._create_frame_sink(cs.protocol, cs.address)
-            self._keypoints_sink = KeyPointsSink(
-                frame_sink=self._keypoints_frame_sink,
-                master_frame_interval=cs.master_frame_interval,
-                owns_sink=False,  # We manage frame sink lifecycle in close()
-            )
-            logger.debug(
-                "KeyPointsSink created with master_frame_interval=%d", cs.master_frame_interval
-            )
-
-        if use_segmentation:
-            seg_cs = self._options.segmentation
-            logger.info("Initializing segmentation sink: %s -> %s", seg_cs.protocol, seg_cs.address)
-            self._segmentation_frame_sink = self._create_frame_sink(seg_cs.protocol, seg_cs.address)
-            logger.debug("Segmentation frame sink created")
-
-        # TODO: Video capture loop - for now raise NotImplementedError
-        raise NotImplementedError(
-            "Video capture not implemented. Use process_frame_sync() or low-level API."
-        )
-
-    def process_frame_sync(
-        self,
-        frame_id: int,
-        input_frame: Mat,
-        output_frame: Mat,
-        width: int,
-        height: int,
-    ) -> tuple[Optional[IKeyPointsDataContext], Optional[ISegmentationDataContext]]:
-        """
-        Process a single frame synchronously.
-
-        Returns (keypoints_context, segmentation_context) for the caller to use.
-        Caller must call commit() on contexts when done.
-        """
-        from rocket_welder_sdk.segmentation_result import SegmentationResultWriter
-
-        kp_ctx: Optional[IKeyPointsDataContext] = None
-        seg_ctx: Optional[ISegmentationDataContext] = None
-
-        if self._keypoints_sink is not None:
-            kp_writer = self._keypoints_sink.create_writer(frame_id)
-            kp_ctx = KeyPointsDataContext(frame_id, kp_writer)
-
-        if self._segmentation_frame_sink is not None:
-            seg_writer = SegmentationResultWriter(
-                frame_id, width, height, frame_sink=self._segmentation_frame_sink
-            )
-            seg_ctx = SegmentationDataContext(frame_id, seg_writer)
-
-        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}")
-
-    def close(self) -> None:
-        """Release resources."""
-        if self._closed:
-            return
-
-        logger.info("Closing RocketWelderClient")
-
-        # Close frame sinks (KeyPointsSink has owns_sink=False, so we manage lifecycle)
-        self._keypoints_sink = None
-        if self._keypoints_frame_sink is not None:
-            logger.debug("Closing keypoints frame sink")
-            self._keypoints_frame_sink.close()
-            self._keypoints_frame_sink = None
-
-        if self._segmentation_frame_sink is not None:
-            logger.debug("Closing segmentation frame sink")
-            self._segmentation_frame_sink.close()
-            self._segmentation_frame_sink = None
-
-        self._closed = True
-        logger.info("RocketWelderClient closed")
-
-    def __enter__(self) -> RocketWelderClient:
-        return self
-
-    def __exit__(self, *args: object) -> None:
-        self.close()