matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -7,6 +7,7 @@ in the post-processing pipeline using Matrice Session.
 """
 
 import os
+import re
 import base64
 import logging
 import httpx
@@ -14,6 +15,7 @@ import urllib
 import urllib.request
 from typing import List, Dict, Any, Optional
 from datetime import datetime, timezone
+from pathlib import Path
 
 # Import matrice session
 try:
@@ -29,6 +31,78 @@ class FacialRecognitionClient:
     Simplified Face Recognition Client using Matrice Session.
     All API calls are made through the Matrice session RPC interface.
     """
+    
+    # Pattern for matching action IDs (hex strings of at least 8 characters)
+    ACTION_ID_PATTERN = re.compile(r"^[0-9a-f]{8,}$", re.IGNORECASE)
+
+    @classmethod
+    def _discover_action_id(cls) -> Optional[str]:
+        """Discover action_id from current working directory name (and parents)."""
+        candidates: List[str] = []
+        try:
+            cwd = Path.cwd()
+            candidates.append(cwd.name)
+            for parent in cwd.parents:
+                candidates.append(parent.name)
+        except Exception:
+            pass
+
+        try:
+            usr_src = Path("/usr/src")
+            if usr_src.exists():
+                for child in usr_src.iterdir():
+                    if child.is_dir():
+                        candidates.append(child.name)
+        except Exception:
+            pass
+
+        for candidate in candidates:
+            if candidate and len(candidate) >= 8 and cls.ACTION_ID_PATTERN.match(candidate):
+                return candidate
+        return None
+
+    def _fetch_project_id_from_action(self) -> Optional[str]:
+        """
+        Fetch project ID from action details using discovered action ID.
+        
+        This method discovers the action ID from the working directory name,
+        fetches action details from the API, and extracts the _idProject field.
+        If successful, it also updates the MATRICE_PROJECT_ID environment variable.
+        
+        Returns:
+            The project ID string if found, None otherwise.
+        """
+        action_id = self._discover_action_id()
+        if not action_id:
+            self.logger.warning("[PROJECT_ID] Could not discover action_id from folder name")
+            return None
+        
+        self.logger.info(f"[PROJECT_ID] Discovered action_id from folder: {action_id}")
+        
+        try:
+            url = f"/v1/actions/action/{action_id}/details"
+            self.logger.info(f"[PROJECT_ID] Fetching action details from: {url}")
+            response = self.session.rpc.get(url)
+            
+            if response and response.get("success", False) and response.get("code") == 200:
+                data = response.get("data", {})
+                project_id = data.get("_idProject", "")
+                
+                if project_id:
+                    self.logger.info(f"[PROJECT_ID] Successfully fetched project ID from action details: {project_id}")
+                    # Update environment variable so other components can use it
+                    os.environ["MATRICE_PROJECT_ID"] = project_id
+                    self.logger.info(f"[PROJECT_ID] Updated MATRICE_PROJECT_ID environment variable: {project_id}")
+                    return project_id
+                else:
+                    self.logger.warning(f"[PROJECT_ID] _idProject not found in action details for action_id={action_id}")
+            else:
+                error_msg = response.get('message', 'Unknown error') if response else 'Empty response'
+                self.logger.warning(f"[PROJECT_ID] Failed to fetch action details: {error_msg}")
+        except Exception as e:
+            self.logger.error(f"[PROJECT_ID] Error fetching action details for action_id={action_id}: {e}", exc_info=True)
+        
+        return None
 
     def __init__(self, account_number: str = "", access_key: str = "", secret_key: str = "", 
                  project_id: str = "", server_id: str = "", session=None):
@@ -75,6 +149,23 @@ class FacialRecognitionClient:
             except Exception as e:
                 self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
                 raise
+        
+        # If project_id is still empty, try to fetch from action details
+        if not self.project_id:
+            self.logger.info("[PROJECT_ID] Project ID is empty, attempting to fetch from action details...")
+            fetched_project_id = self._fetch_project_id_from_action()
+            if fetched_project_id:
+                self.project_id = fetched_project_id
+                self.logger.info(f"[PROJECT_ID] Successfully set project_id from action details: {self.project_id}")
+                # Update session with the new project_id if possible
+                if hasattr(self.session, 'update'):
+                    try:
+                        self.session.update(self.project_id)
+                        self.logger.info(f"[PROJECT_ID] Updated session with project_id: {self.project_id}")
+                    except Exception as e:
+                        self.logger.warning(f"[PROJECT_ID] Failed to update session with project_id: {e}")
+            else:
+                self.logger.warning("[PROJECT_ID] Could not fetch project_id from action details")
 
         # Fetch server connection info if server_id is provided
         if self.server_id:
@@ -93,12 +184,29 @@ class FacialRecognitionClient:
                         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', ''))
-                    self.logger.info(f"Updated Matrice session with project ID: {self.server_info.get('projectID', '')}")
+                    # Update project_id from server_info if available and current project_id is empty
+                    server_project_id = self.server_info.get('projectID', '')
+                    if server_project_id:
+                        if not self.project_id:
+                            self.project_id = server_project_id
+                            self.logger.info(f"[PROJECT_ID] Set project_id from server_info: {self.project_id}")
+                            # Update environment variable
+                            os.environ["MATRICE_PROJECT_ID"] = self.project_id
+                            self.logger.info(f"[PROJECT_ID] Updated MATRICE_PROJECT_ID env var from server_info: {self.project_id}")
+                        self.session.update(server_project_id)
+                        self.logger.info(f"Updated Matrice session with project ID: {server_project_id}")
+                    else:
+                        self.logger.warning("[PROJECT_ID] server_info.projectID is empty")
                 else:
                     self.logger.warning("Failed to fetch facial recognition server connection info")
             except Exception as e:
                 self.logger.error(f"Error fetching facial recognition server connection info: {e}", exc_info=True)
+        
+        # Final check: log the project_id status
+        if self.project_id:
+            self.logger.info(f"[PROJECT_ID] Final project_id: {self.project_id}")
+        else:
+            self.logger.error("[PROJECT_ID] WARNING: project_id is still empty after all initialization attempts!")
     
     def _get_public_ip(self) -> str:
         """Get the public IP address of this machine."""
@@ -286,6 +394,8 @@ class FacialRecognitionClient:
                                   employee_id: Optional[str] = None,
                                   timestamp: str = datetime.now(timezone.utc).isoformat(),
                                   image_data: Optional[str] = None,
+                                  camera_name: Optional[str] = None,
+                                  camera_id: Optional[str] = None,
                                   ) -> Dict[str, Any]:
         """
         Store people activity data with optional image data
@@ -310,6 +420,8 @@ class FacialRecognitionClient:
             "timestamp": timestamp,
             "bbox": bbox,
             "location": location,
+            "camera_name": camera_name,
+            "camera_id": camera_id,
         }
 
         # Add optional fields if provided based on API spec
@@ -322,8 +434,8 @@ class FacialRecognitionClient:
         if image_data:
             activity_request["imageData"] = image_data
         
-        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}, has_image={bool(image_data)}")
-        self.logger.debug(f"Activity request payload: bbox={bbox}, employee_id={employee_id}")
+        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}, camera_name={camera_name}, camera_id={camera_id}, has_image={bool(image_data)}")
+        self.logger.debug(f"Activity request payload: bbox={bbox}, employee_id={employee_id}, camera_name={camera_name}, camera_id={camera_id}")
         
         try:
             response = await self.session.rpc.async_send_request(
@@ -474,11 +586,11 @@ class FacialRecognitionClient:
         except Exception as e:
             self.logger.error(f"API ERROR: Get all staff embeddings request failed - {e}", exc_info=True)
             return {"success": False, "error": str(e)}
-
-    async def update_deployment(self, deployment_id: str) -> Dict[str, Any]:
-        """Update deployment to notify facial recognition server
+    
+    async def update_deployment_action(self, deployment_id: str) -> Dict[str, Any]:
+        """Update deployment action in backend
         
-        API: PUT /v1/facial_recognition/update_deployment/:deployment_id
+        API: PUT /internal/v1/actions/update_facial_recognition_deployment/:server_id?app_deployment_id=:deployment_id
         
         Args:
             deployment_id: The deployment ID to update
@@ -487,34 +599,34 @@ class FacialRecognitionClient:
             Dict containing response data
         """
         if not deployment_id:
-            self.logger.warning("No deployment_id provided for update_deployment")
+            self.logger.warning("No deployment_id provided for update_deployment_action")
             return {"success": False, "error": "deployment_id is required"}
 
-        self.logger.info(f"API REQUEST: Updating deployment - deployment_id={deployment_id}")
+        self.logger.info(f"API REQUEST: Updating deployment action - deployment_id={deployment_id}")
 
-        # Use Matrice session for async RPC call
+        # Use Matrice session for async RPC call to backend (not facial recognition server).
         try:
             response = await self.session.rpc.async_send_request(
                 method="PUT",
-                path=f"/v1/facial_recognition/update_deployment/{deployment_id}",
+                path=f"/v1/actions/update_facial_recognition_deployment/{self.server_id}?app_deployment_id={deployment_id}",
                 payload={},
-                base_url=self.server_base_url
+                base_url="https://prod.backend.app.matrice.ai"
             )
             
             if response.get('success', False):
-                self.logger.info(f"API RESPONSE: Deployment updated successfully - deployment_id={deployment_id}")
+                self.logger.info(f"API RESPONSE: Deployment action 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 action for deployment_id={deployment_id}: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
-            self.logger.error(f"API ERROR: Update deployment request failed - deployment_id={deployment_id} - {e}", exc_info=True)
+            self.logger.error(f"API ERROR: Update deployment action request failed - deployment_id={deployment_id} - {e}", exc_info=True)
             return {"success": False, "error": str(e)}
 
-    async def update_deployment_action(self, deployment_id: str) -> Dict[str, Any]:
-        """Update deployment action in backend
+    async def update_deployment(self, deployment_id: str) -> Dict[str, Any]:
+        """Update deployment to notify facial recognition server
         
-        API: PUT /internal/v1/actions/update_facial_recognition_deployment/:server_id?app_deployment_id=:deployment_id
+        API: PUT /v1/facial_recognition/update_deployment/:deployment_id
         
         Args:
             deployment_id: The deployment ID to update
@@ -523,28 +635,28 @@ class FacialRecognitionClient:
             Dict containing response data
         """
         if not deployment_id:
-            self.logger.warning("No deployment_id provided for update_deployment_action")
+            self.logger.warning("No deployment_id provided for update_deployment")
             return {"success": False, "error": "deployment_id is required"}
 
-        self.logger.info(f"API REQUEST: Updating deployment action - deployment_id={deployment_id}")
+        self.logger.info(f"API REQUEST: Updating deployment - deployment_id={deployment_id}")
 
-        # Use Matrice session for async RPC call to backend (not facial recognition server)
+        # Use Matrice session for async RPC call
         try:
             response = await self.session.rpc.async_send_request(
                 method="PUT",
-                path=f"/internal/v1/actions/update_facial_recognition_deployment/{self.server_id}?app_deployment_id={deployment_id}",
+                path=f"/v1/facial_recognition/update_deployment/{deployment_id}",
                 payload={},
-                base_url="https://prod.backend.app.matrice.ai"
+                base_url=self.server_base_url
             )
             
             if response.get('success', False):
-                self.logger.info(f"API RESPONSE: Deployment action updated successfully - deployment_id={deployment_id}")
+                self.logger.info(f"API RESPONSE: Deployment updated successfully - deployment_id={deployment_id}")
             else:
-                self.logger.warning(f"Failed to update deployment action 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')}")
             
             return self._handle_response(response)
         except Exception as e:
-            self.logger.error(f"API ERROR: Update deployment action request failed - deployment_id={deployment_id} - {e}", exc_info=True)
+            self.logger.error(f"API ERROR: Update deployment request failed - deployment_id={deployment_id} - {e}", exc_info=True)
             return {"success": False, "error": str(e)}
     
     async def enroll_unknown_person(self, embedding: List[float], image_source: str = None, timestamp: str = None, location: str = None, employee_id: str = None) -> Dict[str, Any]:
@@ -602,17 +714,47 @@ class FacialRecognitionClient:
                 payload={},
                 base_url=self.server_base_url
             )
-            
+
             if 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')}")
-            
+
             return self._handle_response(response)
         except Exception as e:
             self.logger.error(f"API ERROR: Health check request failed - {e}", exc_info=True)
             return {"success": False, "error": str(e)}
 
+    async def get_redis_details(self) -> Dict[str, Any]:
+        """Get Redis connection details from facial recognition server
+
+        API: GET /v1/facial_recognition/get_redis_details
+
+        Returns:
+            Dict containing Redis connection details (REDIS_IP, REDIS_PORT, REDIS_PASSWORD)
+        """
+
+        self.logger.info(f"API REQUEST: Getting Redis connection details")
+
+        # Use Matrice session for async RPC call
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="GET",
+                path=f"/v1/facial_recognition/get_redis_details",
+                payload={},
+                base_url=self.server_base_url
+            )
+
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Redis details retrieved successfully")
+            else:
+                self.logger.warning(f"Failed to get Redis details: {response.get('error', 'Unknown error')}")
+
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Get Redis details request failed - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
     def _handle_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
         """Handle RPC response and errors"""
         try:

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -4,6 +4,7 @@ import time
 import threading
 import queue
 import base64
+import os
 from typing import Dict, Optional, Set
 import numpy as np
 import cv2
@@ -18,6 +19,15 @@ class PeopleActivityLogging:
         self.face_client = face_client
         self.logger = logging.getLogger(__name__)
 
+        # Log project ID information for observability and debugging
+        face_client_project_id = getattr(self.face_client, "project_id", None) if self.face_client else None
+        env_project_id = os.getenv("MATRICE_PROJECT_ID", "")
+        self.logger.info(
+            "[PROJECT_ID] PeopleActivityLogging initialized "
+            f"with face_client.project_id='{face_client_project_id}', "
+            f"MATRICE_PROJECT_ID env='{env_project_id}'"
+        )
+
         # Use thread-safe queue for cross-thread communication (Python 3.8 compatibility)
         self.activity_queue = queue.Queue()
 
@@ -95,6 +105,8 @@ class PeopleActivityLogging:
         detection: Dict,
         current_frame: Optional[np.ndarray] = None,
         location: str = "",
+        camera_name: str = "",
+        camera_id: str = "",
     ):
         """Enqueue a detection for background processing"""
         try:
@@ -103,6 +115,8 @@ class PeopleActivityLogging:
                 "detection": detection,
                 "current_frame": current_frame,
                 "location": location,
+                "camera_name": camera_name,
+                "camera_id": camera_id,
                 "timestamp": datetime.now(timezone.utc).isoformat(),
                 "employee_id": detection.get("employee_id", None),
                 "staff_id": detection.get("person_id")
@@ -178,7 +192,10 @@ class PeopleActivityLogging:
         location = activity_data["location"]
         staff_id = activity_data["staff_id"]
         timestamp = activity_data["timestamp"]
+        camera_name = activity_data.get("camera_name", "")
+        camera_id = activity_data.get("camera_id", "")
         
+        self.logger.debug(f"Processing activity - location: '{location}', camera_name: '{camera_name}', camera_id: '{camera_id}'")
         try:
             if not self.face_client:
                 self.logger.warning("Face client not available for activity logging")
@@ -211,6 +228,8 @@ class PeopleActivityLogging:
                 employee_id=employee_id,
                 timestamp=timestamp,
                 image_data=image_data,
+                camera_name=camera_name,
+                camera_id=camera_id,
             )
 
             if response and response.get("success", False):

matrice_analytics/post_processing/post_processor.py

@@ -99,6 +99,7 @@ from .usecases import (
     UndergroundPipelineDefectUseCase,
     SusActivityUseCase,
     NaturalDisasterUseCase,
+    FootFallUseCase,
     # Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
     SkinCancerClassificationUseCase,
@@ -569,6 +570,9 @@ class PostProcessor:
         registry.register_use_case(
             "environmental", "natural_disaster_detection", NaturalDisasterUseCase
         )
+        registry.register_use_case(
+            "retail", "footfall", FootFallUseCase
+        )
 
         # Put all IMAGE based usecases here
         registry.register_use_case(

matrice_analytics/post_processing/usecases/__init__.py

@@ -85,6 +85,8 @@ from .pcb_defect_detection import PCBDefectConfig, PCBDefectUseCase
 from .underground_pipeline_defect_detection import UndergroundPipelineDefectConfig,UndergroundPipelineDefectUseCase
 from .suspicious_activity_detection import SusActivityConfig, SusActivityUseCase
 from .natural_disaster import NaturalDisasterConfig, NaturalDisasterUseCase
+from .footfall import FootFallConfig, FootFallUseCase
+
 
 #Put all IMAGE based usecases here
 from .blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -172,6 +174,7 @@ __all__ = [
     'UndergroundPipelineDefectUseCase',
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
+    'FootFallUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',
@@ -254,7 +257,7 @@ __all__ = [
     'PCBDefectConfig',
     'SusActivityConfig',
     'NaturalDisasterConfig',
-
+    'FootFallConfig',
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',