matrice-analytics 0.1.34__py3-none-any.whl → 0.1.36__py3-none-any.whl

matrice_analytics/post_processing/post_processor.py

@@ -711,7 +711,8 @@ class PostProcessor:
         
         # Async use cases
         async_use_cases = {
-            FaceRecognitionEmbeddingUseCase
+            FaceRecognitionEmbeddingUseCase,
+            LicensePlateMonitorUseCase
         }
         
         # Determine the appropriate method signature and call

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -25,6 +25,7 @@ import numpy as np
 import re
 from collections import Counter, defaultdict
 import sys
+import subprocess
 import logging
 import asyncio
 import urllib
@@ -37,33 +38,96 @@ print(f"Python version: {major_version}.{minor_version}")
 os.environ["ORT_LOG_SEVERITY_LEVEL"] = "3"
 
 
-# Try to import LicensePlateRecognizer from local repo first, then installed package
+# Lazy import mechanism for LicensePlateRecognizer
 _OCR_IMPORT_SOURCE = None
-try:
-    from ..ocr.fast_plate_ocr_py38 import LicensePlateRecognizer
-    _OCR_IMPORT_SOURCE = "local_repo"
-except ImportError:
+_LicensePlateRecognizerClass = None
+
+def _get_license_plate_recognizer_class():
+    """Lazy load LicensePlateRecognizer with automatic installation fallback."""
+    global _OCR_IMPORT_SOURCE, _LicensePlateRecognizerClass
+    
+    if _LicensePlateRecognizerClass is not None:
+        return _LicensePlateRecognizerClass
+    
+    # Try to import from local repo first
+    try:
+        from ..ocr.fast_plate_ocr_py38 import LicensePlateRecognizer
+        _OCR_IMPORT_SOURCE = "local_repo"
+        _LicensePlateRecognizerClass = LicensePlateRecognizer
+        logging.info("Successfully imported LicensePlateRecognizer from local repo")
+        return _LicensePlateRecognizerClass
+    except ImportError as e:
+        logging.debug(f"Could not import from local repo: {e}")
+    
+    # Try to import from installed package
     try:
         from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
         _OCR_IMPORT_SOURCE = "installed_package"
-    except ImportError:
-        # Use stub class if neither import works
-        _OCR_IMPORT_SOURCE = "stub"
-        class LicensePlateRecognizer:  # type: ignore
-            """Stub fallback when fast_plate_ocr is not available."""
-            def __init__(self, *args, **kwargs):
-                pass  # Silent stub - error will be logged once during initialization
+        _LicensePlateRecognizerClass = LicensePlateRecognizer
+        logging.info("Successfully imported LicensePlateRecognizer from installed package")
+        return _LicensePlateRecognizerClass
+    except ImportError as e:
+        logging.warning(f"Could not import from installed package: {e}")
+    
+    # Try to install with GPU support first
+    logging.info("Attempting to install fast-plate-ocr with GPU support...")
+    try:
+        import subprocess
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "fast-plate-ocr[onnx-gpu]", "--no-cache-dir"],
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        if result.returncode == 0:
+            logging.info("Successfully installed fast-plate-ocr[onnx-gpu]")
+            try:
+                from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
+                _OCR_IMPORT_SOURCE = "installed_package_gpu"
+                _LicensePlateRecognizerClass = LicensePlateRecognizer
+                logging.info("Successfully imported LicensePlateRecognizer after GPU installation")
+                return _LicensePlateRecognizerClass
+            except ImportError as e:
+                logging.warning(f"Installation succeeded but import failed: {e}")
+        else:
+            logging.warning(f"GPU installation failed: {result.stderr}")
+    except Exception as e:
+        logging.warning(f"Error during GPU installation: {e}")
+    
+    # Try to install with CPU support as fallback
+    logging.info("Attempting to install fast-plate-ocr with CPU support...")
+    try:
+        import subprocess
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "fast-plate-ocr[onnx]", "--no-cache-dir"],
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        if result.returncode == 0:
+            logging.info("Successfully installed fast-plate-ocr[onnx]")
+            try:
+                from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
+                _OCR_IMPORT_SOURCE = "installed_package_cpu"
+                _LicensePlateRecognizerClass = LicensePlateRecognizer
+                logging.info("Successfully imported LicensePlateRecognizer after CPU installation")
+                return _LicensePlateRecognizerClass
+            except ImportError as e:
+                logging.error(f"Installation succeeded but import failed: {e}")
+        else:
+            logging.error(f"CPU installation failed: {result.stderr}")
+    except Exception as e:
+        logging.error(f"Error during CPU installation: {e}")
+    
+    # Return None if all attempts failed
+    logging.error("All attempts to load or install LicensePlateRecognizer failed")
+    _OCR_IMPORT_SOURCE = "unavailable"
+    return None
 
 # Internal utilities that are still required
 from ..ocr.preprocessing import ImagePreprocessor
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
-# (Catch import errors early in the logs)
-try:
-    _ = LicensePlateRecognizer  # noqa: B018 – reference to quiet linters
-except Exception as _e:
-    print(f"Warning: fast_plate_ocr could not be imported ⇒ {_e}")
-
 try:
     from  matrice_common.session import Session
     HAS_MATRICE_SESSION = True
@@ -123,60 +187,91 @@ class LicensePlateMonitorLogger:
 
     def initialize_session(self, config: LicensePlateMonitorConfig) -> None:
         """Initialize session and fetch server connection info if lpr_server_id is provided."""
-        self.logger.info("Initializing LicensePlateMonitorLogger session...")
+        print("[LP_LOGGING] ===== INITIALIZING LP LOGGER SESSION =====")
+        print(f"[LP_LOGGING] Config lpr_server_id: {config.lpr_server_id}")
+        self.logger.info("[LP_LOGGING] ===== INITIALIZING LP LOGGER SESSION =====")
+        self.logger.info(f"[LP_LOGGING] Config lpr_server_id: {config.lpr_server_id}")
         
         # Use existing session if provided, otherwise create new one
-        if self.session:
-            self.logger.info("Session already initialized, skipping initialization")
+        if self.session and self.server_info and self.server_base_url:
+            self.logger.info("[LP_LOGGING] Session already initialized with server info, skipping re-initialization")
+            self.logger.info(f"[LP_LOGGING] Using existing server: {self.server_base_url}")
             return
+        elif self.session:
+            self.logger.info("[LP_LOGGING] Session exists but server info missing, continuing initialization...")
+        else:
+            self.logger.info("[LP_LOGGING] No existing session, initializing from scratch...")
+        
         if config.session:
             self.session = config.session
-            self.logger.info("Using provided session from config")
+            self.logger.info("[LP_LOGGING]  Using provided session from config")
+        
         if not self.session:
             # Initialize Matrice session
             if not HAS_MATRICE_SESSION:
-                self.logger.error("Matrice session module not available")
+                self.logger.error("[LP_LOGGING]  Matrice session module not available")
                 raise ImportError("Matrice session is required for License Plate Monitoring")
             try:
-                self.logger.info("Creating new Matrice session...")
+                self.logger.info("[LP_LOGGING] Creating new Matrice session from environment variables...")
+                account_number = os.getenv("MATRICE_ACCOUNT_NUMBER", "")
+                access_key_id = os.getenv("MATRICE_ACCESS_KEY_ID", "")
+                secret_key = os.getenv("MATRICE_SECRET_ACCESS_KEY", "")
+                project_id = os.getenv("MATRICE_PROJECT_ID", "")
+                
+                self.logger.info(f"[LP_LOGGING] Account Number: {'SET' if account_number else 'NOT SET'}")
+                self.logger.info(f"[LP_LOGGING] Access Key ID: {'SET' if access_key_id else 'NOT SET'}")
+                self.logger.info(f"[LP_LOGGING] Secret Key: {'SET' if secret_key else 'NOT SET'}")
+                self.logger.info(f"[LP_LOGGING] Project ID: {'SET' if project_id else 'NOT SET'}")
+                
                 self.session = Session(
-                    account_number=os.getenv("MATRICE_ACCOUNT_NUMBER", ""),
-                    access_key=os.getenv("MATRICE_ACCESS_KEY_ID", ""),
-                    secret_key=os.getenv("MATRICE_SECRET_ACCESS_KEY", ""),
-                    project_id=os.getenv("MATRICE_PROJECT_ID", ""),
+                    account_number=account_number,
+                    access_key=access_key_id,
+                    secret_key=secret_key,
+                    project_id=project_id,
                 )
-                self.logger.info("Successfully initialized new Matrice session for License Plate Monitoring")
+                self.logger.info("[LP_LOGGING]  Successfully initialized new Matrice session")
             except Exception as e:
-                self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
+                self.logger.error(f"[LP_LOGGING]  Failed to initialize Matrice session: {e}", exc_info=True)
                 raise
         
         # Fetch server connection info if lpr_server_id is provided
         if config.lpr_server_id:
             self.lpr_server_id = config.lpr_server_id
-            self.logger.info(f"Fetching LPR server connection info for server ID: {self.lpr_server_id}")
+            self.logger.info(f"[LP_LOGGING] Fetching LPR server connection info for server ID: {self.lpr_server_id}")
             try:
                 self.server_info = self.get_server_connection_info()
                 if self.server_info:
-                    self.logger.info(f"Successfully fetched LPR server info: {self.server_info.get('name', 'Unknown')}")
+                    self.logger.info(f"[LP_LOGGING]  Successfully fetched LPR server info")
+                    self.logger.info(f"[LP_LOGGING]   - Name: {self.server_info.get('name', 'Unknown')}")
+                    self.logger.info(f"[LP_LOGGING]   - Host: {self.server_info.get('host', 'Unknown')}")
+                    self.logger.info(f"[LP_LOGGING]   - Port: {self.server_info.get('port', 'Unknown')}")
+                    self.logger.info(f"[LP_LOGGING]   - Status: {self.server_info.get('status', 'Unknown')}")
+                    self.logger.info(f"[LP_LOGGING]   - Project ID: {self.server_info.get('projectID', 'Unknown')}")
+                    
                     # Compare server host with public IP to determine if it's localhost
                     server_host = self.server_info.get('host', 'localhost')
                     server_port = self.server_info.get('port', 8200)
                     
                     if server_host == self.public_ip:
                         self.server_base_url = f"http://localhost:{server_port}"
-                        self.logger.info(f"Server host matches public IP ({self.public_ip}), using localhost: {self.server_base_url}")
+                        self.logger.info(f"[LP_LOGGING] Server host matches public IP ({self.public_ip}), using localhost: {self.server_base_url}")
                     else:
-                        self.server_base_url = f"https://{server_host}:{server_port}"
-                        self.logger.info(f"LPR server base URL configured: {self.server_base_url}")
+                        self.server_base_url = f"http://{server_host}:{server_port}"
+                        self.logger.info(f"[LP_LOGGING] LPR server base URL configured: {self.server_base_url}")
                         
                     self.session.update(self.server_info.get('projectID', ''))
-                    self.logger.info(f"Updated Matrice session with project ID: {self.server_info.get('projectID', '')}")
+                    self.logger.info(f"[LP_LOGGING]  Updated Matrice session with project ID: {self.server_info.get('projectID', '')}")
                 else:
-                    self.logger.warning("Failed to fetch LPR server connection info - server_info is None")
+                    self.logger.error("[LP_LOGGING]  Failed to fetch LPR server connection info - server_info is None")
+                    self.logger.error("[LP_LOGGING] This will prevent plate logging from working!")
             except Exception as e:
-                self.logger.error(f"Error fetching LPR server connection info: {e}", exc_info=True)
+                self.logger.error(f"[LP_LOGGING]  Error fetching LPR server connection info: {e}", exc_info=True)
+                self.logger.error("[LP_LOGGING] This will prevent plate logging from working!")
         else:
-            self.logger.info("No lpr_server_id provided in config, skipping server connection info fetch")
+            self.logger.warning("[LP_LOGGING] No lpr_server_id provided in config, skipping server connection info fetch")
+        
+        print("[LP_LOGGING] ===== LP LOGGER SESSION INITIALIZATION COMPLETE =====")
+        self.logger.info("[LP_LOGGING] ===== LP LOGGER SESSION INITIALIZATION COMPLETE =====")
     
     def _get_public_ip(self) -> str:
         """Get the public IP address of this machine."""
@@ -233,10 +328,12 @@ class LicensePlateMonitorLogger:
         time_since_last_log = current_time - last_log_time
         
         if time_since_last_log >= cooldown:
-            self.logger.debug(f"Plate {plate_text} ready to log (last logged {time_since_last_log:.1f}s ago, cooldown={cooldown}s)")
+            print(f"[LP_LOGGING] ✓ Plate '{plate_text}' ready to log ({time_since_last_log:.1f}s since last)")
+            self.logger.info(f"[LP_LOGGING] OK - Plate '{plate_text}' ready to log (last logged {time_since_last_log:.1f}s ago, cooldown={cooldown}s)")
             return True
         else:
-            self.logger.debug(f"Plate {plate_text} in cooldown period ({time_since_last_log:.1f}s elapsed, {cooldown - time_since_last_log:.1f}s remaining)")
+            print(f"[LP_LOGGING] ⊗ Plate '{plate_text}' in cooldown ({cooldown - time_since_last_log:.1f}s remaining)")
+            self.logger.info(f"[LP_LOGGING] SKIP - Plate '{plate_text}' in cooldown period ({time_since_last_log:.1f}s elapsed, {cooldown - time_since_last_log:.1f}s remaining)")
             return False
     
     def update_log_timestamp(self, plate_text: str) -> None:
@@ -297,11 +394,16 @@ class LicensePlateMonitorLogger:
             image_data: Base64-encoded JPEG image of the license plate crop
             cooldown: Cooldown period in seconds
         """
-        self.logger.info(f"Attempting to log plate: {plate_text} at {timestamp}")
+        print(f"[LP_LOGGING] ===== PLATE LOG REQUEST START =====")
+        print(f"[LP_LOGGING] Plate: '{plate_text}', Timestamp: {timestamp}")
+        self.logger.info(f"[LP_LOGGING] ===== PLATE LOG REQUEST START =====")
+        self.logger.info(f"[LP_LOGGING] Plate: '{plate_text}', Timestamp: {timestamp}")
         
         # Check cooldown
         if not self.should_log_plate(plate_text, cooldown):
-            self.logger.info(f"Plate {plate_text} NOT SENT - skipped due to cooldown period")
+            print(f"[LP_LOGGING] Plate '{plate_text}' NOT SENT - cooldown")
+            self.logger.info(f"[LP_LOGGING]  Plate '{plate_text}' NOT SENT - skipped due to cooldown period")
+            self.logger.info(f"[LP_LOGGING] ===== PLATE LOG REQUEST END (SKIPPED) =====")
             return False
         
         try:
@@ -310,11 +412,16 @@ class LicensePlateMonitorLogger:
             location = camera_info.get("location", "")
             frame_id = stream_info.get("frame_id", "")
             
+            print(f"[LP_LOGGING] Camera: '{camera_name}', Location: '{location}'")
+            self.logger.info(f"[LP_LOGGING] Stream Info - Camera: '{camera_name}', Location: '{location}', Frame ID: '{frame_id}'")
+            
             # Get project ID from server_info
             project_id = self.server_info.get('projectID', '') if self.server_info else ''
+            self.logger.info(f"[LP_LOGGING] Project ID: '{project_id}'")
             
             # Format timestamp to RFC3339 format (2006-01-02T15:04:05Z)
             rfc3339_timestamp = self._format_timestamp_rfc3339(timestamp)
+            self.logger.info(f"[LP_LOGGING] Formatted timestamp: {timestamp} -> {rfc3339_timestamp}")
             
             payload = {
                 'licensePlate': plate_text,
@@ -328,19 +435,27 @@ class LicensePlateMonitorLogger:
             
             # Add projectId as query parameter
             endpoint = f'/v1/lpr-server/detections?projectId={project_id}'
-            self.logger.info(f"Sending POST request to {self.server_base_url}{endpoint} with plate: {plate_text}, imageData length: {len(image_data) if image_data else 0}")
+            full_url = f"{self.server_base_url}{endpoint}"
+            print(f"[LP_LOGGING] Sending POST to: {full_url}")
+            self.logger.info(f"[LP_LOGGING] Sending POST request to: {full_url}")
+            self.logger.info(f"[LP_LOGGING] Payload: licensePlate='{plate_text}', frameId='{frame_id}', location='{location}', camera='{camera_name}', imageData length={len(image_data) if image_data else 0}")
             
             response = await self.session.rpc.post_async(endpoint, payload=payload, base_url=self.server_base_url)
             
-            self.logger.info(f"API Response received for plate {plate_text}: {response}")
+            print(f"[LP_LOGGING] Response: {response}")
+            self.logger.info(f"[LP_LOGGING]  API Response received: {response}")
             
             # Update timestamp after successful log
             self.update_log_timestamp(plate_text)
-            self.logger.info(f"Plate {plate_text} SUCCESSFULLY SENT and logged at {rfc3339_timestamp}")
+            print(f"[LP_LOGGING] ✓ Plate '{plate_text}' SUCCESSFULLY SENT")
+            self.logger.info(f"[LP_LOGGING]  Plate '{plate_text}' SUCCESSFULLY SENT at {rfc3339_timestamp}")
+            self.logger.info(f"[LP_LOGGING] ===== PLATE LOG REQUEST END (SUCCESS) =====")
             return True
             
         except Exception as e:
-            self.logger.error(f"Plate {plate_text} NOT SENT - Failed to log: {e}", exc_info=True)
+            print(f"[LP_LOGGING] ✗ Plate '{plate_text}' FAILED - {e}")
+            self.logger.error(f"[LP_LOGGING]  Plate '{plate_text}' NOT SENT - Exception occurred: {e}", exc_info=True)
+            self.logger.info(f"[LP_LOGGING] ===== PLATE LOG REQUEST END (FAILED) =====")
             return False
         
 class LicensePlateMonitorUseCase(BaseProcessor):
@@ -382,23 +497,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         # Map of track_id -> current dominant plate text
         self.unique_plate_track: Dict[Any, str] = {}
         self.image_preprocessor = ImagePreprocessor()
-        # Fast OCR model (shared across instances)
-        if LicensePlateMonitorUseCase._ocr_model is None:
-            if _OCR_IMPORT_SOURCE == "stub":
-                # Using stub - log warning once
-                self.logger.error("OCR module not available. LicensePlateRecognizer will not function. Install: pip install fast-plate-ocr[onnx]")
-                LicensePlateMonitorUseCase._ocr_model = LicensePlateRecognizer('cct-s-v1-global-model')
-            else:
-                # Try to load real OCR model
-                try:
-                    LicensePlateMonitorUseCase._ocr_model = LicensePlateRecognizer('cct-s-v1-global-model')
-                    source_msg = "from local repo" if _OCR_IMPORT_SOURCE == "local_repo" else "from installed package"
-                    self.logger.info(f"LicensePlateRecognizer loaded successfully {source_msg}")
-                except Exception as e:
-                    self.logger.error(f"Failed to initialize LicensePlateRecognizer: {e}", exc_info=True)
-                    LicensePlateMonitorUseCase._ocr_model = None
-        self.ocr_model = LicensePlateMonitorUseCase._ocr_model
-        # OCR text history for stability checks (text → consecutive frame count)
+        # OCR model will be lazily initialized when first used
+        self.ocr_model = None
+        self._ocr_initialization_attempted = False
+        # OCR text history for stability checks (text  consecutive frame count)
         self._text_history: Dict[str, int] = {}
 
         self.start_timer = None
@@ -415,6 +517,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         # Initialize plate logger (optional, only used if lpr_server_id is provided)
         self.plate_logger: Optional[LicensePlateMonitorLogger] = None
         self._logging_enabled = True
+        self._plate_logger_initialized = False  # Track if plate logger has been initialized
         
 
     def reset_tracker(self) -> None:
@@ -442,30 +545,62 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.reset_plate_tracking()
         self.logger.info("All plate tracking state reset")
     
-    def _initialize_plate_logger(self, config: LicensePlateMonitorConfig) -> None:
-        """Initialize the plate logger if lpr_server_id is provided."""
+    def _initialize_plate_logger(self, config: LicensePlateMonitorConfig) -> bool:
+        """Initialize the plate logger if lpr_server_id is provided. Returns True if successful."""
+        self.logger.info(f"[LP_LOGGING] _initialize_plate_logger called with lpr_server_id: {config.lpr_server_id}")
+        
         if not config.lpr_server_id:
             self._logging_enabled = False
-            self.logger.info("Plate logging disabled: no lpr_server_id provided")
-            return
+            self._plate_logger_initialized = False
+            self.logger.warning("[LP_LOGGING] Plate logging disabled: no lpr_server_id provided")
+            return False
         
         try:
             if self.plate_logger is None:
+                self.logger.info("[LP_LOGGING] Creating new LicensePlateMonitorLogger instance")
                 self.plate_logger = LicensePlateMonitorLogger()
+            else:
+                self.logger.info("[LP_LOGGING] Using existing LicensePlateMonitorLogger instance")
             
+            self.logger.info("[LP_LOGGING] Initializing session for plate logger")
             self.plate_logger.initialize_session(config)
             self._logging_enabled = True
-            self.logger.info(f"Plate logging enabled with server ID: {config.lpr_server_id}")
+            self._plate_logger_initialized = True
+            self.logger.info(f"[LP_LOGGING] SUCCESS - Plate logging ENABLED with server ID: {config.lpr_server_id}")
+            return True
         except Exception as e:
-            self.logger.error(f"Failed to initialize plate logger: {e}", exc_info=True)
+            self.logger.error(f"[LP_LOGGING] ERROR - Failed to initialize plate logger: {e}", exc_info=True)
             self._logging_enabled = False
+            self._plate_logger_initialized = False
+            self.logger.error(f"[LP_LOGGING] Plate logging has been DISABLED due to initialization failure")
+            return False
     
-    def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
+    async def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
                             stream_info: Optional[Dict[str, Any]], image_bytes: Optional[bytes] = None) -> None:
         """Log all detected plates to RPC server with cooldown."""
-        if not self._logging_enabled or not self.plate_logger or not stream_info:
+        # Enhanced logging for diagnostics
+        print(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
+        self.logger.info(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
+        self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}, Stream info exists: {stream_info is not None}")
+        
+        if not self._logging_enabled:
+            print("[LP_LOGGING] Plate logging is DISABLED")
+            self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")
             return
         
+        if not self.plate_logger:
+            print("[LP_LOGGING] Plate logging SKIPPED - plate_logger not initialized")
+            self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - plate_logger is not initialized (lpr_server_id may not be configured)")
+            return
+        
+        if not stream_info:
+            print("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
+            self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
+            return
+        
+        print("[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
+        self.logger.info(f"[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
+        
         # Get current timestamp
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
         
@@ -483,44 +618,65 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                     if success:
                         # Convert to base64
                         image_data = base64.b64encode(jpeg_buffer.tobytes()).decode('utf-8')
-                        self.logger.debug(f"Encoded frame image as base64, length: {len(image_data)}")
+                        self.logger.info(f"[LP_LOGGING] Encoded frame image as base64, length: {len(image_data)}")
+                    else:
+                        self.logger.warning(f"[LP_LOGGING] Failed to encode JPEG image")
+                else:
+                    self.logger.warning(f"[LP_LOGGING] Failed to decode image bytes")
             except Exception as e:
-                self.logger.error(f"Failed to encode frame image: {e}")
+                self.logger.error(f"[LP_LOGGING] Exception while encoding frame image: {e}", exc_info=True)
+        else:
+            self.logger.info(f"[LP_LOGGING] No image_bytes provided, sending without image")
         
         # Collect all unique plates from current detections
         plates_to_log = set()
+        detections_without_text = 0
         for det in detections:
             plate_text = det.get('plate_text')
             if not plate_text:
+                detections_without_text += 1
                 continue
             plates_to_log.add(plate_text)
         
-        # Log each unique plate (respecting cooldown)
+        print(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
+        self.logger.info(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
+        if detections_without_text > 0:
+            self.logger.warning(f"[LP_LOGGING] {detections_without_text} detections have NO plate_text (OCR may have failed or not run yet)")
+        
+        # Log each unique plate directly with await (respecting cooldown)
         if plates_to_log:
+            print(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
+            self.logger.info(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
             try:
-                # Run async logging tasks
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                try:
-                    tasks = []
-                    for plate_text in plates_to_log:
-                        task = self.plate_logger.log_plate(
+                # Call log_plate directly with await for each plate
+                for plate_text in plates_to_log:
+                    print(f"[LP_LOGGING] Processing plate: {plate_text}")
+                    self.logger.info(f"[LP_LOGGING] Processing plate: {plate_text}")
+                    try:
+                        result = await self.plate_logger.log_plate(
                             plate_text=plate_text,
                             timestamp=current_timestamp,
                             stream_info=stream_info,
                             image_data=image_data,
                             cooldown=config.plate_log_cooldown
                         )
-                        tasks.append(task)
-                    
-                    # Run all logging tasks concurrently
-                    loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
-                finally:
-                    loop.close()
+                        status = "SENT" if result else "SKIPPED (cooldown)"
+                        print(f"[LP_LOGGING] Plate {plate_text}: {status}")
+                        self.logger.info(f"[LP_LOGGING] Plate {plate_text}: {status}")
+                    except Exception as e:
+                        print(f"[LP_LOGGING] ERROR - Plate {plate_text} failed: {e}")
+                        self.logger.error(f"[LP_LOGGING] Plate {plate_text} raised exception: {e}", exc_info=True)
+                
+                print("[LP_LOGGING] Plate logging complete")
+                self.logger.info(f"[LP_LOGGING] Plate logging complete")
             except Exception as e:
-                self.logger.error(f"Error during plate logging: {e}", exc_info=True)
+                print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
+                self.logger.error(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}", exc_info=True)
+        else:
+            print("[LP_LOGGING] No plates to log")
+            self.logger.info(f"[LP_LOGGING] No plates to log (plates_to_log is empty)")
 
-    def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
+    async def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         processing_start = time.time()
         try:
@@ -535,9 +691,19 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 return self.create_error_result("input_bytes (video/image) is required for license plate monitoring",
                                                usecase=self.name, category=self.category, context=context)
             
-            # Initialize plate logger if lpr_server_id is provided (optional flow)
-            if config.lpr_server_id and self._logging_enabled:
-                self._initialize_plate_logger(config)
+            # Initialize plate logger once if lpr_server_id is provided (optional flow)
+            if not self._plate_logger_initialized and config.lpr_server_id:
+                self.logger.info(f"[LP_LOGGING] First-time initialization - lpr_server_id: {config.lpr_server_id}")
+                success = self._initialize_plate_logger(config)
+                if success:
+                    self.logger.info(f"[LP_LOGGING] Plate logger initialized successfully and ready to send plates")
+                else:
+                    self.logger.error(f"[LP_LOGGING] Plate logger initialization FAILED - plates will NOT be sent")
+            elif self._plate_logger_initialized:
+                self.logger.debug(f"[LP_LOGGING] Plate logger already initialized, skipping re-initialization")
+            elif not config.lpr_server_id:
+                if self._total_frame_counter == 0:  # Only log once at start
+                    self.logger.warning(f"[LP_LOGGING] Plate logging will be DISABLED - no lpr_server_id provided in config")
             
             # Normalize alert_config if provided as a plain dict (JS JSON)
             if isinstance(getattr(config, 'alert_config', None), dict):
@@ -546,19 +712,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 except Exception:
                     pass
 
-            # Initialize OCR extractor if not already done
-            if self.ocr_model is None:
-                self.logger.info("Lazy initialisation fallback (should rarely happen)")
-                try:
-                    LicensePlateMonitorUseCase._ocr_model = LicensePlateRecognizer('cct-s-v1-global-model')
-                    self.ocr_model = LicensePlateMonitorUseCase._ocr_model
-                except Exception as e:
-                    return self.create_error_result(
-                        f"Failed to initialise OCR model: {e}",
-                        usecase=self.name,
-                        category=self.category,
-                        context=context,
-                    )
+            # OCR model will be lazily initialized when _run_ocr is first called
+            # No need to initialize here
             
             input_format = match_results_structure(data)
             context.input_format = input_format
@@ -627,16 +782,24 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             #print("---------DATA5--------------",processed_data)
             # Step 8: Perform OCR on media
             ocr_analysis = self._analyze_ocr_in_media(processed_data, input_bytes, config)
-
-            #print("ocr_analysis", ocr_analysis)
+            self.logger.info(f"[LP_LOGGING] OCR analysis completed, found {len(ocr_analysis)} results")
+            ocr_plates_found = [r.get('plate_text') for r in ocr_analysis if r.get('plate_text')]
+            if ocr_plates_found:
+                self.logger.info(f"[LP_LOGGING] OCR detected plates: {ocr_plates_found}")
+            else:
+                self.logger.warning(f"[LP_LOGGING] OCR did not detect any valid plate texts")
             
             # Step 9: Update plate texts
-            #print("---------DATA6--------------",processed_data)
             processed_data = self._update_detections_with_ocr(processed_data, ocr_analysis)
             self._update_plate_texts(processed_data)
             
+            # Log final detection state before sending
+            final_plates = [d.get('plate_text') for d in processed_data if d.get('plate_text')]
+            self.logger.info(f"[LP_LOGGING] After OCR update, {len(final_plates)} detections have plate_text: {final_plates}")
+            
             # Step 9.5: Log detected plates to RPC (optional, only if lpr_server_id is provided)
-            self._log_detected_plates(processed_data, config, stream_info, input_bytes)
+            # Direct await since process is now async
+            await self._log_detected_plates(processed_data, config, stream_info, input_bytes)
             
             # Step 10: Update frame counter
             self._total_frame_counter += 1
@@ -806,6 +969,39 @@ class LicensePlateMonitorUseCase(BaseProcessor):
     # ------------------------------------------------------------------
     # Fast OCR helpers
     # ------------------------------------------------------------------
+    def _ensure_ocr_model_loaded(self) -> bool:
+        """Lazy initialization of OCR model. Returns True if model is available."""
+        if self.ocr_model is not None:
+            return True
+        
+        if self._ocr_initialization_attempted:
+            return False
+        
+        self._ocr_initialization_attempted = True
+        
+        # Try to get the LicensePlateRecognizer class
+        LicensePlateRecognizerClass = _get_license_plate_recognizer_class()
+        
+        if LicensePlateRecognizerClass is None:
+            self.logger.error("OCR module not available. LicensePlateRecognizer will not function.")
+            return False
+        
+        # Try to initialize the OCR model
+        try:
+            self.ocr_model = LicensePlateRecognizerClass('cct-s-v1-global-model')
+            source_msg = {
+                "local_repo": "from local repo",
+                "installed_package": "from installed package",
+                "installed_package_gpu": "from installed package (GPU)",
+                "installed_package_cpu": "from installed package (CPU)"
+            }.get(_OCR_IMPORT_SOURCE, "from unknown source")
+            self.logger.info(f"LicensePlateRecognizer loaded successfully {source_msg}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to initialize LicensePlateRecognizer: {e}", exc_info=True)
+            self.ocr_model = None
+            return False
+    
     def _clean_text(self, text: str) -> str:
         """Sanitise OCR output to keep only alphanumerics and uppercase."""
         if not text:
@@ -814,10 +1010,18 @@ class LicensePlateMonitorUseCase(BaseProcessor):
 
     def _run_ocr(self, crop: np.ndarray) -> str:
         """Run OCR on a cropped plate image and return cleaned text or empty string."""
-        if crop is None or crop.size == 0 or self.ocr_model is None:
+        if crop is None or crop.size == 0:
+            return ""
+        
+        # Lazy load OCR model on first use
+        if not self._ensure_ocr_model_loaded():
+            return ""
+        
+        # Double-check model is available
+        if self.ocr_model is None:
             return ""
         
-        # Check if we have a valid OCR model (not the stub) - silently return empty if stub
+        # Check if we have a valid OCR model with run method
         if not hasattr(self.ocr_model, 'run'):
             return ""
             
@@ -926,7 +1130,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             if not dominant_text:
                 dominant_text = self.unique_plate_track.get(tid)
 
-            # Enforce length 5–6 and uniqueness per frame
+            # Enforce length 56 and uniqueness per frame
             if dominant_text and self._min_plate_len <= len(dominant_text) <= 6:
                 unique_texts.add(dominant_text)
                 valid_detections.append({
@@ -1373,7 +1577,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
 
         The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
+        1. A numeric Unix timestamp (``float`` / ``int``)  it will first be converted to a
            string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
         2. A string already following the same layout.
 

{matrice_analytics-0.1.34.dist-info → matrice_analytics-0.1.36.dist-info}/METADATA

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

{matrice_analytics-0.1.34.dist-info → matrice_analytics-0.1.36.dist-info}/RECORD

@@ -13,7 +13,7 @@ matrice_analytics/boundary_drawing_internal/usage/simple_boundary_launcher.py,sh
 matrice_analytics/post_processing/README.md,sha256=bDszazvqV5xbGhMM6hDaMctIyk5gox9bADo2IZZ9Goo,13368
 matrice_analytics/post_processing/__init__.py,sha256=dxGBUQaRCGndQmXpYAWqUhDeUZAcxU-_6HFnm3GRDRA,29417
 matrice_analytics/post_processing/config.py,sha256=V0s86qNapyDE6Q81ZS_1uzNqAjz-vc5L-9Tb33XaLEo,6771
-matrice_analytics/post_processing/post_processor.py,sha256=ql4WuT1qVusXXYP36PNICQYPgvWOwBBErAb4UBMXlm8,44344
+matrice_analytics/post_processing/post_processor.py,sha256=F838_vc7p9tjcp-vTMgTbpHqQcLX94xhL9HM06Wvpo8,44384
 matrice_analytics/post_processing/advanced_tracker/README.md,sha256=RM8dynVoUWKn_hTbw9c6jHAbnQj-8hEAXnmuRZr2w1M,22485
 matrice_analytics/post_processing/advanced_tracker/__init__.py,sha256=tAPFzI_Yep5TLX60FDwKqBqppc-EbxSr0wNsQ9DGI1o,423
 matrice_analytics/post_processing/advanced_tracker/base.py,sha256=VqWy4dd5th5LK-JfueTt2_GSEoOi5QQfQxjTNhmQoLc,3580
@@ -126,7 +126,7 @@ matrice_analytics/post_processing/usecases/leaf.py,sha256=cwgB1ZNxkQFtkk-thSJrkX
 matrice_analytics/post_processing/usecases/leaf_disease.py,sha256=bkiLccTdf4KUq3he4eCpBlKXb5exr-WBhQ_oWQ7os68,36225
 matrice_analytics/post_processing/usecases/leak_detection.py,sha256=oOCLLVMuXVeXPHyN8FUrD3U9JYJJwIz-5fcEMgvLdls,40531
 matrice_analytics/post_processing/usecases/license_plate_detection.py,sha256=dsavd92-wnyXCNrCzaRj24zH7BVvLSa09HkYsrOXYDM,50806
-matrice_analytics/post_processing/usecases/license_plate_monitoring.py,sha256=UaceT9ieQUjj1WRwtXkqmoNloG1Jc055u2AW2LvM8Eo,76747
+matrice_analytics/post_processing/usecases/license_plate_monitoring.py,sha256=5YvqGwvvocyBZkFgSnCGuvCp4XT_YTrPuO-RHOEjRAk,89336
 matrice_analytics/post_processing/usecases/litter_monitoring.py,sha256=XaHAUGRBDJg_iVbu8hRMjTR-5TqrLj6ZNCRkInbzZTY,33255
 matrice_analytics/post_processing/usecases/mask_detection.py,sha256=L_s6ZiT5zeXG-BsFcskb3HEG98DhLgqeMSDmCuwOteU,41501
 matrice_analytics/post_processing/usecases/natural_disaster.py,sha256=ehxdPBoYcZWGVDOVn_mHFoz4lIE8LrveAkuXQj0n9XE,44253
@@ -188,8 +188,8 @@ matrice_analytics/post_processing/utils/format_utils.py,sha256=UTF7A5h9j0_S12xH9
 matrice_analytics/post_processing/utils/geometry_utils.py,sha256=BWfdM6RsdJTTLR1GqkWfdwpjMEjTCJyuBxA4zVGKdfk,9623
 matrice_analytics/post_processing/utils/smoothing_utils.py,sha256=78U-yucAcjUiZ0NIAc9NOUSIT0PWP1cqyIPA_Fdrjp0,14699
 matrice_analytics/post_processing/utils/tracking_utils.py,sha256=rWxuotnJ3VLMHIBOud2KLcu4yZfDp7hVPWUtNAq_2xw,8288
-matrice_analytics-0.1.34.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_analytics-0.1.34.dist-info/METADATA,sha256=KZrHth0YkNGwzjdc9O36coURdXHAGlfltJbkZ7PEz5Y,14378
-matrice_analytics-0.1.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_analytics-0.1.34.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
-matrice_analytics-0.1.34.dist-info/RECORD,,
+matrice_analytics-0.1.36.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_analytics-0.1.36.dist-info/METADATA,sha256=SOV2XH7crdPmqvOuZmjQvlkrVM0BoWI1fK2K2xmlR64,14378
+matrice_analytics-0.1.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_analytics-0.1.36.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
+matrice_analytics-0.1.36.dist-info/RECORD,,