rocket-welder-sdk 1.1.34.dev11__py3-none-any.whl → 1.1.34rc1__py3-none-any.whl

rocket_welder_sdk/__init__.py

@@ -16,22 +16,11 @@ from .opencv_controller import OpenCvController
 from .periodic_timer import PeriodicTimer, PeriodicTimerSync
 from .rocket_welder_client import RocketWelderClient
 from .session_id import (
-    # Explicit URL functions (PREFERRED - set by rocket-welder2)
-    ACTIONS_SINK_URL_ENV,
-    KEYPOINTS_SINK_URL_ENV,
-    SEGMENTATION_SINK_URL_ENV,
-    # SessionId-derived URL functions (fallback for backwards compatibility)
     get_actions_url,
-    get_actions_url_from_env,
-    get_configured_nng_urls,
     get_keypoints_url,
-    get_keypoints_url_from_env,
     get_nng_urls,
-    get_nng_urls_from_env,
     get_segmentation_url,
-    get_segmentation_url_from_env,
     get_session_id_from_env,
-    has_explicit_nng_urls,
     parse_session_id,
 )
 
@@ -60,10 +49,7 @@ if _log_level:
         pass  # Invalid log level, ignore
 
 __all__ = [
-    "ACTIONS_SINK_URL_ENV",
     "FRAME_METADATA_SIZE",
-    "KEYPOINTS_SINK_URL_ENV",
-    "SEGMENTATION_SINK_URL_ENV",
     "BytesSize",
     "Client",
     "ConnectionMode",
@@ -80,16 +66,11 @@ __all__ = [
     "PeriodicTimerSync",
     "Protocol",
     "RocketWelderClient",
+    # SessionId utilities for NNG URL generation
     "get_actions_url",
-    "get_actions_url_from_env",
-    "get_configured_nng_urls",
     "get_keypoints_url",
-    "get_keypoints_url_from_env",
     "get_nng_urls",
-    "get_nng_urls_from_env",
     "get_segmentation_url",
-    "get_segmentation_url_from_env",
     "get_session_id_from_env",
-    "has_explicit_nng_urls",
     "parse_session_id",
 ]

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
@@ -438,9 +438,7 @@ class OneWayShmController(IController):
                 sqrt_pixels = math.sqrt(pixels)
                 if sqrt_pixels == int(sqrt_pixels):
                     dimension = int(sqrt_pixels)
-                    logger.info(
-                        f"Pixel data size {pixel_data_size} suggests {dimension}x{dimension} RGB"
-                    )
+                    logger.info(f"Pixel data size {pixel_data_size} suggests {dimension}x{dimension} RGB")
                     pixel_data = np.frombuffer(frame.data[FRAME_METADATA_SIZE:], dtype=np.uint8)
                     return pixel_data.reshape((dimension, dimension, 3))  # type: ignore[no-any-return]
 
@@ -450,9 +448,7 @@ class OneWayShmController(IController):
                 sqrt_pixels = math.sqrt(pixels)
                 if sqrt_pixels == int(sqrt_pixels):
                     dimension = int(sqrt_pixels)
-                    logger.info(
-                        f"Pixel data size {pixel_data_size} suggests {dimension}x{dimension} RGBA"
-                    )
+                    logger.info(f"Pixel data size {pixel_data_size} suggests {dimension}x{dimension} RGBA")
                     pixel_data = np.frombuffer(frame.data[FRAME_METADATA_SIZE:], dtype=np.uint8)
                     return pixel_data.reshape((dimension, dimension, 4))  # type: ignore[no-any-return]
 

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,
+        )