matrice-analytics 0.1.35__tar.gz → 0.1.37__tar.gz

{matrice_analytics-0.1.35 → matrice_analytics-0.1.37}/PKG-INFO

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

{matrice_analytics-0.1.35 → matrice_analytics-0.1.37}/matrice_analytics.egg-info/PKG-INFO

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

{matrice_analytics-0.1.35 → matrice_analytics-0.1.37}/src/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-0.1.35 → matrice_analytics-0.1.37}/src/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,6 +187,8 @@ class LicensePlateMonitorLogger:
 
     def initialize_session(self, config: LicensePlateMonitorConfig) -> None:
         """Initialize session and fetch server connection info if lpr_server_id is provided."""
+        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}")
         
@@ -204,6 +270,7 @@ class LicensePlateMonitorLogger:
         else:
             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:
@@ -261,9 +328,11 @@ class LicensePlateMonitorLogger:
         time_since_last_log = current_time - last_log_time
         
         if time_since_last_log >= cooldown:
+            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:
+            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
     
@@ -325,11 +394,14 @@ class LicensePlateMonitorLogger:
             image_data: Base64-encoded JPEG image of the license plate crop
             cooldown: Cooldown period in seconds
         """
+        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):
+            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
@@ -340,6 +412,7 @@ 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
@@ -363,20 +436,24 @@ class LicensePlateMonitorLogger:
             # Add projectId as query parameter
             endpoint = f'/v1/lpr-server/detections?projectId={project_id}'
             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)
             
+            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)
+            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:
+            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
@@ -384,13 +461,6 @@ class LicensePlateMonitorLogger:
 class LicensePlateMonitorUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {"license_plate": "license_plate"}
     
-    # --------------------------------------------------------------
-    # Shared resources (initialised once per process)
-    # --------------------------------------------------------------
-    _ocr_model: Optional[LicensePlateRecognizer] = None  # Fast plate OCR
-    
-
-    
     def __init__(self):
         super().__init__("license_plate_monitor")
         self.category = "license_plate_monitor"
@@ -420,22 +490,9 @@ 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 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] = {}
 
@@ -511,25 +568,30 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             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."""
         # 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
@@ -569,49 +631,45 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 continue
             plates_to_log.add(plate_text)
         
+        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 (respecting cooldown)
+        # Log each unique plate directly with await (respecting cooldown)
         if plates_to_log:
-            self.logger.info(f"[LP_LOGGING] Starting async logging for {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
+            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:
-                        self.logger.info(f"[LP_LOGGING] Creating task for plate: {plate_text}")
-                        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
-                    self.logger.info(f"[LP_LOGGING] Executing {len(tasks)} async logging tasks")
-                    results = loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
-                    
-                    # Log results
-                    for i, (plate, result) in enumerate(zip(plates_to_log, results)):
-                        if isinstance(result, Exception):
-                            self.logger.error(f"[LP_LOGGING] Task {i} for plate {plate} raised exception: {result}")
-                        else:
-                            self.logger.info(f"[LP_LOGGING] Task {i} for plate {plate} completed with result: {result}")
-                finally:
-                    loop.close()
-                    self.logger.info(f"[LP_LOGGING] Event loop closed")
+                        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:
+                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:
@@ -647,19 +705,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
@@ -744,7 +791,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             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
@@ -914,6 +962,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:
@@ -922,10 +1003,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 ""