rocket-welder-sdk 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

rocket_welder_sdk/rocket_welder_sdk/client.py

@@ -1,326 +0,0 @@
-"""
-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/rocket_welder_sdk/connection_string.py

@@ -1,190 +0,0 @@
-"""
-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/rocket_welder_sdk/exceptions.py

@@ -1,23 +0,0 @@
-"""
-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