matrice-analytics 0.1.3__py3-none-any.whl → 0.1.32__py3-none-any.whl

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -24,17 +24,34 @@ import numpy as np
 #import torch
 import re
 from collections import Counter, defaultdict
-#from turbojpeg import TurboJPEG, TJPF_RGB
+import sys
+import logging
+import asyncio
+import urllib
+import urllib.request
+# Get the major and minor version numbers
+major_version = sys.version_info.major
+minor_version = sys.version_info.minor
+print(f"Python version: {major_version}.{minor_version}")
 os.environ["ORT_LOG_SEVERITY_LEVEL"] = "3"
-# Fast license-plate OCR (replaces EasyOCR)
-# Attempt to import fast_plate_ocr; fall back to a stub if unavailable
+
+
+# Try to import LicensePlateRecognizer from local repo first, then installed package
+_OCR_IMPORT_SOURCE = None
 try:
-    from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
-except:  # pragma: no cover – optional dependency may be absent
-    class LicensePlateRecognizer:  # type: ignore
-        """Stub fallback when fast_plate_ocr is not installed."""
-        def __init__(self, *args, **kwargs):
-            print("fast_plate_ocr is required for LicensePlateMonitorUseCase but is not installed.")
+    from ..ocr.fast_plate_ocr_py38 import LicensePlateRecognizer
+    _OCR_IMPORT_SOURCE = "local_repo"
+except ImportError:
+    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
 
 # Internal utilities that are still required
 from ..ocr.preprocessing import ImagePreprocessor
@@ -46,6 +63,12 @@ try:
 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
+except ImportError:
+    HAS_MATRICE_SESSION = False
+    logging.warning("Matrice session not available")
 
 @dataclass
 class LicensePlateMonitorConfig(BaseConfig):
@@ -66,7 +89,10 @@ class LicensePlateMonitorConfig(BaseConfig):
     language: List[str] = field(default_factory=lambda: ['en'])
     country: str = field(default_factory=lambda: 'us')
     ocr_mode:str = field(default_factory=lambda: "numeric") # "alphanumeric" or "numeric" or "alphabetic"
-
+    session: Optional[Session] = None
+    lpr_server_id: Optional[str] = None  # Optional LPR server ID for remote logging
+    plate_log_cooldown: float = 30.0  # Cooldown period in seconds for logging same plate
+    
     def validate(self) -> List[str]:
         """Validate configuration parameters."""
         errors = super().validate()
@@ -84,6 +110,228 @@ class LicensePlateMonitorConfig(BaseConfig):
             errors.append("smoothing_confidence_range_factor must be positive")
         return errors
 
+class LicensePlateMonitorLogger:
+    def __init__(self):
+        self.session = None
+        self.logger = logging.getLogger(__name__)
+        self.lpr_server_id = None
+        self.server_info = None
+        self.plate_log_timestamps: Dict[str, float] = {}  # Track last log time per plate
+        self.server_base_url = None
+        self.public_ip = self._get_public_ip()
+
+    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...")
+        
+        # Use existing session if provided, otherwise create new one
+        if self.session:
+            self.logger.info("Session already initialized, skipping initialization")
+            return
+        if config.session:
+            self.session = config.session
+            self.logger.info("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")
+                raise ImportError("Matrice session is required for License Plate Monitoring")
+            try:
+                self.logger.info("Creating new Matrice session...")
+                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", ""),
+                )
+                self.logger.info("Successfully initialized new Matrice session for License Plate Monitoring")
+            except Exception as e:
+                self.logger.error(f"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}")
+            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')}")
+                    # 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}")
+                    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.session.update(self.server_info.get('projectID', ''))
+                    self.logger.info(f"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")
+            except Exception as e:
+                self.logger.error(f"Error fetching LPR server connection info: {e}", exc_info=True)
+        else:
+            self.logger.info("No lpr_server_id provided in config, skipping server connection info fetch")
+    
+    def _get_public_ip(self) -> str:
+        """Get the public IP address of this machine."""
+        self.logger.info("Fetching public IP address...")
+        try:
+            public_ip = urllib.request.urlopen("https://v4.ident.me", timeout=120).read().decode("utf8").strip()
+            self.logger.info(f"Successfully fetched external IP: {public_ip}")
+            return public_ip
+        except Exception as e:
+            self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
+            return "localhost"
+
+    def get_server_connection_info(self) -> Optional[Dict[str, Any]]:
+        """Fetch server connection info from RPC."""
+        if not self.lpr_server_id:
+            self.logger.warning("No lpr_server_id set, cannot fetch server connection info")
+            return None
+        
+        try:
+            endpoint = f"/v1/actions/lpr_servers/{self.lpr_server_id}"
+            self.logger.info(f"Sending GET request to: {endpoint}")
+            response = self.session.rpc.get(endpoint)
+            self.logger.info(f"Received response: success={response.get('success')}, code={response.get('code')}, message={response.get('message')}")
+            
+            if response.get("success", False) and response.get("code") == 200:
+                # Response format:
+                # {'success': True,
+                # 'code': 200,
+                # 'message': 'Success',
+                # 'serverTime': '2025-10-19T04:58:04Z',
+                # 'data': {'id': '68f07e515cd5c6134a075384',
+                # 'name': 'lpr-server-1',
+                # 'host': '106.219.122.19',
+                # 'port': 8200,
+                # 'status': 'created',
+                # 'accountNumber': '3823255831182978487149732',
+                # 'projectID': '68ca6372ab79ba13ef699ba6',
+                # 'region': 'United States',
+                # 'isShared': False}}
+                data = response.get("data", {})
+                self.logger.info(f"Server connection info retrieved: name={data.get('name')}, host={data.get('host')}, port={data.get('port')}, status={data.get('status')}")
+                return data
+            else:
+                self.logger.warning(f"Failed to fetch server info: {response.get('message', 'Unknown error')}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Exception while fetching server connection info: {e}", exc_info=True)
+            return None
+
+    def should_log_plate(self, plate_text: str, cooldown: float) -> bool:
+        """Check if enough time has passed since last log for this plate."""
+        current_time = time.time()
+        last_log_time = self.plate_log_timestamps.get(plate_text, 0)
+        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)")
+            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)")
+            return False
+    
+    def update_log_timestamp(self, plate_text: str) -> None:
+        """Update the last log timestamp for a plate."""
+        self.plate_log_timestamps[plate_text] = time.time()
+        self.logger.debug(f"Updated log timestamp for plate: {plate_text}")
+    
+    def _format_timestamp_rfc3339(self, timestamp: str) -> str:
+        """Convert timestamp to RFC3339 format (2006-01-02T15:04:05Z).
+        
+        Handles various input formats:
+        - "YYYY-MM-DD-HH:MM:SS.ffffff UTC"
+        - "YYYY:MM:DD HH:MM:SS"
+        - Unix timestamp (float/int)
+        """
+        try:
+            # If already in RFC3339 format, return as is
+            if 'T' in timestamp and timestamp.endswith('Z'):
+                return timestamp
+            
+            # Try to parse common formats
+            dt = None
+            
+            # Format: "2025-08-19-04:22:47.187574 UTC"
+            if '-' in timestamp and 'UTC' in timestamp:
+                timestamp_clean = timestamp.replace(' UTC', '')
+                dt = datetime.strptime(timestamp_clean, '%Y-%m-%d-%H:%M:%S.%f')
+            # Format: "2025:10:23 14:30:45"
+            elif ':' in timestamp and ' ' in timestamp:
+                dt = datetime.strptime(timestamp, '%Y:%m:%d %H:%M:%S')
+            # Format: numeric timestamp
+            elif timestamp.replace('.', '').isdigit():
+                dt = datetime.fromtimestamp(float(timestamp), tz=timezone.utc)
+            
+            if dt is None:
+                # Fallback to current time
+                dt = datetime.now(timezone.utc)
+            else:
+                # Ensure timezone is UTC
+                if dt.tzinfo is None:
+                    dt = dt.replace(tzinfo=timezone.utc)
+            
+            # Format to RFC3339: 2006-01-02T15:04:05Z
+            return dt.strftime('%Y-%m-%dT%H:%M:%SZ')
+            
+        except Exception as e:
+            self.logger.warning(f"Failed to parse timestamp '{timestamp}': {e}. Using current time.")
+            return datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    async def log_plate(self, plate_text: str, timestamp: str, stream_info: Dict[str, Any], cooldown: float = 30.0) -> bool:
+        """Log plate to RPC server with cooldown period."""
+        self.logger.info(f"Attempting to log plate: {plate_text} at {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")
+            return False
+        
+        try:
+            camera_info = stream_info.get("camera_info", {})
+            camera_name = camera_info.get("camera_name", "")
+            location = camera_info.get("location", "")
+            frame_id = stream_info.get("frame_id", "")
+            
+            # Get project ID from server_info
+            project_id = self.server_info.get('projectID', '') if self.server_info else ''
+            
+            # Format timestamp to RFC3339 format (2006-01-02T15:04:05Z)
+            rfc3339_timestamp = self._format_timestamp_rfc3339(timestamp)
+            
+            payload = {
+                'licensePlate': plate_text,
+                'frameId': frame_id,
+                'location': location,
+                'camera': camera_name,
+                'captureTimestamp': rfc3339_timestamp,
+                'projectId': project_id
+            }
+            
+            # 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 payload: {payload}")
+            
+            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}")
+            
+            # 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}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Plate {plate_text} NOT SENT - Failed to log: {e}", exc_info=True)
+            return False
+        
 class LicensePlateMonitorUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {"license_plate": "license_plate"}
     
@@ -125,11 +373,19 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.image_preprocessor = ImagePreprocessor()
         # Fast OCR model (shared across instances)
         if LicensePlateMonitorUseCase._ocr_model is None:
-            try:
+            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')
-                self.logger.info("LicensePlateRecognizer loaded successfully")
-            except Exception as e:
-                self.logger.warning(f"Failed to initialise LicensePlateRecognizer: {e}")
+            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)
         self._text_history: Dict[str, int] = {}
@@ -145,6 +401,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self._ocr_mode = None
         #self.jpeg = TurboJPEG()
         
+        # Initialize plate logger (optional, only used if lpr_server_id is provided)
+        self.plate_logger: Optional[LicensePlateMonitorLogger] = None
+        self._logging_enabled = True
+        
 
     def reset_tracker(self) -> None:
         """Reset the advanced tracker instance."""
@@ -170,6 +430,65 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.reset_tracker()
         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."""
+        if not config.lpr_server_id:
+            self._logging_enabled = False
+            self.logger.info("Plate logging disabled: no lpr_server_id provided")
+            return
+        
+        try:
+            if self.plate_logger is None:
+                self.plate_logger = LicensePlateMonitorLogger()
+            
+            self.plate_logger.initialize_session(config)
+            self._logging_enabled = True
+            self.logger.info(f"Plate logging enabled with server ID: {config.lpr_server_id}")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize plate logger: {e}", exc_info=True)
+            self._logging_enabled = False
+    
+    def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
+                            stream_info: Optional[Dict[str, Any]]) -> None:
+        """Log all detected plates to RPC server with cooldown."""
+        if not self._logging_enabled or not self.plate_logger or not stream_info:
+            return
+        
+        # Get current timestamp
+        current_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
+        
+        # Collect all unique plates from current detections
+        plates_to_log = set()
+        for det in detections:
+            plate_text = det.get('plate_text')
+            if not plate_text:
+                continue
+            plates_to_log.add(plate_text)
+        
+        # Log each unique plate (respecting cooldown)
+        if plates_to_log:
+            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(
+                            plate_text=plate_text,
+                            timestamp=current_timestamp,
+                            stream_info=stream_info,
+                            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()
+            except Exception as e:
+                self.logger.error(f"Error during plate logging: {e}", exc_info=True)
 
     def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
@@ -185,11 +504,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             if not input_bytes:
                 return self.create_error_result("input_bytes (video/image) is required for license plate monitoring",
                                                usecase=self.name, category=self.category, context=context)
-                                               
-            print("--------------------------------------")
-            print("config.alert_config",config.alert_config)
-            print(config)
-            print("--------------------------------------")
+            
+            # 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)
             
             # Normalize alert_config if provided as a plain dict (JS JSON)
             if isinstance(getattr(config, 'alert_config', None), dict):
@@ -287,6 +605,9 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             processed_data = self._update_detections_with_ocr(processed_data, ocr_analysis)
             self._update_plate_texts(processed_data)
             
+            # 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)
+            
             # Step 10: Update frame counter
             self._total_frame_counter += 1
             
@@ -463,15 +784,17 @@ 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."""
-        # print("---------OCR CROP22",crop)
-        # print("---------OCR CROP SIZE22",crop.size)
-
         if crop is None or crop.size == 0 or self.ocr_model is None:
             return ""
+        
+        # Check if we have a valid OCR model (not the stub) - silently return empty if stub
+        if not hasattr(self.ocr_model, 'run'):
+            return ""
+            
         try:
-            # fast_plate_ocr expects RGB
-            #rgb_crop = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
+            # fast_plate_ocr LicensePlateRecognizer has a run() method
             res = self.ocr_model.run(crop)
+            
             if isinstance(res, list):
                 res = res[0] if res else ""
             cleaned_text = self._clean_text(str(res))
@@ -482,12 +805,14 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                     response = all(ch.isalpha() for ch in cleaned_text)
                 elif self._ocr_mode == "alphanumeric":
                     response = True
+                else:
+                    response = False
                 
                 if response:
                     return cleaned_text
-            else:
-                return ""
+            return ""
         except Exception as exc:
+            # Only log at debug level to avoid spam
             self.logger.warning(f"OCR failed: {exc}")
             return ""