matrice-inference 0.1.0__py3-none-manylinux_2_17_x86_64.whl

matrice_inference/deploy/aggregator/aggregator.pyi

@@ -0,0 +1,55 @@
+"""Auto-generated stub for module: aggregator."""
+from typing import Any, Dict, List, Optional
+
+from collections import defaultdict
+from queue import Queue, Empty
+import copy
+import logging
+import threading
+import time
+
+# Classes
+class ResultsAggregator:
+    """
+    Handles complex aggregation and combination of synchronized results from multiple deployments.
+    This component takes synchronized results and combines them into meaningful aggregated outputs
+    while maintaining consistent structure with individual deployment results.
+    """
+
+    def __init__(self: Any, synchronized_results_queue: Any, aggregate_by_location: bool = False) -> None: ...
+        """
+        Initialize the results aggregator.
+        
+        Args:
+            synchronized_results_queue: Queue containing synchronized results from synchronizer
+            aggregation_strategies: List of aggregation strategies to apply
+        """
+
+    def cleanup(self: Any) -> None: ...
+        """
+        Clean up resources.
+        """
+
+    def get_health_status(self: Any) -> Dict[str, Any]: ...
+        """
+        Get health status of the aggregator.
+        """
+
+    def get_stats(self: Any) -> Dict[str, Any]: ...
+        """
+        Get current aggregation statistics.
+        """
+
+    def start_aggregation(self: Any) -> bool: ...
+        """
+        Start the results aggregation process.
+        
+        Returns:
+            bool: True if aggregation started successfully, False otherwise
+        """
+
+    def stop_aggregation(self: Any) -> Any: ...
+        """
+        Stop the results aggregation process.
+        """
+

matrice_inference/deploy/aggregator/analytics.pyi

@@ -0,0 +1,63 @@
+"""Auto-generated stub for module: analytics."""
+from typing import Any, Dict, List, Optional, Tuple
+
+from confluent_kafka import Producer
+from matrice_common.session import Session
+import base64
+import json
+import logging
+import threading
+import time
+
+# Classes
+class AnalyticsSummarizer:
+    """
+    Buffers aggregated camera_results and emits 5-minute rollups per camera
+    focusing on tracking_stats per application.
+    
+    Output structure example per camera:
+        {
+          "camera_name": "camera_1",
+          "inferencePipelineId": "pipeline-xyz",
+          "camera_group": "group_a",
+          "location": "Lobby",
+          "agg_apps": [
+            {
+              "application_name": "People Counting",
+              "application_key_name": "People_Counting",
+              "application_version": "1.3",
+              "tracking_stats": {
+                "input_timestamp": "00:00:09.9",          # last seen
+                "reset_timestamp": "00:00:00",             # earliest seen in window
+                "current_counts": [{"category": "person", "count": 4}],  # last seen
+                "total_counts": [{"category": "person", "count": 37}]   # max seen in window
+              }
+            }
+          ],
+          "summary_metadata": {
+            "window_seconds": 300,
+            "messages_aggregated": 123,
+            "start_time": 1710000000.0,
+            "end_time": 1710000300.0
+          }
+        }
+    """
+
+    def __init__(self: Any, session: Session, inference_pipeline_id: str, flush_interval_seconds: int = 300) -> None: ...
+
+    def cleanup(self: Any) -> None: ...
+
+    def get_health_status(self: Any) -> Dict[str, Any]: ...
+
+    def get_stats(self: Any) -> Dict[str, Any]: ...
+
+    def ingest_result(self: Any, aggregated_result: Dict[str, Any]) -> None: ...
+        """
+        Receive a single aggregated camera_results payload for buffering.
+        This is intended to be called by the publisher after successful publish.
+        """
+
+    def start(self: Any) -> bool: ...
+
+    def stop(self: Any) -> None: ...
+

matrice_inference/deploy/aggregator/ingestor.pyi

@@ -0,0 +1,79 @@
+"""Auto-generated stub for module: ingestor."""
+from typing import Any, Dict, List, Optional, Tuple
+
+from matrice_common.session import Session
+from matrice_inference.deploy.stream.kafka_stream import MatriceKafkaDeployment
+from queue import Empty, PriorityQueue, Full
+import itertools
+import logging
+import threading
+import time
+
+# Classes
+class ResultsIngestor:
+    """
+    Streams and manages results from multiple deployments.
+    Handles result collection, queuing, and distribution with enhanced structure consistency.
+    """
+
+    def __init__(self: Any, deployment_ids: List[str], session: Session, consumer_timeout: float = 60) -> None: ...
+        """
+        Initialize the results streamer.
+        
+        Args:
+            deployment_ids: List of deployment IDs
+            session: Session object for authentication
+            consumer_timeout: Timeout for consuming results from deployments
+        """
+
+    def cleanup(self: Any) -> None: ...
+        """
+        Clean up all resources.
+        """
+
+    def get_all_results(self: Any, timeout: float = 1.0) -> List[Dict]: ...
+        """
+        Get results from all deployment queues.
+        
+        Args:
+            timeout: Timeout for getting results
+        
+        Returns:
+            List[Dict]: List of result dictionaries
+        """
+
+    def get_health_status(self: Any) -> Dict: ...
+        """
+        Get health status of the results streamer.
+        """
+
+    def get_results(self: Any, deployment_id: str, timeout: float = 1.0) -> Optional[Dict]: ...
+        """
+        Get a result from a specific deployment's priority queue.
+        
+        Args:
+            deployment_id: ID of the deployment
+            timeout: Timeout for getting the result
+        
+        Returns:
+            Dict: Result dictionary or None if timeout/no result
+        """
+
+    def get_stats(self: Any) -> Dict: ...
+        """
+        Get current statistics.
+        """
+
+    def start_streaming(self: Any) -> bool: ...
+        """
+        Start streaming results from all deployments.
+        
+        Returns:
+            bool: True if streaming started successfully, False otherwise
+        """
+
+    def stop_streaming(self: Any) -> None: ...
+        """
+        Stop all streaming operations.
+        """
+

matrice_inference/deploy/aggregator/pipeline.pyi

@@ -0,0 +1,139 @@
+"""Auto-generated stub for module: pipeline."""
+from typing import Any, Dict
+
+from matrice_common.session import Session
+from matrice_inference.deploy.aggregator.aggregator import ResultsAggregator
+from matrice_inference.deploy.aggregator.analytics import AnalyticsSummarizer
+from matrice_inference.deploy.aggregator.ingestor import ResultsIngestor
+from matrice_inference.deploy.aggregator.publisher import ResultsPublisher
+from matrice_inference.deploy.aggregator.synchronizer import ResultsSynchronizer
+from matrice_inference.deployment.inference_pipeline import InferencePipeline
+from queue import Queue
+import logging
+import time
+
+# Classes
+class ResultsAggregationPipeline:
+    """
+    Enhanced deployments aggregator that handles multiple streams, synchronizes results,
+    and outputs aggregated results to Kafka topics with consistent structure.
+    
+    This class orchestrates the complete pipeline for collecting, synchronizing, and
+    publishing results from multiple ML model deployments in an inference pipeline,
+    ensuring all results follow the same structure as individual deployment results.
+    
+    Usage Example:
+        ```python
+        from matrice import Session
+        from matrice_inference.deploy.aggregator import ResultsAggregationPipeline
+    
+        # Initialize session
+        session = Session(account_number="...", access_key="...", secret_key="...")
+    
+        # Create aggregator for an inference pipeline
+        aggregator = ResultsAggregationPipeline(session, "your-inference-pipeline-id")
+    
+        # Setup the aggregation pipeline
+        if aggregator.setup_components():
+            print(f"Setup complete for {len(aggregator.deployment_ids)} deployments")
+    
+            # Start streaming and run until keyboard interrupt
+            try:
+                aggregator.start_streaming()
+            except KeyboardInterrupt:
+                print("Pipeline stopped by user")
+            finally:
+                aggregator.cleanup()
+        ```
+    """
+
+    def __init__(self: Any, session: Session, action_record_id: str) -> None: ...
+        """
+        Initialize the deployments aggregator.
+        
+        Args:
+            session: Session object for authentication
+            action_record_id: Action Record ID
+        """
+
+    def cleanup(self: Any) -> None: ...
+        """
+        Clean up all resources.
+        """
+
+    def force_sync_pending_results(self: Any) -> int: ...
+        """
+        Force synchronization of all pending results.
+        
+        Returns:
+            int: Number of pending results that were synchronized
+        """
+
+    def get_deployment_info(self: Any) -> Dict: ...
+        """
+        Get information about the deployments in this aggregator.
+        
+        Returns:
+            Dict: Deployment information including IDs, count, and status
+        """
+
+    def get_health_status(self: Any) -> Dict: ...
+        """
+        Get health status of all components.
+        """
+
+    def get_stats(self: Any) -> Dict: ...
+        """
+        Get current statistics from all components.
+        """
+
+    def setup_components(self: Any) -> bool: ...
+        """
+        Setup all components and initialize the aggregation pipeline.
+        
+        Returns:
+            bool: True if all components initialized successfully, False otherwise
+        """
+
+    def start_logging(self: Any, status_interval: int = 30) -> None: ...
+        """
+        Start the pipeline logging and run until interrupted.
+        Args:
+            status_interval: Interval in seconds between status log messages
+        """
+
+    def start_streaming(self: Any, block: bool = True) -> bool: ...
+        """
+        Start the complete streaming pipeline: ingestion, synchronization, aggregation, and publishing.
+        
+        Returns:
+            bool: True if streaming started successfully, False otherwise
+        """
+
+    def stop_streaming(self: Any) -> None: ...
+        """
+        Stop all streaming operations in reverse order.
+        """
+
+    def update_status(self: Any, step_code: str, status: str, status_description: str) -> None: ...
+        """
+        Update status of data preparation.
+        
+                Args:
+                    step_code: Code indicating current step
+                    status: Status of step
+                    status_description: Description of status
+        """
+
+    def wait_for_ready(self: Any, timeout: int = 300, poll_interval: int = 10) -> bool: ...
+        """
+        Wait for the aggregator to be ready and processing results.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+            poll_interval: Time between checks in seconds
+        
+        Returns:
+            bool: True if aggregator is ready, False if timeout
+        """
+

matrice_inference/deploy/aggregator/publisher.pyi

@@ -0,0 +1,59 @@
+"""Auto-generated stub for module: publisher."""
+from typing import Any, Dict, Optional
+
+from matrice_common.session import Session
+from matrice_inference.deploy.stream.kafka_stream import MatriceKafkaDeployment
+from queue import Queue, Empty
+import logging
+import threading
+import time
+
+# Classes
+class ResultsPublisher:
+    """
+    Streams final aggregated results from inference pipeline to Kafka.
+    Handles result collection, queuing, and distribution with proper error handling
+    for the enhanced aggregated result structure.
+    """
+
+    def __init__(self: Any, inference_pipeline_id: str, session: Session, final_results_queue: Any, analytics_summarizer: Optional[Any] = None) -> None: ...
+        """
+        Initialize the final results streamer.
+        
+        Args:
+            inference_pipeline_id: ID of the inference pipeline
+            session: Session object for authentication
+            final_results_queue: Queue containing final aggregated results
+        """
+
+    def get_health_status(self: Any) -> Dict[str, Any]: ...
+        """
+        Get health status of the publisher.
+        """
+
+    def get_stats(self: Any) -> Dict[str, Any]: ...
+        """
+        Get streaming statistics.
+        
+        Returns:
+            Dict containing statistics
+        """
+
+    def is_running(self: Any) -> bool: ...
+        """
+        Check if the streamer is currently running.
+        """
+
+    def start_streaming(self: Any) -> bool: ...
+        """
+        Start streaming final results to Kafka.
+        
+        Returns:
+            bool: True if streaming started successfully, False otherwise
+        """
+
+    def stop_streaming(self: Any) -> None: ...
+        """
+        Stop streaming final results.
+        """
+

matrice_inference/deploy/aggregator/synchronizer.pyi

@@ -0,0 +1,58 @@
+"""Auto-generated stub for module: synchronizer."""
+from typing import Any, Dict, List, Tuple
+
+from collections import defaultdict
+from queue import Queue, Empty, PriorityQueue
+import logging
+import threading
+import time
+
+# Classes
+class ResultsSynchronizer:
+    """
+    Handles synchronization of results from multiple deployments by stream_key and input_order.
+    Ensures consistent structure and proper error handling for the aggregation pipeline.
+    """
+
+    def __init__(self: Any, results_queues: Dict[str, PriorityQueue], sync_timeout: float = 60.0) -> None: ...
+        """
+        Initialize the results synchronizer.
+        
+        Args:
+            results_queues: Dictionary of priority queues containing results from deployments
+            sync_timeout: Maximum time to wait for input_order synchronization (in seconds)
+        """
+
+    def cleanup(self: Any) -> None: ...
+        """
+        Clean up resources.
+        """
+
+    def force_sync_pending(self: Any) -> int: ...
+        """
+        Force synchronization of all pending results regardless of completeness.
+        """
+
+    def get_health_status(self: Any) -> Dict: ...
+        """
+        Get health status of the synchronizer.
+        """
+
+    def get_stats(self: Any) -> Dict: ...
+        """
+        Get current synchronization statistics.
+        """
+
+    def start_synchronization(self: Any) -> bool: ...
+        """
+        Start the results synchronization process.
+        
+        Returns:
+            bool: True if synchronization started successfully, False otherwise
+        """
+
+    def stop_synchronization(self: Any) -> Any: ...
+        """
+        Stop the results synchronization process.
+        """
+

matrice_inference/deploy/client/auto_streaming/auto_streaming.pyi

@@ -0,0 +1,145 @@
+"""Auto-generated stub for module: auto_streaming."""
+from typing import Any, Dict, List, Optional
+
+from auto_streaming_utils import AutoStreamingUtils
+from matrice_inference.deploy.client.streaming_gateway import StreamingGateway, ModelInputType, OutputConfig, InputConfig
+from matrice_inference.deployment.camera_manager import CameraManager
+from matrice_inference.deployment.streaming_gateway_manager import StreamingGateway
+from matrice_inference.deployment.streaming_gateway_manager import StreamingGatewayManager
+import logging
+import threading
+import time
+
+# Classes
+class AutoStreaming:
+    """
+    Handles automatic streaming setup and management using streaming gateway configurations.
+    
+    This class manages multiple streaming gateways, automatically configures cameras
+    based on the gateway's camera group assignments, and handles the streaming lifecycle.
+    
+    Example usage:
+        # Method 1: From service IDs (auto-discovers all gateways)
+        auto_streaming = AutoStreaming(
+            session=session,
+            service_ids=["service_id_123", "service_id_456"],
+            model_input_type=ModelInputType.FRAMES
+        )
+    
+        # Method 2: From specific gateway IDs
+        auto_streaming = AutoStreaming(
+            session=session,
+            streaming_gateway_ids=["gateway1", "gateway2"],
+            model_input_type=ModelInputType.FRAMES
+        )
+    
+        # Start auto streaming
+        success = auto_streaming.start()
+    
+        # Stop auto streaming
+        auto_streaming.stop()
+    
+        # Get statistics
+        stats = auto_streaming.get_statistics()
+    """
+
+    def __init__(self: Any, session: Any, service_ids: List[str] = None, streaming_gateway_ids: List[str] = None, model_input_type: Any = ModelInputType.FRAMES, output_configs: Optional[Dict[str, OutputConfig]] = None, result_callback: Optional[Callable] = None, strip_input_from_result: bool = True, default_fps: int = 30, default_quality: int = 80, default_video_chunk_duration: int = 10, default_video_format: str = 'mp4', simulate_video_file_stream: bool = False) -> None: ...
+        """
+        Initialize AutoStreaming with service IDs or streaming gateway IDs.
+        
+        Args:
+            session: Session object for authentication
+            service_ids: List of Service IDs (deployment or inference pipeline ID) - will auto-discover gateways
+            streaming_gateway_ids: List of specific streaming gateway IDs to use
+            model_input_type: Model input type (FRAMES or VIDEO)
+            output_configs: Optional output configurations per streaming gateway
+            result_callback: Optional callback for processing results
+            strip_input_from_result: Whether to strip input from results
+            default_fps: Default FPS for camera streams
+            default_quality: Default quality for camera streams
+            default_video_chunk_duration: Default video chunk duration for video input type
+            default_video_format: Default video format for video input type
+            simulate_video_file_stream: Whether to restream videos
+        Note:
+            Either service_ids OR streaming_gateway_ids must be provided, not both.
+            If service_ids is provided, all gateways for those services will be auto-discovered.
+        """
+
+    def add_streaming_gateway(self: Any, gateway_id: str) -> bool: ...
+        """
+        Add a new streaming gateway to auto streaming.
+        
+        Args:
+            gateway_id: ID of the streaming gateway to add
+        
+        Returns:
+            bool: True if gateway was added successfully
+        """
+
+    def get_gateway_status(self: Any, gateway_id: str) -> Optional[Dict]: ...
+        """
+        Get status for a specific streaming gateway.
+        
+        Args:
+            gateway_id: Streaming gateway ID
+        
+        Returns:
+            Dict with gateway status or None if not found
+        """
+
+    def get_statistics(self: Any) -> Dict: ...
+        """
+        Get auto streaming statistics.
+        
+        Returns:
+            Dict with comprehensive statistics
+        """
+
+    def refresh_camera_configs(self: Any) -> bool: ...
+        """
+        Refresh camera configurations for all streaming gateways.
+        
+        Returns:
+            bool: True if configurations were refreshed successfully
+        """
+
+    def remove_streaming_gateway(self: Any, gateway_id: str) -> bool: ...
+        """
+        Remove a streaming gateway from auto streaming.
+        
+        Args:
+            gateway_id: ID of the streaming gateway to remove
+        
+        Returns:
+            bool: True if gateway was removed successfully
+        """
+
+    def setup_streaming_gateways(self: Any, gateway_input_configs: Dict[str, List[InputConfig]] = None) -> Dict[str, StreamingGateway]: ...
+        """
+        Setup StreamingGateway instances for each streaming gateway ID.
+        
+        Returns:
+            bool: True if all gateways were setup successfully, False otherwise
+        """
+
+    def setup_streaming_gateways_input_configs(self: Any) -> Optional[Dict[str, List[InputConfig]]]: ...
+        """
+        Setup input configurations for each streaming gateway ID.
+        
+        Returns:
+            bool: True if all gateway input configs were setup successfully, False otherwise
+        """
+
+    def start(self: Any, send_to_api: bool = False) -> bool: ...
+        """
+        Start auto streaming for all configured streaming gateways.
+        
+        Returns:
+            bool: True if streaming started successfully, False otherwise
+        """
+
+    def stop(self: Any) -> Any: ...
+        """
+        Stop auto streaming for all gateways.
+        """
+