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

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

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

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

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

{matrice_analytics-0.1.33 → matrice_analytics-0.1.35}/src/matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -90,7 +90,7 @@ class FacialRecognitionClient:
                         self.server_base_url = f"http://localhost:{server_port}"
                         self.logger.warning(f"Server host matches public IP, using localhost: {self.server_base_url}")
                     else:
-                        self.server_base_url = f"https://{server_host}:{server_port}"
+                        self.server_base_url = f"http://{server_host}:{server_port}"
                         self.logger.warning(f"Facial recognition server base URL: {self.server_base_url}")
                     
                     self.session.update(self.server_info.get('projectID', ''))

{matrice_analytics-0.1.33 → matrice_analytics-0.1.35}/src/matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -60,9 +60,9 @@ from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
 # (Catch import errors early in the logs)
 try:
-    _ = LicensePlateRecognizer  # noqa: B018 – reference to quiet linters
+    _ = LicensePlateRecognizer  # noqa: B018  reference to quiet linters
 except Exception as _e:
-    print(f"Warning: fast_plate_ocr could not be imported ⇒ {_e}")
+    print(f"Warning: fast_plate_ocr could not be imported  {_e}")
 
 try:
     from  matrice_common.session import Session
@@ -123,60 +123,88 @@ 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...")
+        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")
+        
+        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 +261,10 @@ 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)")
+            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)")
+            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 +325,13 @@ 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}")
+        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")
+            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 +340,15 @@ class LicensePlateMonitorLogger:
             location = camera_info.get("location", "")
             frame_id = stream_info.get("frame_id", "")
             
+            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 +362,23 @@ 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}"
+            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}")
+            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}")
+            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)
+            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):
@@ -398,7 +436,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                     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 text history for stability checks (text  consecutive frame count)
         self._text_history: Dict[str, int] = {}
 
         self.start_timer = None
@@ -415,6 +453,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 +481,57 @@ 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, 
                             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
+        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:
+            self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")
             return
         
+        if not self.plate_logger:
+            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:
+            self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
+            return
+        
+        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,20 +549,33 @@ 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)
         
+        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)
         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")
             try:
                 # Run async logging tasks
                 loop = asyncio.new_event_loop()
@@ -504,6 +583,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 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(
                             plate_text=plate_text,
                             timestamp=current_timestamp,
@@ -514,11 +594,22 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                         tasks.append(task)
                     
                     # Run all logging tasks concurrently
-                    loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+                    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")
             except Exception as e:
-                self.logger.error(f"Error during plate logging: {e}", exc_info=True)
+                self.logger.error(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}", exc_info=True)
+        else:
+            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, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
@@ -535,9 +626,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):
@@ -627,14 +728,21 @@ 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)
             
@@ -926,7 +1034,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 +1481,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.