matrice-analytics 0.1.44__tar.gz → 0.1.45__tar.gz

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/PKG-INFO

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

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/matrice_analytics.egg-info/PKG-INFO

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

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/matrice_analytics.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ src/matrice_analytics/post_processing/test_cases/test_customer_service.py
 src/matrice_analytics/post_processing/test_cases/test_data_generators.py
 src/matrice_analytics/post_processing/test_cases/test_people_counting.py
 src/matrice_analytics/post_processing/test_cases/test_processor.py
+src/matrice_analytics/post_processing/test_cases/test_usecases.py
 src/matrice_analytics/post_processing/test_cases/test_utilities.py
 src/matrice_analytics/post_processing/test_cases/test_utils.py
 src/matrice_analytics/post_processing/usecases/Histopathological_Cancer_Detection_img.py

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/config.py

@@ -143,4 +143,4 @@ def get_usecase_from_app_name(app_name: str) -> str:
 
 def get_category_from_app_name(app_name: str) -> str:
     normalized_app_name = app_name.lower().replace(" ", "_").replace("-", "_")
-    return APP_NAME_TO_CATEGORY.get(app_name, APP_NAME_TO_CATEGORY.get(normalized_app_name))
+    return APP_NAME_TO_CATEGORY.get(app_name, APP_NAME_TO_CATEGORY.get(normalized_app_name))

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -24,7 +24,7 @@ subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        preexec_fn=os.setpgrp   
+        # preexec_fn=os.setpgrp
     )
 log_file.close()
 
@@ -81,13 +81,13 @@ class TemporalIdentityManager:
     """
     Maintains stable identity labels per tracker ID using temporal smoothing and embedding history.
 
-    Adaptation for production: _compute_best_identity queries the face recognition API
-    via search_similar_faces(embedding, threshold=0.01, limit=1) to obtain top-1 match and score.
+    Uses local embedding similarity search via EmbeddingManager instead of API calls.
     """
 
     def __init__(
         self,
         face_client: FacialRecognitionClient,
+        embedding_manager: Optional[Any] = None,  # EmbeddingManager instance
         recognition_threshold: float = 0.35,
         history_size: int = 20,
         unknown_patience: int = 7,
@@ -96,6 +96,7 @@ class TemporalIdentityManager:
     ) -> None:
         self.logger = logging.getLogger(__name__)
         self.face_client = face_client
+        self.embedding_manager = embedding_manager
         self.threshold = float(recognition_threshold)
         self.history_size = int(history_size)
         self.unknown_patience = int(unknown_patience)
@@ -119,69 +120,65 @@ class TemporalIdentityManager:
 
     async def _compute_best_identity(self, emb: List[float], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
         """
-        Query backend for top-1 match for the given embedding.
+        Query embedding manager for top-1 match using local similarity search.
         Returns (staff_id, person_name, score, employee_id, staff_details, detection_type).
-        Robust to varying response shapes.
+        
+        NOTE: API call to search_similar_faces is commented out - using local embeddings only.
         """
         if not emb or not isinstance(emb, list):
             return None, "Unknown", 0.0, None, {}, "unknown"
+        
+        # COMMENTED OUT: API-based search - now using local embedding similarity search
+        # try:
+        #     resp = await self.face_client.search_similar_faces(
+        #         face_embedding=emb,
+        #         threshold=0.01,  # low threshold to always get top-1
+        #         limit=1,
+        #         collection="staff_enrollment",
+        #         location=location,
+        #         timestamp=timestamp,
+        #     )
+        # except Exception as e:
+        #     self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
+        #     return None, "Unknown", 0.0, None, {}, "unknown"
+        #
+        # [API response parsing code removed - see git history]
+        
+        # NEW: Use local embedding manager for similarity search
         try:
-            resp = await self.face_client.search_similar_faces(
-                face_embedding=emb,
-                threshold=0.01,  # low threshold to always get top-1
-                limit=1,
-                collection="staff_enrollment",
+            if not self.embedding_manager:
+                self.logger.warning("Embedding manager not available for local similarity search")
+                return None, "Unknown", 0.0, None, {}, "unknown"
+            
+            # Perform local similarity search using embedding manager
+            search_result = await self.embedding_manager.search_face_embedding(
+                embedding=emb,
+                track_id=None,  # No track_id needed for this search
                 location=location,
                 timestamp=timestamp,
             )
-        except Exception as e:
-            self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
-            return None, "Unknown", 0.0, None, {}, "unknown"
-
-        try:
-            results: List[Any] = []
-            self.logger.debug('API Response received for identity search')
-            if isinstance(resp, dict):
-                if isinstance(resp.get("data"), list):
-                    results = resp.get("data", [])
-                elif isinstance(resp.get("results"), list):
-                    results = resp.get("results", [])
-                elif isinstance(resp.get("items"), list):
-                    results = resp.get("items", [])
-            elif isinstance(resp, list):
-                results = resp
-
-            if not results:
-                self.logger.debug("No identity match found from API")
+            
+            if not search_result:
+                self.logger.debug("No identity match found from local embeddings")
                 return None, "Unknown", 0.0, None, {}, "unknown"
-
-            item = results[0] if isinstance(results, list) else results
-            self.logger.debug(f'Top-1 match from API: {item}')
-            # Be defensive with keys and types
-            staff_id = item.get("staffId") if isinstance(item, dict) else None
-            employee_id = str(item.get("_id")) if isinstance(item, dict) and item.get("_id") is not None else None
-            score = float(item.get("score", 0.0)) if isinstance(item, dict) else 0.0
-            detection_type = str(item.get("detectionType", "unknown")) if isinstance(item, dict) else "unknown"
-            staff_details = item.get("staffDetails", {}) if isinstance(item, dict) else {}
-            # Extract a person name from staff_details
-            person_name = "Unknown"
-            if isinstance(staff_details, dict) and staff_details:
-                first_name = staff_details.get("firstName")
-                last_name = staff_details.get("lastName")
-                name = staff_details.get("name")
-                if name:
-                    person_name = str(name)
-                else:
-                    if first_name or last_name:
-                        person_name = f"{first_name or ''} {last_name or ''}".strip() or "UnknowNN" #TODO:ebugging change to normal once done
-            # If API says unknown or missing staff_id, treat as unknown
-            if not staff_id: #or detection_type == "unknown"
-                self.logger.debug(f"API returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
+            
+            # Extract data from SearchResult
+            staff_id = search_result.staff_id
+            person_name = search_result.person_name
+            score = search_result.similarity_score
+            employee_id = search_result.employee_id
+            staff_details = search_result.staff_details
+            detection_type = search_result.detection_type
+            
+            if not staff_id or detection_type == "unknown":
+                self.logger.debug(f"Local search returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
                 return None, "Unknown", float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "unknown"
-            self.logger.info(f"API identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
+            
+            self.logger.info(f"Local embedding identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
             return str(staff_id), person_name, float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "known"
+            
         except Exception as e:
-            self.logger.error(f"Error parsing API response in _compute_best_identity: {e}", exc_info=True)
+            self.logger.error(f"Error in local embedding similarity search: {e}", exc_info=True)
             return None, "Unknown", 0.0, None, {}, "unknown"
 
     async def _compute_best_identity_from_history(self, track_state: Dict[str, object], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
@@ -488,16 +485,17 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
             self.logger.info("Embedding manager initialized")
             
-            # Initialize TemporalIdentityManager
+            # Initialize TemporalIdentityManager with embedding_manager for local search
             self.temporal_identity_manager = TemporalIdentityManager(
                 face_client=self.face_client,
+                embedding_manager=self.embedding_manager,  # Pass embedding manager for local similarity search
                 recognition_threshold=float(init_config.similarity_threshold),
                 history_size=20,
                 unknown_patience=7,
                 switch_patience=5,
                 fallback_margin=0.05,
             )
-            self.logger.info("Temporal identity manager initialized")
+            self.logger.info("Temporal identity manager initialized with local embedding search")
             
             self._initialized = True
             self.logger.info("Face recognition use case fully initialized")
@@ -909,16 +907,28 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Generate current timestamp
         current_timestamp = datetime.now(timezone.utc).isoformat()
 
-        final_detections = []
-        # Process detections sequentially to preserve order
-        for detection in detections:
-            
-            # Process each detection sequentially with await to preserve order
-            processed_detection = await self._process_face(
+        # Process all detections in parallel for better performance
+        # Create tasks for parallel processing
+        tasks = [
+            self._process_face(
                 detection, current_frame, location, current_timestamp, config,
                 current_recognized_count, current_unknown_count, 
                 recognized_persons, current_frame_staff_details
             )
+            for detection in detections
+        ]
+        
+        # Process all faces in parallel
+        processed_detections = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Build final results and update counters (maintains order)
+        final_detections = []
+        for processed_detection in processed_detections:
+            # Handle exceptions from parallel processing
+            if isinstance(processed_detection, Exception):
+                self.logger.error(f"Error processing face detection: {processed_detection}", exc_info=True)
+                continue
+                
             # Include both known and unknown faces in final detections (maintains original order)
             if processed_detection:
                 final_detections.append(processed_detection)
@@ -1085,7 +1095,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                         # If it later becomes recognized, we'll remove it from unknown set above
                         self._unknown_track_ids.add(internal_tid)
 
-        # Enqueue detection for background logging with all required parameters
+        # Enqueue detection for background logging with all required parameters (non-blocking)
         try:
             # Log known faces for activity tracking (skip any employee_id starting with "unknown_")
             if (
@@ -1096,7 +1106,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 and employee_id
                 and not str(employee_id).startswith("unknown_")
             ):
-                await self.people_activity_logging.enqueue_detection(
+                # Non-blocking enqueue - no await needed
+                self.people_activity_logging.enqueue_detection(
                     detection=detection,
                     current_frame=current_frame,
                     location=location,

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -182,9 +182,9 @@ class FacialRecognitionClient:
                 payload=enrollment_request,
                 base_url=self.server_base_url
             )
-            self.logger.info(f"API RESPONSE: Staff enrollment completed - Success: {response.get('success', False)}")
-            if not response.get('success', False):
-                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error')}")
+            self.logger.info(f"API RESPONSE: Staff enrollment completed - Success: {response.get('success', False) if response else False}")
+            if not response or not response.get('success', False):
+                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             return self._handle_response(response)
         except Exception as e:
             self.logger.error(f"API ERROR: Staff enrollment request failed - {e}", exc_info=True)
@@ -236,14 +236,14 @@ class FacialRecognitionClient:
             )
             
             results_count = 0
-            if response.get('success', False):
+            if response and response.get('success', False):
                 data = response.get('data', [])
                 results_count = len(data) if isinstance(data, list) else 0
                 self.logger.info(f"API RESPONSE: Face search completed - Found {results_count} matches")
                 if results_count > 0:
                     self.logger.debug(f"Top match: staff_id={data[0].get('staffId', 'N/A')}, score={data[0].get('score', 0):.3f}")
             else:
-                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -267,10 +267,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Staff details retrieved successfully - staff_id={staff_id}")
             else:
-                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -366,10 +366,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Staff images updated successfully - employee_id={employee_id}")
             else:
-                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -417,10 +417,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Service shutdown successful")
             else:
-                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -447,12 +447,12 @@ class FacialRecognitionClient:
             )
             
             embeddings_count = 0
-            if response.get('success', False):
+            if response and response.get('success', False):
                 data = response.get('data', [])
                 embeddings_count = len(data) if isinstance(data, list) else 0
                 self.logger.info(f"API RESPONSE: Retrieved {embeddings_count} staff embeddings")
             else:
-                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -485,10 +485,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Deployment updated successfully - deployment_id={deployment_id}")
             else:
-                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -527,10 +527,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Unknown person enrolled successfully")
             else:
-                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -551,10 +551,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and response.get('success', False):
                 self.logger.info(f"API RESPONSE: Service is healthy")
             else:
-                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error')}")
+                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -564,6 +564,11 @@ class FacialRecognitionClient:
     def _handle_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
         """Handle RPC response and errors"""
         try:
+            # Handle None response
+            if response is None:
+                self.logger.error("RPC Error: Received None response from API")
+                return {"success": False, "error": "No response received from API"}
+            
             if response.get("success", True):
                 return response
             else:

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -84,19 +84,20 @@ class PeopleActivityLogging:
                     self.activity_queue.task_done()
                 except queue.Empty:
                     # Continue loop to check for empty detections
+                    await asyncio.sleep(0.01)
                     continue
 
             except Exception as e:
                 self.logger.error(f"Error processing activity queue: {e}", exc_info=True)
                 await asyncio.sleep(1.0)
 
-    async def enqueue_detection(
+    def enqueue_detection(
         self,
         detection: Dict,
         current_frame: Optional[np.ndarray] = None,
         location: str = "",
     ):
-        """Enqueue a detection for background processing"""
+        """Enqueue a detection for background processing (non-blocking)"""
         try:
             activity_data = {
                 "detection_type": detection["recognition_status"],  # known, unknown
@@ -135,8 +136,9 @@ class PeopleActivityLogging:
             self.last_detection_time = time.time()
             self.empty_detection_logged = False
 
-            # Use thread-safe put (no await needed for queue.Queue)
-            self.activity_queue.put(activity_data)
+            # Use thread-safe put_nowait to avoid any potential blocking
+            # queue.Queue.put() is already non-blocking with no timeout, but being explicit
+            self.activity_queue.put_nowait(activity_data)
         except Exception as e:
             self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
 

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/ocr/easyocr_extractor.py

@@ -1,6 +1,7 @@
 import easyocr
 import numpy as np
 import torch
+from matrice_common.utils import log_errors
 
 class EasyOCRExtractor:
     def __init__(self, lang=['en', 'hi', 'ar'], gpu=False, model_storage_directory=None, 
@@ -30,7 +31,8 @@ class EasyOCRExtractor:
         self.recognizer = recognizer
         self.verbose = verbose
         self.reader = None
-    
+        
+    @log_errors(default_return=None, raise_exception=True, service_name="py_analytics", log_error=True)
     def setup(self):
         """
         Initializes the EasyOCR reader if not already initialized.

matrice_analytics-0.1.45/src/matrice_analytics/post_processing/test_cases/test_usecases.py

@@ -0,0 +1,165 @@
+import os
+import sys
+import cv2
+import json
+import importlib
+import argparse
+from ultralytics import YOLO
+from src.matrice_analytics.post_processing.core.base import ProcessingContext
+
+
+class UseCaseTestProcessor:
+    """
+    A flexible YOLO-based video processor for testing different post-processing use cases.
+    """
+
+    def __init__(self, file_name, config_name, usecase_name, model_path, video_path, post_process=None, max_frames=None):
+        self.file_name = file_name
+        self.config_name = config_name
+        self.usecase_name = usecase_name
+        self.model_path = model_path
+        self.video_path = video_path
+        self.post_process = post_process
+        self.max_frames = max_frames
+        self.json_dir = "jsons"
+
+        self._setup_environment()
+        self.ConfigClass, self.UsecaseClass = self._load_usecase()
+        self.config = self._initialize_config()
+        self.processor = self.UsecaseClass()
+        self.model = YOLO(self.model_path)
+        os.makedirs(self.json_dir, exist_ok=True)
+
+    def _setup_environment(self):
+        """Ensure project root is added to sys.path."""
+        project_root = os.path.abspath("/content/py_analytics")
+        if project_root not in sys.path:
+            sys.path.append(project_root)
+
+    def _load_usecase(self):
+        """Dynamically import config and usecase classes."""
+        module_path = f"src.matrice_analytics.post_processing.usecases.{self.file_name}"
+        module = importlib.import_module(module_path)
+        return getattr(module, self.config_name), getattr(module, self.usecase_name)
+
+    def _initialize_config(self):
+        """Initialize config object, applying overrides if provided."""
+        if self.post_process:
+            return self.ConfigClass(**self.post_process)
+        return self.ConfigClass()
+
+    def _serialize_result(self, result):
+        """Convert result object into JSON-serializable dict."""
+        def to_serializable(obj):
+            if hasattr(obj, "to_dict"):
+                return obj.to_dict()
+            if hasattr(obj, "__dict__"):
+                return obj.__dict__
+            return str(obj)
+        return json.loads(json.dumps(result, default=to_serializable))
+
+
+    def process_video(self):
+        """Run YOLO inference on video and post-process frame by frame."""
+        cap = cv2.VideoCapture(self.video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Failed to open video at {self.video_path}")
+
+        frame_idx = 0
+        stream_info = {
+            'input_settings': {
+                'start_frame': 0,
+                'original_fps': cap.get(cv2.CAP_PROP_FPS),
+                'camera_info': {'id': 'cam1', 'name': 'Test Camera'}
+            }
+        }
+
+        print(f"\nStarting video processing: {self.video_path}")
+        print(f"Model: {self.model_path}")
+        print(f"Output directory: {self.json_dir}\n")
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = self.model(frame_rgb)
+
+            detections = []
+            for xyxy, conf, cls in zip(results[0].boxes.xyxy, results[0].boxes.conf, results[0].boxes.cls):
+                x1, y1, x2, y2 = xyxy.tolist()
+                detections.append({
+                    'category_id': int(cls),
+                    'confidence': conf.item(),
+                    'bounding_box': {
+                        'xmin': int(x1),
+                        'ymin': int(y1),
+                        'xmax': int(x2),
+                        'ymax': int(y2)
+                    }
+                })
+
+            success, encoded_image = cv2.imencode(".jpg", frame)
+            input_bytes = encoded_image.tobytes() if success else None
+
+            try:
+                result = self.processor.process(
+                    detections, self.config, input_bytes, ProcessingContext(), stream_info
+                )
+            except TypeError:
+                result = self.processor.process(
+                    detections, self.config, ProcessingContext(), stream_info
+                )
+
+            json_path = os.path.join(self.json_dir, f"frame_{frame_idx:04d}.json")
+            with open(json_path, "w") as f:
+                json.dump(self._serialize_result(result), f, indent=2)
+
+            print(f"Frame {frame_idx} processed — detections: {len(detections)} — saved: {json_path}")
+
+            frame_idx += 1
+            stream_info['input_settings']['start_frame'] += 1
+
+            if self.max_frames and frame_idx >= self.max_frames:
+                print(f"\nMax frame limit ({self.max_frames}) reached.")
+                break
+
+        cap.release()
+        print(f"\nProcessing complete. JSON outputs saved in: {self.json_dir}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="YOLO Use Case Test Processor")
+
+    parser.add_argument("--file_name", type=str, required=True,
+                        help="Usecase file name under src/matrice_analytics/post_processing/usecases/")
+    parser.add_argument("--config_name", type=str, required=True,
+                        help="Config class name (e.g., PeopleCountingConfig)")
+    parser.add_argument("--usecase_name", type=str, required=True,
+                        help="Use case class name (e.g., PeopleCountingUseCase)")
+    parser.add_argument("--model_path", type=str, required=True,
+                        help="Path to YOLO model file (.pt)")
+    parser.add_argument("--video_path", type=str, required=True,
+                        help="Path to input video")
+    parser.add_argument("--post_process", type=json.loads, default=None,
+                        help="JSON string for config overrides, e.g. '{\"min_confidence\": 0.5}'")
+    parser.add_argument("--max_frames", type=int, default=None,
+                        help="Limit number of frames processed")
+
+    args = parser.parse_args()
+
+    processor = UseCaseTestProcessor(
+        file_name=args.file_name,
+        config_name=args.config_name,
+        usecase_name=args.usecase_name,
+        model_path=args.model_path,
+        video_path=args.video_path,
+        post_process=args.post_process,
+        max_frames=args.max_frames
+    )
+    processor.process_video()
+
+
+if __name__ == "__main__":
+    main()

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/usecases/color/clip.py

@@ -11,20 +11,21 @@ subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        preexec_fn=os.setpgrp   
+        # preexec_fn=os.setpgrp
     )
 cmd = ["pip", "install", "httpx", "aiohttp", "filterpy"]
 subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        preexec_fn=os.setpgrp   
+        # preexec_fn=os.setpgrp
     )
 log_file.close()
 
 import numpy as np
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass, field
+from pathlib import Path
 import cv2
 import io
 import threading
@@ -371,7 +372,7 @@ class ClipProcessor:
                 cmd,
                 stdout=log_file,
                 stderr=subprocess.STDOUT,
-                preexec_fn=os.setpgrp
+                # preexec_fn=os.setpgrp
             )
 
         # Determine and enforce providers (prefer CUDA only)

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/usecases/color/color_mapper.py

@@ -465,4 +465,4 @@ def process_video_with_color_detection(
     classifier = VideoColorClassifier(top_k_colors, min_confidence)
     return classifier.process_video_with_predictions(
         video_bytes, yolo_predictions, output_dir, fps
-    )
+    )

{matrice_analytics-0.1.44 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/usecases/fire_detection.py

@@ -1144,4 +1144,3 @@ class FireSmokeUseCase(BaseProcessor):
         return (1,1)
 
 
-