matrice-inference 0.1.0__py3-none-manylinux_2_17_x86_64.whl

matrice_inference/deploy/client/streaming_gateway/streaming_gateway.pyi

@@ -0,0 +1,120 @@
+"""Auto-generated stub for module: streaming_gateway."""
+from typing import Any, Dict, List, Optional
+
+from matrice_inference.deploy.client.client import MatriceDeployClient
+from matrice_inference.deploy.client.client_stream_utils import ClientStreamUtils
+from matrice_inference.deploy.client.streaming_gateway.streaming_gateway_utils import InputConfig, OutputConfig, InputType, ModelInputType, _RealTimeJsonEventPicker
+from matrice_inference.deploy.client.streaming_gateway.streaming_results_handler import StreamingResultsHandler
+import json
+import logging
+import threading
+import time
+
+# Classes
+class StreamingGateway:
+    """
+    Simplified streaming gateway that leverages MatriceDeployClient's capabilities.
+    
+        Supports both frame-based streaming (sending individual images) and video-based
+        streaming (sending video chunks) based on the model_input_type configuration.
+    
+        Now includes optional post-processing capabilities for model results.
+    
+        Prevents multiple deployments or background streams from being started simultaneously
+        using simple class-level tracking.
+    
+        Example usage:
+            # Traditional usage with manual input config
+            frame_input = create_camera_frame_input(camera_index=0, fps=30)
+            video_input = create_camera_video_input(
+                camera_index=0,
+                fps=30,
+                video_duration=5.0,  # 5-second chunks
+                video_format="mp4"
+            )
+    
+            gateway = StreamingGateway(
+                session=session,
+                service_id="your_service_id",
+                inputs_config=[video_input],
+                output_config=output_config
+            )
+    
+            gateway.start_streaming()
+    
+            # To stop all streams from any instance:
+            StreamingGateway.stop_all_active_streams()
+    """
+
+    def __init__(self: Any, session: Any, service_id: str = None, inputs_config: List[InputConfig] = None, output_config: Any = None, json_event_picker: Any = _RealTimeJsonEventPicker(), create_deployment_config: Dict = None, auth_key: str = None, consumer_group_id: str = None, result_callback: Optional[Callable] = None, strip_input_from_result: bool = True, force_restart: bool = False) -> None: ...
+        """
+        Initialize StreamingGateway.
+        
+                Args:
+                    session: Session object for authentication
+                    service_id: ID of existing deployment (optional if create_deployment_config provided)
+                    inputs_config: Multiple input configurations (alternative to input_config)
+                    output_config: Output configuration
+                    create_deployment_config: Configuration for creating new deployment
+                    auth_key: Authentication key for deployment
+                    consumer_group_id: Kafka consumer group ID
+                    result_callback: Optional callback function for processing results
+                    strip_input_from_result: Whether to remove 'input' field from results to save space
+                    force_restart: Whether to force stop existing streams and restart (use with caution)
+        """
+
+    def get_config(self: Any) -> Dict: ...
+        """
+        Get current configuration.
+        
+                Returns:
+                    Dict with current configuration
+        """
+
+    def get_statistics(self: Any) -> Dict: ...
+        """
+        Get streaming statistics.
+        
+                Returns:
+                    Dict with streaming statistics
+        """
+
+    def load_config(cls: Any, filepath: str, session: Any = None, auth_key: str = None) -> Any: ...
+        """
+        Load configuration from file and create StreamingGateway.
+        
+                Args:
+                    filepath: Path to configuration file
+                    session: Session object (required)
+                    auth_key: Authentication key
+        
+                Returns:
+                    StreamingGateway instance
+        """
+
+    def save_config(self: Any, filepath: str) -> Any: ...
+        """
+        Save current configuration to file.
+        
+                Args:
+                    filepath: Path to save configuration
+        """
+
+    def start_streaming(self: Any, send_to_api: bool = False) -> bool: ...
+        """
+        Start streaming using MatriceDeployClient's built-in capabilities.
+        
+                Returns:
+                    bool: True if streaming started successfully, False otherwise
+        """
+
+    def stop_all_active_streams(self: Any) -> Any: ...
+        """
+        Stop all active streams across all deployments.
+        """
+
+    def stop_streaming(self: Any) -> None: ...
+        """
+        Stop all streaming operations.
+        """
+

matrice_inference/deploy/client/streaming_gateway/streaming_gateway_utils.pyi

@@ -0,0 +1,442 @@
+"""Auto-generated stub for module: streaming_gateway_utils."""
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from collections import deque
+from dataclasses import dataclass, asdict
+from enum import Enum
+from matrice_inference.deploy.utils.post_processing.core.config import BaseConfig, AlertConfig, TrackingConfig, ZoneConfig
+from urllib.parse import urlparse
+import json
+import os
+import os
+import re
+import requests
+import time
+import urllib3
+import uuid
+import warnings
+
+# Functions
+def create_camera_frame_input(camera_index: int = 0, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None) -> Any: ...
+    """
+    Create a camera input for frame-based streaming.
+    
+        Args:
+            camera_index: Camera device index
+            fps: Frames per second
+            quality: Image quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+    
+        Returns:
+            InputConfig: Camera input configured for frame streaming
+    """
+def create_camera_input(camera_index: int = 0, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, model_input_type: Any = ModelInputType.FRAMES, video_duration: float = None, max_frames: int = None, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a camera input configuration.
+    
+        Args:
+            camera_index: Camera device index (0 for default camera)
+            fps: Frames per second to capture
+            quality: Video/image quality (1-100)
+            stream_key: Unique identifier for the stream
+            width: Frame width in pixels
+            height: Frame height in pixels
+            model_input_type: FRAMES for individual images, VIDEO for video chunks
+            video_duration: Duration of video chunks in seconds (only for VIDEO mode)
+            max_frames: Maximum frames per video chunk (only for VIDEO mode)
+            video_format: Video format for encoding (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Configured input for camera
+    
+        Raises:
+            ValueError: If parameters are invalid
+    """
+def create_camera_video_input(camera_index: int = 0, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, video_duration: float = 5.0, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a camera input for video-based streaming with duration limit.
+    
+        Args:
+            camera_index: Camera device index
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            video_duration: Duration of video chunks in seconds
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Camera input configured for video streaming
+    """
+def create_camera_video_input_by_frames(camera_index: int = 0, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, max_frames: int = 150, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a camera input for video-based streaming with frame count limit.
+    
+        Args:
+            camera_index: Camera device index
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            max_frames: Maximum frames per video chunk
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Camera input configured for video streaming
+    """
+def create_detection_post_processing_config(confidence_threshold: float = 0.6, enable_counting: bool = True, enable_alerting: bool = True, map_index_to_category: bool = False, index_to_category: Dict[int, str] = None, category_triggers: List[str] = None, count_threshold: int = None) -> Any: ...
+    """
+    Create a post-processing configuration optimized for object detection.
+    
+        Args:
+            confidence_threshold: Global confidence threshold for filtering detections
+            enable_counting: Whether to enable object counting features
+            enable_alerting: Whether to enable alerting features
+            map_index_to_category: Whether to map category indices to names
+            index_to_category: Mapping from category indices to category names
+            category_triggers: List of categories that should trigger alerts
+            count_threshold: Threshold for triggering count-based alerts
+    
+        Returns:
+            PostProcessingConfig optimized for detection models
+    """
+def create_dual_output(file_directory: str, kafka_topic: str, kafka_bootstrap_servers: str, filename_pattern: str = None, max_files: int = None, kafka_key_field: str = 'stream_key', producer_config: Dict = None, post_processing_config: Any = None, apply_post_processing: bool = False, save_original_results: bool = True) -> Any: ...
+    """
+    Create a dual output configuration (both file and Kafka).
+    
+        Args:
+            file_directory: Directory for file output
+            kafka_topic: Kafka topic name
+            kafka_bootstrap_servers: Kafka bootstrap servers
+            filename_pattern: Pattern for output filenames
+            max_files: Maximum number of files to keep
+            kafka_key_field: Field to use as Kafka message key
+            producer_config: Additional Kafka producer configuration
+    
+        Returns:
+            OutputConfig instance for dual output
+    """
+def create_file_output(directory: str, filename_pattern: str = None, max_files: int = None, post_processing_config: Any = None, apply_post_processing: bool = False, save_original_results: bool = True) -> Any: ...
+    """
+    Create a file output configuration.
+    
+        Args:
+            directory: Output directory path
+            filename_pattern: Pattern for output filenames
+            max_files: Maximum number of files to keep
+            post_processing_config: Post-processing configuration (optional)
+            apply_post_processing: Whether to apply post-processing (default: False)
+            save_original_results: Whether to save original results alongside processed ones (default: True)
+    
+        Returns:
+            OutputConfig instance for file output
+    """
+def create_http_video_frame_input(video_url: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None) -> Any: ...
+    """
+    Create an HTTP video file input for frame-based streaming.
+    
+        Args:
+            video_url: HTTP/HTTPS video file URL
+            fps: Frames per second
+            quality: Image quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+    
+        Returns:
+            InputConfig: HTTP video input configured for frame streaming
+    """
+def create_http_video_input(video_url: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, model_input_type: Any = ModelInputType.FRAMES, video_duration: float = None, max_frames: int = None, video_format: str = 'mp4') -> Any: ...
+    """
+    Create an HTTP video file input configuration.
+    
+        Args:
+            video_url: HTTP/HTTPS video file URL
+            fps: Frames per second to process
+            quality: Video/image quality (1-100)
+            stream_key: Unique identifier for the stream
+            width: Frame width in pixels
+            height: Frame height in pixels
+            model_input_type: FRAMES for individual images, VIDEO for video chunks
+            video_duration: Duration of video chunks in seconds (only for VIDEO mode)
+            max_frames: Maximum frames per video chunk (only for VIDEO mode)
+            video_format: Video format for encoding (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Configured input for HTTP video file
+    
+        Raises:
+            ValueError: If parameters are invalid
+    """
+def create_http_video_video_input(video_url: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, video_duration: float = 5.0, video_format: str = 'mp4') -> Any: ...
+    """
+    Create an HTTP video file input for video-based streaming with duration limit.
+    
+        Args:
+            video_url: HTTP/HTTPS video file URL
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            video_duration: Duration of video chunks in seconds
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: HTTP video input configured for video streaming
+    """
+def create_http_video_video_input_by_frames(video_url: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, max_frames: int = 150, video_format: str = 'mp4') -> Any: ...
+    """
+    Create an HTTP video file input for video-based streaming with frame count limit.
+    
+        Args:
+            video_url: HTTP/HTTPS video file URL
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            max_frames: Maximum frames per video chunk
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: HTTP video input configured for video streaming
+    """
+def create_kafka_output(topic: str, bootstrap_servers: str, key_field: str = 'stream_key', producer_config: Dict = None) -> Any: ...
+    """
+    Create a Kafka output configuration.
+    
+        Args:
+            topic: Kafka topic name
+            bootstrap_servers: Kafka bootstrap servers
+            key_field: Field to use as message key
+            producer_config: Additional Kafka producer configuration
+    
+        Returns:
+            OutputConfig instance for Kafka output
+    """
+def create_rtsp_input(rtsp_url: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, model_input_type: Any = ModelInputType.FRAMES, video_duration: float = None, max_frames: int = None, video_format: str = 'mp4') -> Any: ...
+    """
+    Create an RTSP stream input configuration.
+    
+        Args:
+            rtsp_url: RTSP stream URL
+            fps: Frames per second to capture
+            quality: Video/image quality (1-100)
+            stream_key: Unique identifier for the stream
+            width: Frame width in pixels
+            height: Frame height in pixels
+            model_input_type: FRAMES for individual images, VIDEO for video chunks
+            video_duration: Duration of video chunks in seconds (only for VIDEO mode)
+            max_frames: Maximum frames per video chunk (only for VIDEO mode)
+            video_format: Video format for encoding (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Configured input for RTSP stream
+    
+        Raises:
+            ValueError: If parameters are invalid
+    """
+def create_security_post_processing_config(person_confidence_threshold: float = 0.8, vehicle_confidence_threshold: float = 0.7, restricted_zones: Dict[str, List[Tuple[int, int]]] = None, entrance_lines: Dict[str, List[Tuple[int, int]]] = None, alert_on_person: bool = True, max_person_count: int = 5) -> Any: ...
+    """
+    Create a post-processing configuration optimized for security monitoring.
+    
+        Args:
+            person_confidence_threshold: Confidence threshold for person detection
+            vehicle_confidence_threshold: Confidence threshold for vehicle detection
+            restricted_zones: Dictionary of restricted zone names to polygon coordinates
+            entrance_lines: Dictionary of entrance line names to line coordinates
+            alert_on_person: Whether to alert whenever a person is detected
+            max_person_count: Maximum allowed person count before triggering alert
+    
+        Returns:
+            PostProcessingConfig optimized for security monitoring
+    """
+def create_tracking_post_processing_config(confidence_threshold: float = 0.6, enable_tracking: bool = True, enable_counting: bool = True, enable_alerting: bool = True, tracking_zones: Dict[str, List[Tuple[int, int]]] = None, crossing_lines: Dict[str, List[Tuple[int, int]]] = None, map_index_to_category: bool = False, index_to_category: Dict[int, str] = None, category_triggers: List[str] = None) -> Any: ...
+    """
+    Create a post-processing configuration optimized for object tracking.
+    
+        Args:
+            confidence_threshold: Global confidence threshold for filtering detections
+            enable_tracking: Whether to enable tracking features
+            enable_counting: Whether to enable object counting features
+            enable_alerting: Whether to enable alerting features
+            tracking_zones: Dictionary of zone names to polygon coordinates
+            crossing_lines: Dictionary of line names to line coordinates
+            map_index_to_category: Whether to map category indices to names
+            index_to_category: Mapping from category indices to category names
+            category_triggers: List of categories that should trigger alerts
+    
+        Returns:
+            PostProcessingConfig optimized for tracking models
+    """
+def create_video_frame_input(video_path: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None) -> Any: ...
+    """
+    Create a video file input for frame-based streaming.
+    
+        Args:
+            video_path: Path to video file
+            fps: Frames per second
+            quality: Image quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+    
+        Returns:
+            InputConfig: Video input configured for frame streaming
+    """
+def create_video_input(video_path: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, model_input_type: Any = ModelInputType.FRAMES, video_duration: float = None, max_frames: int = None, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a video file input configuration.
+    
+        Args:
+            video_path: Path to the video file
+            fps: Frames per second to process
+            quality: Video/image quality (1-100)
+            stream_key: Unique identifier for the stream
+            width: Frame width in pixels
+            height: Frame height in pixels
+            model_input_type: FRAMES for individual images, VIDEO for video chunks
+            video_duration: Duration of video chunks in seconds (only for VIDEO mode)
+            max_frames: Maximum frames per video chunk (only for VIDEO mode)
+            video_format: Video format for encoding (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Configured input for video file
+    
+        Raises:
+            ValueError: If parameters are invalid
+            FileNotFoundError: If video file doesn't exist
+    """
+def create_video_video_input(video_path: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, video_duration: float = 5.0, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a video file input for video-based streaming with duration limit.
+    
+        Args:
+            video_path: Path to video file
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            video_duration: Duration of video chunks in seconds
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Video input configured for video streaming
+    """
+def create_video_video_input_by_frames(video_path: str, fps: int = 30, quality: int = 95, stream_key: str = None, width: int = None, height: int = None, max_frames: int = 150, video_format: str = 'mp4') -> Any: ...
+    """
+    Create a video file input for video-based streaming with frame count limit.
+    
+        Args:
+            video_path: Path to video file
+            fps: Frames per second
+            quality: Video quality (1-100)
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+            max_frames: Maximum frames per video chunk
+            video_format: Video format (mp4, avi, webm)
+    
+        Returns:
+            InputConfig: Video input configured for video streaming
+    """
+
+# Classes
+class FileOutputConfig:
+    """
+    Configuration for file output.
+    """
+
+    def from_dict(cls: Any, data: Dict) -> Any: ...
+        """
+        Create from dictionary.
+        """
+
+    def to_dict(self: Any) -> Dict: ...
+        """
+        Convert to dictionary.
+        """
+
+class InputConfig:
+    """
+    Configuration for input sources.
+    """
+
+    def from_dict(cls: Any, data: Dict) -> Any: ...
+        """
+        Create from dictionary.
+        """
+
+    def to_dict(self: Any) -> Dict: ...
+        """
+        Convert to dictionary.
+        """
+
+class InputType(Enum):
+    """
+    Supported input types.
+    """
+
+    AUTO: str
+    CAMERA: str
+    HTTP_STREAM: str
+    HTTP_VIDEO_FILE: str
+    RTSP_STREAM: str
+    VIDEO_FILE: str
+
+    pass
+class KafkaOutputConfig:
+    """
+    Configuration for Kafka output.
+    """
+
+    def from_dict(cls: Any, data: Dict) -> Any: ...
+        """
+        Create from dictionary.
+        """
+
+    def to_dict(self: Any) -> Dict: ...
+        """
+        Convert to dictionary.
+        """
+
+class ModelInputType(Enum):
+    """
+    Supported model input types.
+    """
+
+    FRAMES: str
+    VIDEO: str
+
+    pass
+class OutputConfig:
+    """
+    Configuration for output destinations.
+    """
+
+    def from_dict(cls: Any, data: Dict) -> Any: ...
+        """
+        Create from dictionary.
+        """
+
+    def to_dict(self: Any) -> Dict: ...
+        """
+        Convert to dictionary.
+        """
+
+class OutputType(Enum):
+    """
+    Supported output types.
+    """
+
+    BOTH: str
+    FILE: str
+    KAFKA: str
+
+    pass

matrice_inference/deploy/client/streaming_gateway/streaming_results_handler.pyi

@@ -0,0 +1,19 @@
+"""Auto-generated stub for module: streaming_results_handler."""
+from typing import Any, Dict, Optional
+
+from confluent_kafka import Producer
+from datetime import datetime
+from matrice_inference.deploy.client.client_stream_utils import ClientStreamUtils
+from matrice_inference.deploy.client.streaming_gateway.streaming_gateway_utils import OutputType, OutputConfig, _RealTimeJsonEventPicker
+from matrice_inference.deploy.utils.post_processing import PostProcessor
+import json
+import logging
+import os
+import threading
+import time
+
+# Classes
+class StreamingResultsHandler:
+    def __init__(self: Any, client_stream_utils: Any, output_config: Any, json_event_picker: Any, service_id: str = None, strip_input_from_result: bool = True, result_callback: Optional[Callable] = None) -> None: ...
+
+    pass

matrice_inference/deploy/optimize/cache_manager.pyi

@@ -0,0 +1,15 @@
+"""Auto-generated stub for module: cache_manager."""
+from typing import Any, Dict
+
+from collections import OrderedDict
+
+# Classes
+class CacheManager:
+    def __init__(self: Any, max_cache_size: int = 5) -> None: ...
+
+    def clear_cache(self: Any, stream_key: str = None) -> Any: ...
+
+    def get_cached_result(self: Any, input_hash: str, stream_key: str = None) -> Any: ...
+
+    def set_cached_result(self: Any, input_hash: str, value: dict, stream_key: str = None) -> Any: ...
+