rocket-welder-sdk 1.0.3__tar.gz → 1.0.4__tar.gz

{rocket_welder_sdk-1.0.3 → rocket_welder_sdk-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.0.3
+Version: 1.0.4
 Summary: High-performance video streaming client library for RocketWelder services
 Home-page: https://github.com/modelingevolution/rocket-welder-sdk
 Author: ModelingEvolution
@@ -18,7 +18,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: numpy>=1.20.0
 Requires-Dist: opencv-python>=4.5.0
-Requires-Dist: zerobuffer-ipc>=1.0.0
+Requires-Dist: zerobuffer-ipc>=1.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black>=22.0; extra == "dev"
@@ -35,6 +35,11 @@ Dynamic: summary
 
 # Rocket Welder SDK
 
+[![NuGet](https://img.shields.io/nuget/v/RocketWelder.SDK.svg)](https://www.nuget.org/packages/RocketWelder.SDK/)
+[![PyPI](https://img.shields.io/pypi/v/rocket-welder-sdk.svg)](https://pypi.org/project/rocket-welder-sdk/)
+[![vcpkg](https://img.shields.io/badge/vcpkg-rocket--welder--sdk-blue)](https://github.com/modelingevolution/rocket-welder-sdk-vcpkg-registry)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Multi-language client libraries for interacting with RocketWelder video streaming services.
 
 ## Overview
@@ -100,22 +105,98 @@ CONNECTION_STRING=shm://camera_feed?buffer_size=20MB&metadata_size=4KB
 
 ## Installation
 
-### C++ (vcpkg)
+### C++ with vcpkg
 
+Configure the custom registry in your `vcpkg-configuration.json`:
+```json
+{
+  "registries": [
+    {
+      "kind": "git",
+      "repository": "https://github.com/modelingevolution/rocket-welder-sdk-vcpkg-registry",
+      "baseline": "YOUR_BASELINE_HERE",
+      "packages": ["rocket-welder-sdk"]
+    }
+  ]
+}
+```
+
+Then install:
 ```bash
+# Install via vcpkg
 vcpkg install rocket-welder-sdk
+
+# Or integrate with CMake
+find_package(rocket-welder-sdk CONFIG REQUIRED)
+target_link_libraries(your_app PRIVATE rocket-welder-sdk::rocket-welder-sdk)
 ```
 
-### C# (NuGet)
+### C# with NuGet
+
+[![NuGet Downloads](https://img.shields.io/nuget/dt/RocketWelder.SDK.svg)](https://www.nuget.org/packages/RocketWelder.SDK/)
 
 ```bash
+# Package Manager Console
+Install-Package RocketWelder.SDK
+
+# .NET CLI
 dotnet add package RocketWelder.SDK
+
+# PackageReference in .csproj
+<PackageReference Include="RocketWelder.SDK" Version="1.0.*" />
 ```
 
-### Python (pip)
+### Python with pip
+
+[![PyPI Downloads](https://img.shields.io/pypi/dm/rocket-welder-sdk.svg)](https://pypi.org/project/rocket-welder-sdk/)
 
 ```bash
+# Install from PyPI
 pip install rocket-welder-sdk
+
+# Install with optional dependencies
+pip install rocket-welder-sdk[opencv]  # Includes OpenCV
+pip install rocket-welder-sdk[all]     # All optional dependencies
+
+# Install specific version
+pip install rocket-welder-sdk==1.0.0
+```
+
+## Quick Start
+
+### C++ Quick Start
+```cpp
+#include <rocket_welder/client.hpp>
+
+auto client = rocket_welder::Client::from_connection_string("shm://my-buffer");
+client.on_frame([](cv::Mat& frame) {
+    // Process frame
+});
+client.start();
+```
+
+### C# Quick Start  
+```csharp
+using RocketWelder.SDK;
+
+var client = RocketWelderClient.FromConnectionString("shm://my-buffer");
+client.Start(frame => {
+    // Process frame
+});
+```
+
+### Python Quick Start
+```python
+import rocket_welder_sdk as rw
+
+client = rw.Client.from_connection_string("shm://my-buffer")
+
+@client.on_frame
+def process(frame):
+    # Process frame
+    pass
+
+client.start()
 ```
 
 ## Usage Examples
@@ -178,7 +259,7 @@ class Program
         int frameCount = 0;
         
         // Process frames as OpenCV Mat
-        client.OnFrame((Mat frame) => 
+        client.Start((Mat frame) => 
         {
             // Add overlay text
             Cv2.PutText(frame, "Processing", new Point(10, 30),
@@ -188,8 +269,6 @@ class Program
             Cv2.PutText(frame, $"Frame: {frameCount++}", new Point(10, 60),
                        HersheyFonts.HersheySimplex, 0.5, new Scalar(255, 255, 255), 1);
         });
-        
-        client.Start();
     }
 }
 ```

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/__init__.py

@@ -0,0 +1,20 @@
+"""
+Rocket Welder SDK - Python client for RocketWelder video streaming services
+
+Zero-copy video streaming and processing with shared memory buffers.
+"""
+
+__version__ = "1.0.0"
+
+from .connection_string import ConnectionString, Protocol
+from .gst_caps import GstCaps
+from .client import RocketWelderClient
+from .exceptions import RocketWelderException
+
+__all__ = [
+    "ConnectionString",
+    "Protocol",
+    "GstCaps",
+    "RocketWelderClient",
+    "RocketWelderException",
+]

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/client.py

@@ -0,0 +1,326 @@
+"""
+RocketWelder client implementation with zero-copy frame processing
+
+Mirrors the C# implementation with Python idioms.
+"""
+
+import os
+import sys
+import json
+import logging
+import threading
+import struct
+from typing import Optional, Callable, Dict, Any
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+# Add ZeroBuffer to path
+zerobuffer_path = Path("/mnt/d/source/modelingevolution/streamer/src/zerobuffer/python")
+if zerobuffer_path.exists() and str(zerobuffer_path) not in sys.path:
+    sys.path.insert(0, str(zerobuffer_path))
+
+from zerobuffer import Reader, Writer, BufferConfig
+from zerobuffer.exceptions import WriterDeadException
+
+from .connection_string import ConnectionString, Protocol
+from .gst_caps import GstCaps
+from .gst_metadata import GstMetadata
+from .exceptions import RocketWelderException, ConnectionException
+
+
+class RocketWelderClient:
+    """
+    Client for RocketWelder video streaming services
+    
+    Provides zero-copy access to video frames from shared memory or network streams.
+    """
+    
+    def __init__(self, connection_string: str, logger: Optional[logging.Logger] = None):
+        """
+        Initialize client with connection string
+        
+        Args:
+            connection_string: Connection string in format protocol://host:port/path
+            logger: Optional logger instance
+        """
+        if not connection_string:
+            raise ValueError("Connection string cannot be empty")
+        
+        self._connection = ConnectionString.parse(connection_string)
+        self._logger = logger or logging.getLogger(__name__)
+        self._frame_callback: Optional[Callable[[np.ndarray], None]] = None
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        
+        # ZeroBuffer components
+        self._reader: Optional[Reader] = None
+        self._writer: Optional[Writer] = None
+        
+        # Cached video format from metadata
+        self._video_format: Optional[GstCaps] = None
+        
+    @classmethod
+    def from_args(cls, args: list) -> 'RocketWelderClient':
+        """
+        Create client from command line arguments
+        
+        Args:
+            args: Command line arguments
+        
+        Returns:
+            RocketWelderClient instance
+        """
+        # Check environment variable first
+        connection_string = os.environ.get("CONNECTION_STRING")
+        
+        # Override with command line args if present
+        if args:
+            for arg in args:
+                if (arg.startswith("shm://") or 
+                    arg.startswith("mjpeg+http://") or 
+                    arg.startswith("mjpeg+tcp://")):
+                    connection_string = arg
+                    break
+        
+        return cls(connection_string or "shm://default")
+    
+    @classmethod
+    def from_config(cls, config: Dict[str, Any], logger: Optional[logging.Logger] = None) -> 'RocketWelderClient':
+        """
+        Create client from configuration dictionary
+        
+        Args:
+            config: Configuration dictionary
+            logger: Optional logger instance
+        
+        Returns:
+            RocketWelderClient instance
+        """
+        connection_string = ConnectionString.from_config(config)
+        return cls(str(connection_string), logger)
+    
+    @classmethod
+    def from_environment(cls) -> 'RocketWelderClient':
+        """
+        Create client from CONNECTION_STRING environment variable
+        
+        Returns:
+            RocketWelderClient instance
+        """
+        connection_string = os.environ.get("CONNECTION_STRING", "shm://default")
+        return cls(connection_string)
+    
+    @property
+    def connection(self) -> ConnectionString:
+        """Get connection string configuration"""
+        return self._connection
+    
+    @property
+    def is_running(self) -> bool:
+        """Check if client is running"""
+        return self._running
+    
+    def on_frame(self, callback: Callable[[np.ndarray], None]) -> None:
+        """
+        Set callback for frame processing
+        
+        Args:
+            callback: Function to call with each frame (receives np.ndarray)
+        """
+        if callback is None:
+            raise ValueError("Callback cannot be None")
+        self._frame_callback = callback
+    
+    def start(self) -> None:
+        """Start frame processing"""
+        if self._running:
+            return
+        
+        if self._frame_callback is None:
+            raise RuntimeError("Frame callback must be set before starting")
+        
+        self._running = True
+        self._stop_event.clear()
+        
+        # Start processing thread based on protocol
+        if self._connection.protocol == Protocol.SHM:
+            self._thread = threading.Thread(target=self._process_shared_memory)
+        elif self._connection.protocol == (Protocol.MJPEG | Protocol.HTTP):
+            self._thread = threading.Thread(target=self._process_mjpeg_http)
+        elif self._connection.protocol == (Protocol.MJPEG | Protocol.TCP):
+            self._thread = threading.Thread(target=self._process_mjpeg_tcp)
+        else:
+            raise NotImplementedError(f"Protocol {self._connection.protocol} not supported")
+        
+        self._thread.daemon = True
+        self._thread.start()
+    
+    def stop(self) -> None:
+        """Stop frame processing"""
+        if not self._running:
+            return
+        
+        self._running = False
+        self._stop_event.set()
+        
+        if self._thread:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+        
+        if self._reader:
+            self._reader.close()
+            self._reader = None
+        
+        if self._writer:
+            self._writer.close()
+            self._writer = None
+    
+    def _process_shared_memory(self) -> None:
+        """Process frames from shared memory (zero-copy)"""
+        try:
+            buffer_name = self._connection.buffer_name or "default"
+            buffer_size = self._connection.buffer_size
+            metadata_size = self._connection.metadata_size
+            
+            config = BufferConfig(
+                metadata_size=metadata_size,
+                payload_size=buffer_size
+            )
+            
+            # Create reader - this creates the shared memory buffer
+            self._reader = Reader(buffer_name, config, logger=self._logger)
+            
+            if self._connection.mode == "duplex":
+                self._logger.warning("Duplex mode not fully implemented yet, operating in read-only mode")
+            
+            self._logger.debug(
+                "Created shared memory buffer: %s (size: %d, metadata: %d)",
+                buffer_name, buffer_size, metadata_size
+            )
+            
+            while not self._stop_event.is_set():
+                try:
+                    # Read frame from shared memory (zero-copy)
+                    frame = self._reader.read_frame(timeout=1.0)
+                    
+                    if frame is None or not frame.is_valid:
+                        self._logger.info("No valid frame read, waiting for next frame")
+                        continue
+                    
+                    # Use context manager for proper Frame disposal (RAII)
+                    with frame:
+                        # Parse metadata on first frame or when not yet parsed
+                        if self._video_format is None:
+                            self._parse_metadata()
+                        
+                        if self._video_format is None:
+                            raise RuntimeError("No video format detected")
+                        
+                        # Create numpy array from frame data (zero-copy)
+                        # frame.data is a memoryview that directly points to shared memory
+                        mat = self._video_format.create_mat(frame.data)
+                        
+                        # Call frame callback with zero-copy array
+                        self._frame_callback(mat)
+                    
+                except WriterDeadException:
+                    self._logger.warning("Writer process died")
+                    break
+                except Exception as e:
+                    self._logger.error("Error reading from shared memory: %s", e)
+                    if not self._stop_event.wait(0.1):
+                        continue
+                    
+        except Exception as e:
+            self._logger.error("Error in shared memory processing: %s", e)
+            raise
+    
+    def _parse_metadata(self) -> None:
+        """Parse video format from metadata"""
+        try:
+            metadata_view = self._reader.get_metadata()
+            if metadata_view is None or len(metadata_view) == 0:
+                return
+            
+            # Python's get_metadata() returns raw JSON without any prefixes
+            json_str = bytes(metadata_view).decode('utf-8')
+            
+            # Deserialize to strongly-typed GstMetadata
+            metadata = GstMetadata.from_json(json_str)
+            
+            # Use the already-parsed GstCaps from metadata
+            self._video_format = metadata.caps
+            self._logger.info(
+                "Parsed metadata - Type: %s, Version: %s, Element: %s, Format: %s",
+                metadata.type,
+                metadata.version,
+                metadata.element_name,
+                self._video_format
+            )
+            
+        except Exception as e:
+            self._logger.warning("Failed to parse metadata: %s", e)
+    
+    def _process_mjpeg_http(self) -> None:
+        """Process MJPEG stream over HTTP"""
+        url = f"http://{self._connection.host}:{self._connection.port or 80}"
+        if self._connection.path:
+            url += f"/{self._connection.path}"
+        self._process_mjpeg_stream(url)
+    
+    def _process_mjpeg_tcp(self) -> None:
+        """Process MJPEG stream over TCP"""
+        url = f"tcp://{self._connection.host}:{self._connection.port or 8080}"
+        if self._connection.path:
+            url += f"/{self._connection.path}"
+        self._process_mjpeg_stream(url)
+    
+    def _process_mjpeg_stream(self, url: str) -> None:
+        """Process MJPEG stream using OpenCV VideoCapture"""
+        try:
+            # Use OpenCV VideoCapture which can handle MJPEG streams directly
+            cap = cv2.VideoCapture(url)
+            
+            if not cap.isOpened():
+                raise ConnectionException(f"Failed to open video stream: {url}")
+            
+            self._logger.info("Opened MJPEG stream: %s", url)
+            
+            while not self._stop_event.is_set():
+                try:
+                    # Read frame from stream
+                    ret, frame = cap.read()
+                    
+                    if ret and frame is not None:
+                        # Process the frame
+                        self._frame_callback(frame)
+                    else:
+                        # Small delay if no frame available
+                        if self._stop_event.wait(0.01):
+                            break
+                    
+                except Exception as e:
+                    self._logger.error("Error reading from MJPEG stream: %s", e)
+                    if self._stop_event.wait(0.1):
+                        break
+            
+            cap.release()
+            
+        except Exception as e:
+            self._logger.error("Error in MJPEG processing: %s", e)
+            raise
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.stop()
+    
+    def __del__(self):
+        """Cleanup on deletion"""
+        self.stop()

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/connection_string.py

@@ -0,0 +1,190 @@
+"""
+Connection string parsing for RocketWelder SDK
+
+Mirrors the C# implementation with Python idioms.
+"""
+
+from dataclasses import dataclass
+from enum import Flag, auto
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse, parse_qs
+import os
+
+
+class Protocol(Flag):
+    """Protocol flags that can be combined using bitwise operations"""
+    NONE = 0
+    SHM = auto()
+    MJPEG = auto()
+    HTTP = auto()
+    TCP = auto()
+    
+    def __add__(self, other):
+        """Support + operator as bitwise OR"""
+        return self | other
+
+
+@dataclass(frozen=True)
+class ConnectionString:
+    """
+    Readonly connection string configuration
+    
+    Mirrors C# readonly record struct with IParsable interface.
+    """
+    protocol: Protocol
+    host: Optional[str] = None
+    port: Optional[int] = None
+    path: Optional[str] = None
+    buffer_name: Optional[str] = None
+    buffer_size: int = 10485760  # 10MB default
+    metadata_size: int = 65536  # 64KB default
+    mode: str = "oneway"  # "oneway" or "duplex"
+    
+    @classmethod
+    def parse(cls, s: str, provider=None) -> 'ConnectionString':
+        """
+        Parse connection string (equivalent to IParsable<T>.Parse in C#)
+        
+        Args:
+            s: Connection string in format protocol://host:port/path?params
+            provider: Not used, kept for API compatibility with C#
+        
+        Returns:
+            ConnectionString instance
+        
+        Raises:
+            ValueError: If connection string format is invalid
+        """
+        if not s:
+            raise ValueError("Connection string cannot be empty")
+        
+        # Handle environment variable
+        if s.startswith("$"):
+            env_var = s[1:]
+            s = os.environ.get(env_var, "")
+            if not s:
+                raise ValueError(f"Environment variable {env_var} not set")
+        
+        # Parse URL
+        parsed = urlparse(s)
+        
+        # Determine protocol
+        protocol = Protocol.NONE
+        if parsed.scheme == "shm":
+            protocol = Protocol.SHM
+        elif parsed.scheme == "mjpeg+http":
+            protocol = Protocol.MJPEG | Protocol.HTTP
+        elif parsed.scheme == "mjpeg+tcp":
+            protocol = Protocol.MJPEG | Protocol.TCP
+        elif parsed.scheme == "http":
+            protocol = Protocol.HTTP
+        elif parsed.scheme == "tcp":
+            protocol = Protocol.TCP
+        else:
+            raise ValueError(f"Unknown protocol: {parsed.scheme}")
+        
+        # Parse query parameters
+        params = parse_qs(parsed.query) if parsed.query else {}
+        
+        # Extract components based on protocol
+        host = None
+        port = None
+        path = None
+        buffer_name = None
+        
+        if protocol == Protocol.SHM:
+            # For SHM, the netloc or path becomes the buffer name
+            buffer_name = parsed.netloc or parsed.path.lstrip("/") or "default"
+        else:
+            # For network protocols
+            host = parsed.hostname
+            port = parsed.port
+            path = parsed.path.lstrip("/") if parsed.path else None
+        
+        # Extract additional parameters
+        buffer_size = int(params.get("buffer_size", [10485760])[0])
+        metadata_size = int(params.get("metadata_size", [65536])[0])
+        mode = params.get("mode", ["oneway"])[0]
+        
+        return cls(
+            protocol=protocol,
+            host=host,
+            port=port,
+            path=path,
+            buffer_name=buffer_name,
+            buffer_size=buffer_size,
+            metadata_size=metadata_size,
+            mode=mode
+        )
+    
+    @classmethod
+    def try_parse(cls, s: str, provider=None) -> tuple[bool, Optional['ConnectionString']]:
+        """
+        Try to parse connection string (equivalent to IParsable<T>.TryParse in C#)
+        
+        Args:
+            s: Connection string to parse
+            provider: Not used, kept for API compatibility
+        
+        Returns:
+            Tuple of (success, ConnectionString or None)
+        """
+        try:
+            result = cls.parse(s, provider)
+            return True, result
+        except (ValueError, KeyError):
+            return False, None
+    
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> 'ConnectionString':
+        """
+        Create from configuration dictionary (mirrors IConfiguration in C#)
+        
+        Args:
+            config: Configuration dictionary
+        
+        Returns:
+            ConnectionString instance
+        """
+        # Try to get connection string from various sources
+        connection_string = (
+            config.get("CONNECTION_STRING") or
+            config.get("RocketWelder", {}).get("ConnectionString") or
+            config.get("ConnectionString") or
+            os.environ.get("CONNECTION_STRING")
+        )
+        
+        if connection_string:
+            return cls.parse(connection_string)
+        
+        # Build from components
+        protocol_str = config.get("RocketWelder", {}).get("Protocol", "shm")
+        host = config.get("RocketWelder", {}).get("Host")
+        port = config.get("RocketWelder", {}).get("Port")
+        path = config.get("RocketWelder", {}).get("Path") or config.get("RocketWelder", {}).get("BufferName")
+        
+        if protocol_str == "shm":
+            connection_string = f"shm://{path or 'default'}"
+        elif host:
+            port_part = f":{port}" if port else ""
+            path_part = f"/{path}" if path else ""
+            connection_string = f"{protocol_str}://{host}{port_part}{path_part}"
+        else:
+            connection_string = "shm://default"
+        
+        return cls.parse(connection_string)
+    
+    def __str__(self) -> str:
+        """String representation of connection string"""
+        if self.protocol == Protocol.SHM:
+            return f"shm://{self.buffer_name or 'default'}?buffer_size={self.buffer_size}&metadata_size={self.metadata_size}&mode={self.mode}"
+        elif self.protocol == (Protocol.MJPEG | Protocol.HTTP):
+            port_part = f":{self.port}" if self.port else ""
+            path_part = f"/{self.path}" if self.path else ""
+            return f"mjpeg+http://{self.host}{port_part}{path_part}"
+        elif self.protocol == (Protocol.MJPEG | Protocol.TCP):
+            port_part = f":{self.port}" if self.port else ""
+            path_part = f"/{self.path}" if self.path else ""
+            return f"mjpeg+tcp://{self.host}{port_part}{path_part}"
+        else:
+            return f"{self.protocol.name.lower()}://{self.host}:{self.port}/{self.path}"

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/exceptions.py

@@ -0,0 +1,23 @@
+"""
+Exception classes for RocketWelder SDK
+"""
+
+
+class RocketWelderException(Exception):
+    """Base exception for RocketWelder SDK"""
+    pass
+
+
+class ConnectionException(RocketWelderException):
+    """Exception raised for connection errors"""
+    pass
+
+
+class ProtocolException(RocketWelderException):
+    """Exception raised for protocol-specific errors"""
+    pass
+
+
+class BufferException(RocketWelderException):
+    """Exception raised for buffer-related errors"""
+    pass

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/gst_caps.py

@@ -0,0 +1,224 @@
+"""
+GStreamer caps parsing for video format information
+
+Mirrors the C# implementation with Python idioms.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import re
+import numpy as np
+import cv2
+
+
+@dataclass(frozen=True)
+class GstCaps:
+    """
+    Readonly GStreamer caps configuration
+    
+    Mirrors C# readonly record struct with IParsable interface.
+    """
+    width: int
+    height: int
+    format: str
+    framerate: Optional[Tuple[int, int]] = None
+    
+    @classmethod
+    def parse(cls, s: str, provider=None) -> 'GstCaps':
+        """
+        Parse GStreamer caps string (equivalent to IParsable<T>.Parse in C#)
+        
+        Args:
+            s: Caps string like "video/x-raw,format=RGB,width=640,height=480,framerate=30/1"
+            provider: Not used, kept for API compatibility with C#
+        
+        Returns:
+            GstCaps instance
+        
+        Raises:
+            ValueError: If caps format is invalid
+        """
+        if not s:
+            raise ValueError("Caps string cannot be empty")
+        
+        # Remove video/x-raw prefix if present
+        if s.startswith("video/x-raw"):
+            s = s[len("video/x-raw"):].lstrip(",")
+        
+        # Parse key=value pairs
+        params = {}
+        for part in s.split(","):
+            if "=" in part:
+                key, value = part.split("=", 1)
+                params[key.strip()] = value.strip()
+        
+        # Extract required fields
+        if "width" not in params:
+            raise ValueError("Missing 'width' in caps")
+        if "height" not in params:
+            raise ValueError("Missing 'height' in caps")
+        
+        # Handle GStreamer type annotations like "(int)640"
+        width_str = params["width"]
+        if width_str.startswith("(int)"):
+            width_str = width_str[5:]
+        width = int(width_str)
+        
+        height_str = params["height"]
+        if height_str.startswith("(int)"):
+            height_str = height_str[5:]
+        height = int(height_str)
+        format_str = params.get("format", "RGB")
+        
+        # Parse framerate if present
+        framerate = None
+        if "framerate" in params:
+            framerate_str = params["framerate"]
+            # Handle GStreamer type annotations like "(fraction)30/1"
+            if framerate_str.startswith("(fraction)"):
+                framerate_str = framerate_str[10:]
+            fr_match = re.match(r"(\d+)/(\d+)", framerate_str)
+            if fr_match:
+                framerate = (int(fr_match.group(1)), int(fr_match.group(2)))
+        
+        return cls(
+            width=width,
+            height=height,
+            format=format_str,
+            framerate=framerate
+        )
+    
+    @classmethod
+    def try_parse(cls, s: str, provider=None) -> tuple[bool, Optional['GstCaps']]:
+        """
+        Try to parse caps string (equivalent to IParsable<T>.TryParse in C#)
+        
+        Args:
+            s: Caps string to parse
+            provider: Not used, kept for API compatibility
+        
+        Returns:
+            Tuple of (success, GstCaps or None)
+        """
+        try:
+            result = cls.parse(s, provider)
+            return True, result
+        except (ValueError, KeyError):
+            return False, None
+    
+    @classmethod
+    def from_simple(cls, width: int, height: int, format_str: str = "RGB") -> 'GstCaps':
+        """
+        Create from simple parameters
+        
+        Args:
+            width: Frame width
+            height: Frame height
+            format_str: Pixel format (RGB, BGR, GRAY8, etc.)
+        
+        Returns:
+            GstCaps instance
+        """
+        return cls(width=width, height=height, format=format_str)
+    
+    def get_opencv_dtype(self) -> int:
+        """
+        Get OpenCV data type for the format
+        
+        Returns:
+            OpenCV dtype constant
+        """
+        # Map GStreamer formats to OpenCV types
+        format_map = {
+            "RGB": cv2.CV_8UC3,
+            "BGR": cv2.CV_8UC3,
+            "RGBA": cv2.CV_8UC4,
+            "BGRA": cv2.CV_8UC4,
+            "GRAY8": cv2.CV_8UC1,
+            "GRAY16_LE": cv2.CV_16UC1,
+            "GRAY16_BE": cv2.CV_16UC1,
+        }
+        
+        return format_map.get(self.format, cv2.CV_8UC3)
+    
+    def get_channels(self) -> int:
+        """
+        Get number of channels for the format
+        
+        Returns:
+            Number of channels
+        """
+        if self.format in ["RGB", "BGR"]:
+            return 3
+        elif self.format in ["RGBA", "BGRA"]:
+            return 4
+        elif self.format.startswith("GRAY"):
+            return 1
+        else:
+            return 3  # Default to 3 channels
+    
+    def get_numpy_dtype(self) -> np.dtype:
+        """
+        Get NumPy data type for the format
+        
+        Returns:
+            NumPy dtype
+        """
+        if "16" in self.format:
+            return np.dtype(np.uint16)
+        else:
+            return np.dtype(np.uint8)
+    
+    def create_mat(self, data_ptr: memoryview) -> np.ndarray:
+        """
+        Create OpenCV Mat from data pointer without copying (zero-copy)
+        
+        Args:
+            data_ptr: Memory view of the frame data
+        
+        Returns:
+            NumPy array that wraps the data (no copy)
+        """
+        # Calculate expected size
+        channels = self.get_channels()
+        dtype = self.get_numpy_dtype()
+        expected_size = self.width * self.height * channels * dtype.itemsize
+        
+        # Create numpy array from memoryview (zero-copy)
+        # The memoryview directly points to shared memory
+        flat_array = np.frombuffer(data_ptr, dtype=dtype, count=self.width * self.height * channels)
+        
+        # Reshape to image dimensions
+        if channels == 1:
+            return flat_array.reshape((self.height, self.width))
+        else:
+            return flat_array.reshape((self.height, self.width, channels))
+    
+    def create_mat_from_buffer(self, buffer: bytes) -> np.ndarray:
+        """
+        Create OpenCV Mat from byte buffer (makes a copy)
+        
+        Args:
+            buffer: Byte buffer containing frame data
+        
+        Returns:
+            NumPy array (copy of data)
+        """
+        channels = self.get_channels()
+        dtype = self.get_numpy_dtype()
+        
+        # Create numpy array from bytes
+        flat_array = np.frombuffer(buffer, dtype=dtype)
+        
+        # Reshape to image dimensions
+        if channels == 1:
+            return flat_array.reshape((self.height, self.width))
+        else:
+            return flat_array.reshape((self.height, self.width, channels))
+    
+    def __str__(self) -> str:
+        """String representation as GStreamer caps"""
+        caps = f"video/x-raw,format={self.format},width={self.width},height={self.height}"
+        if self.framerate:
+            caps += f",framerate={self.framerate[0]}/{self.framerate[1]}"
+        return caps

rocket_welder_sdk-1.0.4/rocket_welder_sdk/rocket_welder_sdk/gst_metadata.py

@@ -0,0 +1,43 @@
+"""GStreamer metadata structure matching the JSON written by GStreamer plugins"""
+
+from dataclasses import dataclass
+from typing import Optional
+import json
+
+from .gst_caps import GstCaps
+
+
+@dataclass
+class GstMetadata:
+    """Metadata structure that matches the JSON written by GStreamer plugins"""
+    
+    type: str
+    version: str
+    caps: GstCaps
+    element_name: str
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> 'GstMetadata':
+        """Deserialize from JSON string"""
+        data = json.loads(json_str)
+        
+        # Parse caps string to GstCaps
+        caps = GstCaps.parse(data['caps'])
+        
+        return cls(
+            type=data['type'],
+            version=data['version'],
+            caps=caps,
+            element_name=data['element_name']
+        )
+    
+    def to_json(self) -> str:
+        """Serialize to JSON string"""
+        # Convert GstCaps back to string for JSON
+        data = {
+            'type': self.type,
+            'version': self.version,
+            'caps': self.caps.caps_string if self.caps.caps_string else str(self.caps),
+            'element_name': self.element_name
+        }
+        return json.dumps(data)

{rocket_welder_sdk-1.0.3 → rocket_welder_sdk-1.0.4}/rocket_welder_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.0.3
+Version: 1.0.4
 Summary: High-performance video streaming client library for RocketWelder services
 Home-page: https://github.com/modelingevolution/rocket-welder-sdk
 Author: ModelingEvolution
@@ -18,7 +18,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: numpy>=1.20.0
 Requires-Dist: opencv-python>=4.5.0
-Requires-Dist: zerobuffer-ipc>=1.0.0
+Requires-Dist: zerobuffer-ipc>=1.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black>=22.0; extra == "dev"
@@ -35,6 +35,11 @@ Dynamic: summary
 
 # Rocket Welder SDK
 
+[![NuGet](https://img.shields.io/nuget/v/RocketWelder.SDK.svg)](https://www.nuget.org/packages/RocketWelder.SDK/)
+[![PyPI](https://img.shields.io/pypi/v/rocket-welder-sdk.svg)](https://pypi.org/project/rocket-welder-sdk/)
+[![vcpkg](https://img.shields.io/badge/vcpkg-rocket--welder--sdk-blue)](https://github.com/modelingevolution/rocket-welder-sdk-vcpkg-registry)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Multi-language client libraries for interacting with RocketWelder video streaming services.
 
 ## Overview
@@ -100,22 +105,98 @@ CONNECTION_STRING=shm://camera_feed?buffer_size=20MB&metadata_size=4KB
 
 ## Installation
 
-### C++ (vcpkg)
+### C++ with vcpkg
 
+Configure the custom registry in your `vcpkg-configuration.json`:
+```json
+{
+  "registries": [
+    {
+      "kind": "git",
+      "repository": "https://github.com/modelingevolution/rocket-welder-sdk-vcpkg-registry",
+      "baseline": "YOUR_BASELINE_HERE",
+      "packages": ["rocket-welder-sdk"]
+    }
+  ]
+}
+```
+
+Then install:
 ```bash
+# Install via vcpkg
 vcpkg install rocket-welder-sdk
+
+# Or integrate with CMake
+find_package(rocket-welder-sdk CONFIG REQUIRED)
+target_link_libraries(your_app PRIVATE rocket-welder-sdk::rocket-welder-sdk)
 ```
 
-### C# (NuGet)
+### C# with NuGet
+
+[![NuGet Downloads](https://img.shields.io/nuget/dt/RocketWelder.SDK.svg)](https://www.nuget.org/packages/RocketWelder.SDK/)
 
 ```bash
+# Package Manager Console
+Install-Package RocketWelder.SDK
+
+# .NET CLI
 dotnet add package RocketWelder.SDK
+
+# PackageReference in .csproj
+<PackageReference Include="RocketWelder.SDK" Version="1.0.*" />
 ```
 
-### Python (pip)
+### Python with pip
+
+[![PyPI Downloads](https://img.shields.io/pypi/dm/rocket-welder-sdk.svg)](https://pypi.org/project/rocket-welder-sdk/)
 
 ```bash
+# Install from PyPI
 pip install rocket-welder-sdk
+
+# Install with optional dependencies
+pip install rocket-welder-sdk[opencv]  # Includes OpenCV
+pip install rocket-welder-sdk[all]     # All optional dependencies
+
+# Install specific version
+pip install rocket-welder-sdk==1.0.0
+```
+
+## Quick Start
+
+### C++ Quick Start
+```cpp
+#include <rocket_welder/client.hpp>
+
+auto client = rocket_welder::Client::from_connection_string("shm://my-buffer");
+client.on_frame([](cv::Mat& frame) {
+    // Process frame
+});
+client.start();
+```
+
+### C# Quick Start  
+```csharp
+using RocketWelder.SDK;
+
+var client = RocketWelderClient.FromConnectionString("shm://my-buffer");
+client.Start(frame => {
+    // Process frame
+});
+```
+
+### Python Quick Start
+```python
+import rocket_welder_sdk as rw
+
+client = rw.Client.from_connection_string("shm://my-buffer")
+
+@client.on_frame
+def process(frame):
+    # Process frame
+    pass
+
+client.start()
 ```
 
 ## Usage Examples
@@ -178,7 +259,7 @@ class Program
         int frameCount = 0;
         
         // Process frames as OpenCV Mat
-        client.OnFrame((Mat frame) => 
+        client.Start((Mat frame) => 
         {
             // Add overlay text
             Cv2.PutText(frame, "Processing", new Point(10, 30),
@@ -188,8 +269,6 @@ class Program
             Cv2.PutText(frame, $"Frame: {frameCount++}", new Point(10, 60),
                        HersheyFonts.HersheySimplex, 0.5, new Scalar(255, 255, 255), 1);
         });
-        
-        client.Start();
     }
 }
 ```

rocket_welder_sdk-1.0.4/rocket_welder_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+MANIFEST.in
+logo.png
+setup.py
+../README.md
+rocket_welder_sdk/__init__.py
+rocket_welder_sdk/client.py
+rocket_welder_sdk.egg-info/PKG-INFO
+rocket_welder_sdk.egg-info/SOURCES.txt
+rocket_welder_sdk.egg-info/dependency_links.txt
+rocket_welder_sdk.egg-info/requires.txt
+rocket_welder_sdk.egg-info/top_level.txt
+rocket_welder_sdk/rocket_welder_sdk/__init__.py
+rocket_welder_sdk/rocket_welder_sdk/client.py
+rocket_welder_sdk/rocket_welder_sdk/connection_string.py
+rocket_welder_sdk/rocket_welder_sdk/exceptions.py
+rocket_welder_sdk/rocket_welder_sdk/gst_caps.py
+rocket_welder_sdk/rocket_welder_sdk/gst_metadata.py

{rocket_welder_sdk-1.0.3 → rocket_welder_sdk-1.0.4}/rocket_welder_sdk.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy>=1.20.0
 opencv-python>=4.5.0
-zerobuffer-ipc>=1.0.0
+zerobuffer-ipc>=1.1.0
 
 [dev]
 pytest>=7.0

{rocket_welder_sdk-1.0.3 → rocket_welder_sdk-1.0.4}/setup.py

@@ -11,7 +11,7 @@ else:
 
 setup(
     name="rocket-welder-sdk",
-    version="1.0.3",
+    version="1.0.4",
     author="ModelingEvolution",
     description="High-performance video streaming client library for RocketWelder services",
     long_description=long_description,
@@ -34,7 +34,7 @@ setup(
     install_requires=[
         "numpy>=1.20.0",
         "opencv-python>=4.5.0",
-        "zerobuffer-ipc>=1.0.0",
+        "zerobuffer-ipc>=1.1.0",
     ],
     extras_require={
         "dev": [

rocket_welder_sdk-1.0.3/rocket_welder_sdk.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-MANIFEST.in
-logo.png
-setup.py
-../README.md
-rocket_welder_sdk/__init__.py
-rocket_welder_sdk/client.py
-rocket_welder_sdk.egg-info/PKG-INFO
-rocket_welder_sdk.egg-info/SOURCES.txt
-rocket_welder_sdk.egg-info/dependency_links.txt
-rocket_welder_sdk.egg-info/requires.txt
-rocket_welder_sdk.egg-info/top_level.txt