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

matrice_inference/__init__.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+import platform
 from matrice_common.utils import dependencies_check
 
 base = [
@@ -24,36 +25,52 @@ base = [
     "transformers"
 ]
 
-# Install base dependencies first
-dependencies_check(base)
-
 # Helper to attempt installation and verify importability
 def _install_and_verify(pkg: str, import_name: str):
     """Install a package expression and return True if the import succeeds."""
-    if dependencies_check([pkg]):
-        try:
-            __import__(import_name)
-            return True
-        except ImportError:
-            return False
-    return False
+    try:
+        if pkg=='onnxruntime-gpu':
+            pkg = 'onnxruntime'
+        __import__(pkg)
+        return True
+    except:
+        if dependencies_check([pkg]):
+            try:
+                __import__(import_name)
+                return True
+            except ImportError:
+                return False
+        return False
+
+# Runtime gating for optional OCR bootstrap (default OFF), and never on Jetson
+_ENABLE_OCR_BOOTSTRAP = os.getenv("MATRICE_ENABLE_OCR_BOOTSTRAP", "0")
+_IS_JETSON = (platform.machine().lower() in ("aarch64", "arm64"))
 
-if not dependencies_check(["opencv-python"]):
-    dependencies_check(["opencv-python-headless"])
+print("*******************************Deployment ENV Info**********************************")
+print(f"ENABLE_JETSON_PIP_SETTINGS: {_ENABLE_OCR_BOOTSTRAP}") #0 if OFF, 1 if ON, this will be set to 1 in jetson byom codebase.
+print(f"IS_JETSON_ARCH?: {_IS_JETSON}") #True if Jetson, False otherwise
+print("*************************************************************************************")
 
-# Attempt GPU-specific dependencies first
-_gpu_ok = _install_and_verify("onnxruntime-gpu", "onnxruntime") and _install_and_verify(
-    "fast-plate-ocr[onnx-gpu]", "fast_plate_ocr"
-)
+if not int(_ENABLE_OCR_BOOTSTRAP) and not _IS_JETSON:
+    # Install base dependencies first
+    dependencies_check(base)
 
-if not _gpu_ok:
-    # Fallback to CPU variants
-    _cpu_ok = _install_and_verify("onnxruntime", "onnxruntime") and _install_and_verify(
-        "fast-plate-ocr[onnx]", "fast_plate_ocr"
+    if not dependencies_check(["opencv-python"]):
+        dependencies_check(["opencv-python-headless"])
+
+    # Attempt GPU-specific dependencies first
+    _gpu_ok = _install_and_verify("onnxruntime-gpu", "onnxruntime") and _install_and_verify(
+        "fast-plate-ocr[onnx-gpu]", "fast_plate_ocr"
     )
-    if not _cpu_ok:
-        # Last-chance fallback without extras tag (PyPI sometimes lacks them)
-        _install_and_verify("fast-plate-ocr", "fast_plate_ocr")
+
+    if not _gpu_ok:
+        # Fallback to CPU variants
+        _cpu_ok = _install_and_verify("onnxruntime", "onnxruntime") and _install_and_verify(
+            "fast-plate-ocr[onnx]", "fast_plate_ocr"
+        )
+        if not _cpu_ok:
+            # Last-chance fallback without extras tag (PyPI sometimes lacks them)
+            _install_and_verify("fast-plate-ocr", "fast_plate_ocr")
 
 # matrice_deps = ["matrice_common", "matrice_analytics", "matrice"]
 

matrice_inference/server/__init__.py

@@ -1,23 +1,29 @@
 import os
 import logging
 
-# Root logger
-logging.basicConfig(level=logging.DEBUG)
+# Define paths
+log_path = os.path.join(os.getcwd(), "deploy_server.log")
 
-# Console handler (INFO+)
+# Create handlers explicitly
 console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.INFO)
-
-# File handler (DEBUG+)
-log_path = os.path.join(os.getcwd(), "deploy_server.log")
 file_handler = logging.FileHandler(log_path)
+
+# Set levels
+console_handler.setLevel(logging.INFO)
 file_handler.setLevel(logging.DEBUG)
 
-# Formatter
+# Define a formatter
 formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
 console_handler.setFormatter(formatter)
 file_handler.setFormatter(formatter)
 
-# Add handlers to root logger
-logging.getLogger().addHandler(console_handler)
-logging.getLogger().addHandler(file_handler)
+# Get the root logger
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)  # Root level must be the lowest (DEBUG)
+
+# Optional: remove any default handlers if basicConfig was called earlier
+if logger.hasHandlers():
+    logger.handlers.clear()
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)

matrice_inference/server/model/triton_server.py

@@ -17,8 +17,6 @@ from matrice_common.utils import dependencies_check
 TRITON_DOCKER_IMAGE = "nvcr.io/nvidia/tritonserver:23.08-py3"
 BASE_PATH = "./model_repository"
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-
 class TritonServer:
     def __init__(
         self,
@@ -1161,7 +1159,7 @@ class TritonInference:
         model_alphabet: str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_",
         return_confidence: bool = True,
         confidence_threshold: float = 0.0,  # Disabled threshold to match ONNX
-        ) -> Tuple[list[str], np.ndarray] | list[str]:
+        ) -> Union[Tuple[List[str], np.ndarray], List[str]]:
         """Postprocess OCR model outputs into license plate strings.
 
         Args:

matrice_inference/server/server.py

@@ -131,6 +131,7 @@ class MatriceDeployServer:
             self.streaming_pipeline = None
             self.app_deployment = None
             self.stream_manager = None
+            self.camera_config_monitor = None
 
             # Initialize utilities
             self.utils = None
@@ -320,7 +321,10 @@ class MatriceDeployServer:
             post_processing_config = {}
         if isinstance(post_processing_config, dict):
             post_processing_config["facial_recognition_server_id"] = self.job_params.get("facial_recognition_server_id", None)
+            post_processing_config["lpr_server_id"] = self.job_params.get("lpr_server_id", None)
             post_processing_config["session"] = self.session  # Pass the session to post-processing
+            # Pass deployment_id for facial recognition deployment update
+            post_processing_config["deployment_id"] = self.deployment_id 
         
         # Get index_to_category from action_tracker if available
         index_to_category = None
@@ -374,10 +378,6 @@ class MatriceDeployServer:
             self.streaming_pipeline = StreamingPipeline(
                 inference_interface=self.inference_interface,
                 post_processor=self.post_processor,
-                consumer_threads=self.job_params.get("consumer_threads", 4),
-                producer_threads=self.job_params.get("producer_threads", 2),
-                inference_threads=self.job_params.get("inference_threads", 4),
-                postprocessing_threads=self.job_params.get("postprocessing_threads", 2),
                 inference_queue_maxsize=self.job_params.get("inference_queue_maxsize", 5000),
                 postproc_queue_maxsize=self.job_params.get("postproc_queue_maxsize", 5000),
                 output_queue_maxsize=self.job_params.get("output_queue_maxsize", 5000),
@@ -402,6 +402,9 @@ class MatriceDeployServer:
             
             logging.info("Streaming pipeline initialized successfully")
             
+            # Start camera config monitor if app deployment is available
+            self._start_camera_config_monitor()
+            
         except Exception as e:
             logging.error(f"Failed to initialize streaming pipeline: {str(e)}")
             raise
@@ -416,6 +419,37 @@ class MatriceDeployServer:
         finally:
             loop.close()
 
+    def _start_camera_config_monitor(self):
+        """Start the camera config monitor if app deployment is available."""
+        try:
+            if not self.app_deployment:
+                logging.info("No app deployment configured, skipping camera config monitor")
+                return
+            
+            if not self.streaming_pipeline:
+                logging.warning("Streaming pipeline not initialized, skipping camera config monitor")
+                return
+            
+            # Get check interval from job params (default: 60 seconds)
+            check_interval = self.job_params.get("camera_config_check_interval", 60)
+            
+            # Import and create the monitor
+            from matrice_inference.server.stream.camera_config_monitor import CameraConfigMonitor
+            
+            self.camera_config_monitor = CameraConfigMonitor(
+                app_deployment=self.app_deployment,
+                streaming_pipeline=self.streaming_pipeline,
+                check_interval=check_interval
+            )
+            
+            # Start monitoring
+            self.camera_config_monitor.start()
+            logging.info(f"Camera config monitor started (check interval: {check_interval}s)")
+            
+        except Exception as e:
+            logging.error(f"Failed to start camera config monitor: {str(e)}")
+            # Don't raise - monitor is optional
+
     def _stop_pipeline_in_new_loop(self):
         """Stop the pipeline in a new event loop (for use when already in an event loop)."""
         import asyncio
@@ -463,6 +497,14 @@ class MatriceDeployServer:
             # Signal shutdown to all components
             self._shutdown_event.set()
             
+            # Stop camera config monitor
+            if self.camera_config_monitor:
+                try:
+                    self.camera_config_monitor.stop()
+                    logging.info("Camera config monitor stopped")
+                except Exception as exc:
+                    logging.error("Error stopping camera config monitor: %s", str(exc))
+            
             # Stop streaming pipeline
             if self.streaming_pipeline:
                 try:

matrice_inference/server/stream/camera_config_monitor.py

@@ -0,0 +1,221 @@
+"""Background monitor for camera configuration updates."""
+
+import hashlib
+import json
+import logging
+import threading
+import time
+from typing import Dict, Optional
+
+from matrice_inference.server.stream.utils import CameraConfig
+
+
+class CameraConfigMonitor:
+    """Monitors and syncs camera configurations from app deployment API."""
+
+    DEFAULT_CHECK_INTERVAL = 120  # seconds
+
+    def __init__(
+        self,
+        app_deployment,
+        streaming_pipeline,
+        check_interval: int = DEFAULT_CHECK_INTERVAL
+    ):
+        """Initialize the camera config monitor.
+        
+        Args:
+            app_deployment: AppDeployment instance to fetch configs
+            streaming_pipeline: StreamingPipeline instance to update
+            check_interval: Seconds between config checks
+        """
+        self.app_deployment = app_deployment
+        self.streaming_pipeline = streaming_pipeline
+        self.check_interval = max(10, int(check_interval))  # Minimum 10 seconds
+        self.running = False
+        self.thread: Optional[threading.Thread] = None
+        self.logger = logging.getLogger(__name__)
+        
+        # Track camera configs by hash to detect changes (thread-safe access)
+        self.camera_hashes: Dict[str, str] = {}
+        self._hashes_lock = threading.Lock()
+
+    def start(self) -> None:
+        """Start the background monitoring thread."""
+        if self.running:
+            self.logger.warning("Camera config monitor already running")
+            return
+        
+        self.running = True
+        self.thread = threading.Thread(
+            target=self._monitor_loop,
+            name="CameraConfigMonitor",
+            daemon=False
+        )
+        self.thread.start()
+        self.logger.info(f"Started camera config monitor (check interval: {self.check_interval}s)")
+
+    def stop(self) -> None:
+        """Stop the background monitoring thread."""
+        if not self.running:
+            return
+        
+        self.running = False
+        if self.thread:
+            self.thread.join(timeout=5.0)
+            self.logger.info("Stopped camera config monitor")
+
+    def _monitor_loop(self) -> None:
+        """Main monitoring loop - periodically sync camera configs."""
+        while self.running:
+            try:
+                self._sync_camera_configs()
+            except Exception as e:
+                self.logger.error(f"Error syncing camera configs: {e}")
+            
+            # Sleep in small intervals to allow quick shutdown
+            for _ in range(self.check_interval):
+                if not self.running:
+                    break
+                time.sleep(1)
+
+    def _sync_camera_configs(self) -> None:
+        """Fetch latest configs from API and sync with pipeline."""
+        try:
+            # Fetch current configs from app deployment API
+            latest_configs = self.app_deployment.get_camera_configs()
+            
+            if not latest_configs:
+                self.logger.debug("No camera configs returned from API")
+                return
+            
+            # Process each camera config
+            for camera_id, camera_config in latest_configs.items():
+                self._process_camera_config(camera_id, camera_config)
+            
+            # Optional: Remove cameras that are no longer in API
+            # Uncomment if you want to auto-remove deleted cameras
+            # self._remove_deleted_cameras(latest_configs)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to sync camera configs: {e}")
+
+    def _process_camera_config(self, camera_id: str, camera_config: CameraConfig) -> None:
+        """Process a single camera config - add new or update changed."""
+        try:
+            # Calculate config hash to detect changes
+            config_hash = self._hash_camera_config(camera_config)
+            
+            # Thread-safe read of previous hash
+            with self._hashes_lock:
+                previous_hash = self.camera_hashes.get(camera_id)
+            
+            # Check if this is a new camera or config changed
+            if previous_hash is None:
+                # New camera - add it
+                self._add_new_camera(camera_id, camera_config, config_hash)
+            elif previous_hash != config_hash:
+                # Config changed - update it
+                self._update_changed_camera(camera_id, camera_config, config_hash)
+            else:
+                # No change - skip
+                self.logger.debug(f"Camera {camera_id} config unchanged")
+                
+        except Exception as e:
+            self.logger.error(f"Error processing camera {camera_id}: {e}")
+
+    def _add_new_camera(self, camera_id: str, camera_config: CameraConfig, config_hash: str) -> None:
+        """Add a new camera to the pipeline."""
+        try:
+            # Use asyncio to add camera config
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                success = loop.run_until_complete(
+                    self.streaming_pipeline.add_camera_config(camera_config)
+                )
+                if success:
+                    # Thread-safe write
+                    with self._hashes_lock:
+                        self.camera_hashes[camera_id] = config_hash
+                    self.logger.info(f"Added new camera: {camera_id}")
+                else:
+                    self.logger.warning(f"Failed to add camera: {camera_id}")
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            self.logger.error(f"Error adding camera {camera_id}: {e}")
+
+    def _update_changed_camera(self, camera_id: str, camera_config: CameraConfig, config_hash: str) -> None:
+        """Update an existing camera with changed config."""
+        try:
+            # Use asyncio to update camera config
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                success = loop.run_until_complete(
+                    self.streaming_pipeline.update_camera_config(camera_config)
+                )
+                if success:
+                    # Thread-safe write
+                    with self._hashes_lock:
+                        self.camera_hashes[camera_id] = config_hash
+                    self.logger.info(f"Updated camera config: {camera_id}")
+                else:
+                    self.logger.warning(f"Failed to update camera: {camera_id}")
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            self.logger.error(f"Error updating camera {camera_id}: {e}")
+
+    def _remove_deleted_cameras(self, latest_configs: Dict[str, CameraConfig]) -> None:
+        """Remove cameras that are no longer in the API response."""
+        # Thread-safe read
+        with self._hashes_lock:
+            current_camera_ids = set(self.camera_hashes.keys())
+        
+        latest_camera_ids = set(latest_configs.keys())
+        deleted_camera_ids = current_camera_ids - latest_camera_ids
+        
+        for camera_id in deleted_camera_ids:
+            try:
+                import asyncio
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    success = loop.run_until_complete(
+                        self.streaming_pipeline.remove_camera_config(camera_id)
+                    )
+                    if success:
+                        # Thread-safe delete
+                        with self._hashes_lock:
+                            del self.camera_hashes[camera_id]
+                        self.logger.info(f"Removed deleted camera: {camera_id}")
+                finally:
+                    loop.close()
+            except Exception as e:
+                self.logger.error(f"Error removing camera {camera_id}: {e}")
+
+    def _hash_camera_config(self, camera_config: CameraConfig) -> str:
+        """Generate a hash of the camera config to detect changes."""
+        try:
+            # Create a dict with relevant config fields
+            config_dict = {
+                "camera_id": camera_config.camera_id,
+                "input_topic": camera_config.input_topic,
+                "output_topic": camera_config.output_topic,
+                "stream_config": camera_config.stream_config,
+                "enabled": camera_config.enabled
+            }
+            
+            # Convert to JSON string (sorted for consistency) and hash
+            config_str = json.dumps(config_dict, sort_keys=True)
+            return hashlib.md5(config_str.encode()).hexdigest()
+            
+        except Exception as e:
+            self.logger.error(f"Error hashing camera config: {e}")
+            return ""
+