matrice-inference 0.1.2__py3-none-any.whl → 0.1.23__py3-none-any.whl

matrice_inference/server/stream/stream_pipeline.py

@@ -1,5 +1,5 @@
 """
-Ultra-optimized streaming pipeline using MatriceStream and updated inference interface:
+Streaming pipeline using MatriceStream and updated inference interface:
 Direct processing with priority queues, dynamic camera configuration
 
 Architecture:
@@ -18,186 +18,137 @@ Features:
 - Non-blocking threading for consumers/producers
 """
 
-import asyncio
-import json
-import time
 import logging
-import threading
 import queue
-import signal
-import copy
-from dataclasses import dataclass, field
-from typing import Any, Dict, Optional, List, Union
 from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, List, Optional
 
-from matrice_common.stream.matrice_stream import MatriceStream, StreamType
 from matrice_analytics.post_processing.post_processor import PostProcessor
-
 from matrice_inference.server.inference_interface import InferenceInterface
-from matrice_inference.server.model.model_manager_wrapper import ModelManagerWrapper
-from matrice_inference.server.stream.utils import CameraConfig, StreamMessage
 from matrice_inference.server.stream.consumer_worker import ConsumerWorker
 from matrice_inference.server.stream.inference_worker import InferenceWorker
 from matrice_inference.server.stream.post_processing_worker import PostProcessingWorker
 from matrice_inference.server.stream.producer_worker import ProducerWorker
-# from matrice_inference.server.stream.frame_cache import RedisFrameCache
+from matrice_inference.server.stream.utils import CameraConfig
 
 
 
 class StreamingPipeline:
-    """Ultra-optimized streaming pipeline with dynamic camera configuration."""
-    
+    """Optimized streaming pipeline with dynamic camera configuration and clean resource management."""
+
+    DEFAULT_QUEUE_SIZE = 5000
+    DEFAULT_MESSAGE_TIMEOUT = 10.0
+    DEFAULT_INFERENCE_TIMEOUT = 30.0
+    DEFAULT_SHUTDOWN_TIMEOUT = 30.0
+
     def __init__(
         self,
         inference_interface: InferenceInterface,
         post_processor: PostProcessor,
-        consumer_threads=1,
-        producer_threads=1,
-        inference_threads=1,
-        postprocessing_threads=1,
-        inference_queue_maxsize=5000,
-        postproc_queue_maxsize=5000,
-        output_queue_maxsize=5000,
-        message_timeout=10.0,
-        inference_timeout=30.0,
-        shutdown_timeout=30.0,
+        inference_queue_maxsize: int = DEFAULT_QUEUE_SIZE,
+        postproc_queue_maxsize: int = DEFAULT_QUEUE_SIZE,
+        output_queue_maxsize: int = DEFAULT_QUEUE_SIZE,
+        message_timeout: float = DEFAULT_MESSAGE_TIMEOUT,
+        inference_timeout: float = DEFAULT_INFERENCE_TIMEOUT,
+        shutdown_timeout: float = DEFAULT_SHUTDOWN_TIMEOUT,
         camera_configs: Optional[Dict[str, CameraConfig]] = None,
     ):
         self.inference_interface = inference_interface
         self.post_processor = post_processor
-        self.consumer_threads = consumer_threads
-        self.producer_threads = producer_threads
-        self.inference_threads = inference_threads
-        self.postprocessing_threads = postprocessing_threads
-        self.inference_queue_maxsize = inference_queue_maxsize
-        self.postproc_queue_maxsize = postproc_queue_maxsize
-        self.output_queue_maxsize = output_queue_maxsize
         self.message_timeout = message_timeout
         self.inference_timeout = inference_timeout
         self.shutdown_timeout = shutdown_timeout
-        
-        # Camera configurations (can be empty initially)
+
         self.camera_configs: Dict[str, CameraConfig] = camera_configs or {}
-        
-        # Priority queues for pipeline stages
-        self.inference_queue = queue.PriorityQueue(maxsize=self.inference_queue_maxsize)
-        self.postproc_queue = queue.PriorityQueue(maxsize=self.postproc_queue_maxsize)
-        self.output_queue = queue.PriorityQueue(maxsize=self.output_queue_maxsize)
-        
-        # Thread pools for CPU/GPU intensive work
-        self.inference_executor = ThreadPoolExecutor(self.inference_threads)
-        self.postprocessing_executor = ThreadPoolExecutor(self.postprocessing_threads)
-        
-        # No centralized stream management - each worker creates its own streams
-        
-        # Worker instances
-        self.consumer_workers: Dict[str, List[ConsumerWorker]] = {}
-        self.inference_workers = []
-        self.postproc_workers = []
-        self.producer_workers = []
-        
-        # Worker threads
-        self.worker_threads = []
-        
-        # Control state
         self.running = False
-        
         self.logger = logging.getLogger(__name__)
-        
-        # Frame cache disabled (commented out)
-        # self.frame_cache_config = frame_cache_config or {}
-        # self.frame_cache: Optional[RedisFrameCache] = None
-    
-    # Removed set_global_instances method - now passing interfaces as parameters to worker functions
+
+        self._setup_queues(inference_queue_maxsize, postproc_queue_maxsize, output_queue_maxsize)
+        self._setup_executors()
+        self._setup_workers()
+        # Frame cache instance (initialized lazily at start)
+        self.frame_cache = None
+
+    def _setup_queues(self, inference_size: int, postproc_size: int, output_size: int) -> None:
+        """Initialize priority queues for pipeline stages."""
+        self.inference_queue = queue.PriorityQueue(maxsize=inference_size)
+        self.postproc_queue = queue.PriorityQueue(maxsize=postproc_size)
+        self.output_queue = queue.PriorityQueue(maxsize=output_size)
+
+    def _setup_executors(self) -> None:
+        """Initialize thread pool executors."""
+        # Single-thread executors to preserve strict ordering
+        self.inference_executor = ThreadPoolExecutor(max_workers=1)
+        self.postprocessing_executor = ThreadPoolExecutor(max_workers=1)
+
+    def _setup_workers(self) -> None:
+        """Initialize worker containers."""
+        self.consumer_workers: Dict[str, List[ConsumerWorker]] = {}
+        self.inference_workers: List = []
+        self.postproc_workers: List = []
+        self.producer_workers: List = []
+        self.worker_threads: List = []
     
-    async def start(self):
-        """Start the pipeline."""
+    async def start(self) -> None:
+        """Start the pipeline with proper error handling."""
         if self.running:
             self.logger.warning("Pipeline already running")
             return
-        
+
         self.running = True
-        self.logger.info("Starting ultra-optimized streaming pipeline...")
-        
+        self.logger.info("Starting streaming pipeline...")
+
         try:
-            # Frame cache initialization disabled
-            # fc = dict(self.frame_cache_config)
-            # if not fc.get("host"):
-            #     for cfg in self.camera_configs.values():
-            #         sc = cfg.stream_config
-            #         if sc.get("stream_type", "kafka").lower() == "redis":
-            #             fc.setdefault("host", sc.get("host", "localhost"))
-            #             fc.setdefault("port", sc.get("port", 6379))
-            #             fc.setdefault("password", sc.get("password"))
-            #             fc.setdefault("username", sc.get("username"))
-            #             fc.setdefault("db", sc.get("db", 0))
-            #             break
-            # try:
-            #     self.frame_cache = RedisFrameCache(
-            #         host=fc.get("host", "localhost"),
-            #         port=fc.get("port", 6379),
-            #         db=fc.get("db", 0),
-            #         password=fc.get("password"),
-            #         username=fc.get("username"),
-            #         ttl_seconds=fc.get("ttl_seconds", 300),
-            #         prefix=fc.get("prefix", "stream:frames:"),
-            #     )
-            #     self.frame_cache.start()
-            # except Exception as _:
-            #     self.frame_cache = None
-            #     self.logger.warning("Frame cache initialization failed; proceeding without cache")
-            
-            # Initialize streams for existing camera configs
-            await self._initialize_streams()
-            
-            # Create and start workers
+            # Initialize frame cache before workers
+            self._initialize_frame_cache()
             await self._create_workers()
             self._start_workers()
-            
-            self.logger.info(
-                f"Pipeline started with {len(self.camera_configs)} cameras, "
-                f"{sum(len(workers) for workers in self.consumer_workers.values())} consumer workers, "
-                f"{len(self.inference_workers)} inference workers, "
-                f"{len(self.postproc_workers)} post-processing workers, "
-                f"{len(self.producer_workers)} producer workers"
-            )
-            
+            self._log_startup_info()
         except Exception as e:
             self.logger.error(f"Failed to start pipeline: {e}")
             await self.stop()
             raise
+
+    def _log_startup_info(self) -> None:
+        """Log pipeline startup information."""
+        consumer_count = sum(len(workers) for workers in self.consumer_workers.values())
+        self.logger.info(
+            f"Pipeline started - Cameras: {len(self.camera_configs)}, "
+            f"Consumers: {consumer_count}, Inference: {len(self.inference_workers)}, "
+            f"PostProc: {len(self.postproc_workers)}, Producers: {len(self.producer_workers)}"
+        )
     
-    async def stop(self):
-        """Stop the pipeline gracefully."""
+    async def stop(self) -> None:
+        """Stop the pipeline gracefully with proper cleanup."""
         if not self.running:
             return
-        
+
         self.logger.info("Stopping pipeline...")
         self.running = False
-        
-        # Stop all workers
+
         self._stop_workers()
-        
-        # Wait for all threads to complete
+        self._wait_for_threads()
+        self._shutdown_executors()
+
+        # Stop frame cache if running
+        try:
+            if self.frame_cache:
+                self.frame_cache.stop()
+        except Exception:
+            pass
+
+        self.logger.info("Pipeline stopped")
+
+    def _wait_for_threads(self) -> None:
+        """Wait for all worker threads to complete."""
         for thread in self.worker_threads:
             if thread.is_alive():
                 thread.join(timeout=self.shutdown_timeout)
-        
-        # Close streams
-        await self._close_streams()
-        
-        # Shutdown executors
+
+    def _shutdown_executors(self) -> None:
+        """Shutdown thread pool executors."""
         self.inference_executor.shutdown(wait=False)
         self.postprocessing_executor.shutdown(wait=False)
-        
-        # Frame cache stop disabled
-        # try:
-        #     if self.frame_cache:
-        #         self.frame_cache.stop()
-        # except Exception:
-        #     pass
-        
-        self.logger.info("Pipeline stopped")
     
     async def add_camera_config(self, camera_config: CameraConfig) -> bool:
         """
@@ -273,149 +224,137 @@ class StreamingPipeline:
         return await self.add_camera_config(camera_config)
     
     def enable_camera(self, camera_id: str) -> bool:
-        """Enable a camera."""
-        if camera_id in self.camera_configs:
-            self.camera_configs[camera_id].enabled = True
-            self.logger.info(f"Camera {camera_id} enabled")
-            return True
-        return False
-    
+        """Enable a camera configuration."""
+        return self._set_camera_state(camera_id, True, "enabled")
+
     def disable_camera(self, camera_id: str) -> bool:
-        """Disable a camera."""
+        """Disable a camera configuration."""
+        return self._set_camera_state(camera_id, False, "disabled")
+
+    def _set_camera_state(self, camera_id: str, enabled: bool, state_name: str) -> bool:
+        """Set camera enabled state."""
         if camera_id in self.camera_configs:
-            self.camera_configs[camera_id].enabled = False
-            self.logger.info(f"Camera {camera_id} disabled")
+            self.camera_configs[camera_id].enabled = enabled
+            self.logger.info(f"Camera {camera_id} {state_name}")
             return True
         return False
+      
     
-    async def _initialize_streams(self):
-        """No centralized stream initialization - workers create their own streams."""
-        pass
-    
-    async def _initialize_camera_streams(self, camera_config: CameraConfig):
-        """No centralized camera stream initialization - workers create their own streams."""
-        pass
-    
-    async def _close_streams(self):
-        """No centralized streams to close - workers manage their own streams."""
-        pass
-    
-    async def _close_camera_streams(self, camera_id: str):
-        """No centralized camera streams to close - workers manage their own streams."""
-        pass
-    
-    async def _create_workers(self):
-        """Create all worker instances."""
-        # Create consumer workers (per camera)
+    async def _create_workers(self) -> None:
+        """Create all worker instances for the pipeline."""
+        await self._create_consumer_workers()
+        self._create_inference_worker()
+        self._create_postprocessing_worker()
+        self._create_producer_worker()
+
+    async def _create_consumer_workers(self) -> None:
+        """Create consumer workers for all cameras."""
         for camera_config in self.camera_configs.values():
             await self._create_camera_workers(camera_config)
-        
-        # Create inference workers
-        for i in range(self.inference_threads):
-            worker = InferenceWorker(
-                worker_id=i,
-                inference_queue=self.inference_queue,
-                postproc_queue=self.postproc_queue,
-                inference_executor=self.inference_executor,
-                message_timeout=self.message_timeout,
-                inference_timeout=self.inference_timeout,
-                inference_interface=self.inference_interface
-            )
-            self.inference_workers.append(worker)
-        
-        # Create post-processing workers
-        for i in range(self.postprocessing_threads):
-            worker = PostProcessingWorker(
-                worker_id=i,
-                postproc_queue=self.postproc_queue,
-                output_queue=self.output_queue,
-                postprocessing_executor=self.postprocessing_executor,
-                message_timeout=self.message_timeout,
-                inference_timeout=self.inference_timeout,
-                post_processor=self.post_processor,
-                # frame_cache=self.frame_cache,
-            )
-            self.postproc_workers.append(worker)
-        
-        # Create producer workers
-        for i in range(self.producer_threads):
-            worker = ProducerWorker(
-                worker_id=i,
-                output_queue=self.output_queue,
-                camera_configs=self.camera_configs,
-                message_timeout=self.message_timeout
-            )
-            self.producer_workers.append(worker)
+
+    def _create_inference_worker(self) -> None:
+        """Create single inference worker."""
+        worker = InferenceWorker(
+            worker_id=0,
+            inference_queue=self.inference_queue,
+            postproc_queue=self.postproc_queue,
+            inference_executor=self.inference_executor,
+            message_timeout=self.message_timeout,
+            inference_timeout=self.inference_timeout,
+            inference_interface=self.inference_interface
+        )
+        self.inference_workers.append(worker)
+
+    def _create_postprocessing_worker(self) -> None:
+        """Create single post-processing worker."""
+        worker = PostProcessingWorker(
+            worker_id=0,
+            postproc_queue=self.postproc_queue,
+            output_queue=self.output_queue,
+            postprocessing_executor=self.postprocessing_executor,
+            message_timeout=self.message_timeout,
+            inference_timeout=self.inference_timeout,
+            post_processor=self.post_processor,
+            frame_cache=self.frame_cache,
+        )
+        self.postproc_workers.append(worker)
+
+    def _create_producer_worker(self) -> None:
+        """Create single producer worker."""
+        worker = ProducerWorker(
+            worker_id=0,
+            output_queue=self.output_queue,
+            camera_configs=self.camera_configs,
+            message_timeout=self.message_timeout
+        )
+        self.producer_workers.append(worker)
     
-    async def _create_camera_workers(self, camera_config: CameraConfig):
+    async def _create_camera_workers(self, camera_config: CameraConfig) -> None:
         """Create consumer workers for a specific camera."""
         camera_id = camera_config.camera_id
-        
-        # Create consumer workers for this camera - each worker will create its own stream
-        camera_workers = []
-        for i in range(self.consumer_threads):
-            worker = ConsumerWorker(
-                camera_id=camera_id,
-                worker_id=i,
-                stream_config=camera_config.stream_config,
-                input_topic=camera_config.input_topic,
-                inference_queue=self.inference_queue,
-                message_timeout=self.message_timeout,
-                camera_config=camera_config
-            )
-            camera_workers.append(worker)
-        
-        self.consumer_workers[camera_id] = camera_workers
+
+        worker = ConsumerWorker(
+            camera_id=camera_id,
+            worker_id=0,
+            stream_config=camera_config.stream_config,
+            input_topic=camera_config.input_topic,
+            inference_queue=self.inference_queue,
+            message_timeout=self.message_timeout,
+            camera_config=camera_config,
+            frame_cache=self.frame_cache
+        )
+
+        self.consumer_workers[camera_id] = [worker]
     
-    def _start_workers(self):
-        """Start all worker instances."""
-        # Start consumer workers
+    def _start_workers(self) -> None:
+        """Start all worker instances and track their threads."""
+        self._start_all_camera_workers()
+        self._start_worker_group(self.inference_workers)
+        self._start_worker_group(self.postproc_workers)
+        self._start_worker_group(self.producer_workers)
+
+    def _start_all_camera_workers(self) -> None:
+        """Start consumer workers for all cameras."""
         for camera_id in self.consumer_workers:
             self._start_camera_workers(camera_id)
-        
-        # Start inference workers
-        for worker in self.inference_workers:
-            thread = worker.start()
-            self.worker_threads.append(thread)
-        
-        # Start post-processing workers
-        for worker in self.postproc_workers:
-            thread = worker.start()
-            self.worker_threads.append(thread)
-        
-        # Start producer workers
-        for worker in self.producer_workers:
+
+    def _start_worker_group(self, workers: List) -> None:
+        """Start a group of workers and track their threads."""
+        for worker in workers:
             thread = worker.start()
             self.worker_threads.append(thread)
     
-    def _start_camera_workers(self, camera_id: str):
+    def _start_camera_workers(self, camera_id: str) -> None:
         """Start consumer workers for a specific camera."""
         if camera_id in self.consumer_workers:
-            for worker in self.consumer_workers[camera_id]:
-                thread = worker.start()
-                self.worker_threads.append(thread)
+            self._start_worker_group(self.consumer_workers[camera_id])
     
-    def _stop_workers(self):
-        """Stop all worker instances."""
-        # Stop all workers
+    def _stop_workers(self) -> None:
+        """Stop all worker instances gracefully."""
+        self._stop_all_camera_workers()
+        self._stop_worker_group(self.inference_workers)
+        self._stop_worker_group(self.postproc_workers)
+        self._stop_worker_group(self.producer_workers)
+
+    def _stop_all_camera_workers(self) -> None:
+        """Stop all camera consumer workers."""
         for workers in self.consumer_workers.values():
-            for worker in workers:
-                worker.stop()
-        
-        for worker in (self.inference_workers + self.postproc_workers + self.producer_workers):
+            self._stop_worker_group(workers)
+
+    def _stop_worker_group(self, workers: List) -> None:
+        """Stop a group of workers."""
+        for worker in workers:
             worker.stop()
     
-    async def _stop_camera_workers(self, camera_id: str):
+    async def _stop_camera_workers(self, camera_id: str) -> None:
         """Stop consumer workers for a specific camera."""
         if camera_id in self.consumer_workers:
-            for worker in self.consumer_workers[camera_id]:
-                worker.stop()
-            # Remove from tracking
+            self._stop_worker_group(self.consumer_workers[camera_id])
             del self.consumer_workers[camera_id]
     
     def get_metrics(self) -> Dict[str, Any]:
-        """Get pipeline metrics."""
-        return {
+        """Get pipeline metrics including frame cache statistics."""
+        metrics = {
             "running": self.running,
             "camera_count": len(self.camera_configs),
             "enabled_cameras": sum(1 for config in self.camera_configs.values() if config.enabled),
@@ -434,10 +373,6 @@ class StreamingPipeline:
                 "total_threads": len(self.worker_threads),
                 "active_threads": len([t for t in self.worker_threads if t.is_alive()]),
             },
-            "thread_pool_sizes": {
-                "inference_threads": self.inference_threads,
-                "postprocessing_threads": self.postprocessing_threads,
-            },
             "camera_configs": {
                 camera_id: {
                     "input_topic": config.input_topic,
@@ -448,4 +383,53 @@ class StreamingPipeline:
                 for camera_id, config in self.camera_configs.items()
             }
         }
+        
+        # Add frame cache metrics if available
+        if self.frame_cache:
+            try:
+                metrics["frame_cache"] = self.frame_cache.get_metrics()
+            except Exception as e:
+                self.logger.warning(f"Failed to get frame cache metrics: {e}")
+                metrics["frame_cache"] = {"error": str(e)}
+        else:
+            metrics["frame_cache"] = {"enabled": False}
+        
+        return metrics
 
+    def _initialize_frame_cache(self) -> None:
+        """Initialize RedisFrameCache with TTL 10 minutes, deriving connection from Redis cameras if available."""
+        try:
+            # Find a Redis camera config for connection params
+            host = "localhost"
+            port = 6379
+            password = None
+            username = None
+            db = 0
+
+            for cfg in self.camera_configs.values():
+                sc = cfg.stream_config or {}
+                st = sc.get("stream_type", "kafka").lower()
+                if st == "redis":
+                    host = sc.get("host", host)
+                    port = sc.get("port", port)
+                    password = sc.get("password", password)
+                    username = sc.get("username", username)
+                    db = sc.get("db", db)
+                    break
+
+            # Lazy import to avoid dependency issues if not used
+            from matrice_inference.server.stream.frame_cache import RedisFrameCache
+            self.frame_cache = RedisFrameCache(
+                host=host,
+                port=port,
+                db=db,
+                password=password,
+                username=username,
+                ttl_seconds=600,  # 10 minutes
+                worker_threads=1,  # conservative to avoid contention
+            )
+            self.frame_cache.start()
+            self.logger.info("Initialized RedisFrameCache with 10-minute TTL")
+        except Exception as e:
+            self.frame_cache = None
+            self.logger.warning(f"Frame cache initialization failed; proceeding without cache: {e}")

matrice_inference/tmp/aggregator/analytics.py

@@ -73,7 +73,7 @@ class AnalyticsSummarizer:
         #           application_key_name: {
         #               "meta": {name, key_name, version},
         #               "last_input_timestamp": str,
-        #               "earliest_reset_timestamp": str | None,
+        #               "earliest_reset_timestamp": str or None,
         #               "current_counts": {category: last_value},
         #               "total_counts": {category: max_value}
         #           }

matrice_inference/tmp/overall_inference_testing.py

@@ -10,10 +10,6 @@ from triton_model_manager import TritonModelManager
 import GPUtil
 import pytz
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-)
 logger = logging.getLogger(__name__)
 
 COCO_CLASSES = [

{matrice_inference-0.1.2.dist-info → matrice_inference-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_inference
-Version: 0.1.2
+Version: 0.1.23
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT