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

matrice_analytics/post_processing/config.py

@@ -53,7 +53,9 @@ APP_NAME_TO_USECASE = {
     "abandoned_object_detection" : "abandoned_object_detection",
     "gas_leak_detection": "gas_leak_detection",
     "color_detection": "color_detection",
+    "Color Detection": "color_detection",
     "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
     "cell_microscopy_segmentation": "cell_microscopy_segmentation",
     "Dwell Detection": "dwell",
     "age_gender_detection": "age_gender_detection",
@@ -120,7 +122,9 @@ APP_NAME_TO_CATEGORY = {
     "abandoned_object_detection" : "security",
     "gas_leak_detection": "oil_gas",
     "color_detection": "visual_appearance",
+    "Color Detection": "visual_appearance",
     "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
     "cell_microscopy_segmentation" : "healthcare",
     "Dwell Detection": "general",
     "age_gender_detection": "age_gender_detection",

matrice_analytics/post_processing/core/config.py

@@ -10,10 +10,13 @@ from typing import Any, Dict, List, Optional, Union, get_type_hints
 from pathlib import Path
 import json
 import yaml
+import logging
 from abc import ABC, abstractmethod
 
 from .base import ConfigProtocol
 
+logger = logging.getLogger(__name__)
+
 
 class ConfigValidationError(Exception):
     """Raised when configuration validation fails."""
@@ -786,6 +789,43 @@ class PeopleTrackingConfig:
         return errors
 
 
+def filter_config_kwargs(config_class: type, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Filter kwargs to only include parameters that are valid for the config class.
+    
+    Args:
+        config_class: The config class to create
+        kwargs: Dictionary of parameters to filter
+        
+    Returns:
+        Dict[str, Any]: Filtered kwargs containing only valid parameters
+    """
+    if not hasattr(config_class, '__dataclass_fields__'):
+        # Not a dataclass, return kwargs as-is
+        return kwargs
+    
+    # Get valid field names from the dataclass
+    valid_fields = set(config_class.__dataclass_fields__.keys())
+    
+    # Filter kwargs to only include valid fields
+    filtered_kwargs = {}
+    ignored_params = []
+    
+    for key, value in kwargs.items():
+        if key in valid_fields:
+            filtered_kwargs[key] = value
+        else:
+            ignored_params.append(key)
+    
+    # Log ignored parameters for debugging
+    if ignored_params:
+        logger.debug(
+            f"Ignoring non-config parameters for {config_class.__name__}: {ignored_params}"
+        )
+    
+    return filtered_kwargs
+
+
 class ConfigManager:
     """Centralized configuration management for post-processing operations."""
     
@@ -1423,6 +1463,19 @@ class ConfigManager:
         except ImportError:
             return None
 
+    def _filter_kwargs_for_config(self, config_class: type, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Filter kwargs to only include valid parameters for the config class.
+        
+        Args:
+            config_class: The config class
+            kwargs: Dictionary of parameters
+            
+        Returns:
+            Filtered kwargs
+        """
+        return filter_config_kwargs(config_class, kwargs)
+    
     def create_config(self, usecase: str, category: Optional[str] = None, **kwargs) -> BaseConfig:
         """
         Create configuration for a specific use case.
@@ -1438,6 +1491,17 @@ class ConfigManager:
         Raises:
             ConfigValidationError: If configuration is invalid
         """
+        # Filter out common non-config parameters that should never be passed to configs
+        common_non_config_params = [
+            'deployment_id', 'stream_key', 'stream_id', 'camera_id', 'server_id',
+            'inference_id', 'timestamp', 'frame_id', 'frame_number', 'request_id',
+            'user_id', 'tenant_id', 'organization_id', 'app_name', 'app_id'
+        ]
+        for param in common_non_config_params:
+            if param in kwargs:
+                logger.debug(f"Removing non-config parameter '{param}' from config creation")
+                kwargs.pop(param, None)
+        
         if usecase == "people_counting":
             # Handle nested configurations
             zone_config = kwargs.pop("zone_config", None)
@@ -1448,12 +1512,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(PeopleCountingConfig, kwargs)
+            
             config = PeopleCountingConfig(
                 category=category or "general",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
 
@@ -1467,12 +1534,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(PeopleTrackingConfig, kwargs)
+            
             config = PeopleTrackingConfig(
                 category=category or "general",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         
         elif usecase == "intrusion_detection":
@@ -1485,12 +1555,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(IntrusionConfig, kwargs)
+            
             config = IntrusionConfig(
                 category=category or "security",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         
         elif usecase == "proximity_detection":
@@ -1503,12 +1576,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ProximityConfig, kwargs)
+            
             config = ProximityConfig(
                 category=category or "security",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase in ["customer_service", "advanced_customer_service"]:
@@ -1521,12 +1597,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(CustomerServiceConfig, kwargs)
+            
             config = CustomerServiceConfig(
                 category=category or "sales",
                 usecase=usecase,
                 tracking_config=tracking_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "basic_counting_tracking":
             # Import here to avoid circular import
@@ -1552,6 +1631,9 @@ class ConfigManager:
             alert_cooldown = kwargs.pop("alert_cooldown", 60.0)
             enable_unique_counting = kwargs.pop("enable_unique_counting", True)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(BasicCountingTrackingConfig, kwargs)
+            
             config = BasicCountingTrackingConfig(
                 category=category or "general",
                 usecase=usecase,
@@ -1564,7 +1646,7 @@ class ConfigManager:
                 zone_thresholds=zone_thresholds,
                 alert_cooldown=alert_cooldown,
                 enable_unique_counting=enable_unique_counting,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "license_plate_detection":
             # Import here to avoid circular import
@@ -1575,11 +1657,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LicensePlateConfig, kwargs)
+            
             config = LicensePlateConfig(
                 category=category or "vehicle",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "parking_space_detection":
             # Import here to avoid circular import
@@ -1590,11 +1675,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ParkingSpaceConfig, kwargs)
+            
             config = ParkingSpaceConfig(
                 category=category or "parking_space",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "field_mapping":
             # Import here to avoid circular import
@@ -1605,11 +1693,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(FieldMappingConfig, kwargs)
+            
             config = FieldMappingConfig(
                 category=category or "infrastructure",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase == "leaf_disease_detection":
@@ -1621,6 +1712,9 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LeafDiseaseDetectionConfig, kwargs)
+
             config = LeafDiseaseDetectionConfig(
                 category=category or "agriculture",
                 usecase=usecase,
@@ -1964,11 +2058,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ColorDetectionConfig, kwargs)
+
             config = ColorDetectionConfig(
                 category=category or "visual_appearance",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "video_color_classification":
             # Alias for color_detection - Import here to avoid circular import
@@ -1979,11 +2076,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ColorDetectionConfig, kwargs)
+
             config = ColorDetectionConfig(
                 category=category or "visual_appearance",
                 usecase="color_detection",  # Use canonical name internally
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "ppe_compliance_detection":
             # Import here to avoid circular import
@@ -2478,11 +2578,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LicensePlateMonitorConfig, kwargs)
+            
             config = LicensePlateMonitorConfig(
                 category=category or "license_plate_monitor",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase == "dwell":

matrice_analytics/post_processing/face_reg/embedding_manager.py

@@ -46,6 +46,10 @@ class EmbeddingConfig:
     # Search settings
     search_limit: int = 5
     search_collection: str = "staff_enrollment"
+    
+    # Background embedding refresh settings
+    enable_background_refresh: bool = True
+    background_refresh_interval: int = 600  # Refresh embeddings every 10 minutes (600 seconds)
 
 
 class EmbeddingManager:
@@ -76,10 +80,93 @@ class EmbeddingManager:
         self._cache_lock = threading.Lock()
         self._embeddings_lock = threading.Lock()
         
+        # Background refresh thread
+        self._refresh_thread = None
+        self._is_running = False
+        self._stop_event = threading.Event()
+        
+        # Start background refresh if enabled
+        if self.config.enable_background_refresh and self.face_client:
+            self.start_background_refresh()
+            self.logger.info(f"Background embedding refresh enabled - interval: {self.config.background_refresh_interval}s")
+        
     def set_face_client(self, face_client: FacialRecognitionClient):
         """Set the face recognition client."""
         self.face_client = face_client
         
+        # Start background refresh if it wasn't started yet
+        if self.config.enable_background_refresh and not self._is_running:
+            self.start_background_refresh()
+            self.logger.info("Background embedding refresh started after setting face client")
+    
+    def start_background_refresh(self):
+        """Start the background embedding refresh thread"""
+        if not self._is_running and self.face_client:
+            self._is_running = True
+            self._stop_event.clear()
+            self._refresh_thread = threading.Thread(
+                target=self._run_refresh_loop, daemon=True, name="EmbeddingRefreshThread"
+            )
+            self._refresh_thread.start()
+            self.logger.info("Started background embedding refresh thread")
+    
+    def stop_background_refresh(self):
+        """Stop the background embedding refresh thread"""
+        if self._is_running:
+            self.logger.info("Stopping background embedding refresh thread...")
+            self._is_running = False
+            self._stop_event.set()
+            if self._refresh_thread:
+                self._refresh_thread.join(timeout=10.0)
+                self.logger.info("Background embedding refresh thread stopped")
+    
+    def _run_refresh_loop(self):
+        """Run the embedding refresh loop in background thread"""
+        import asyncio
+        
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+            # Run initial load
+            self.logger.info("Loading initial staff embeddings in background thread...")
+            loop.run_until_complete(self._load_staff_embeddings())
+            
+            # Periodic refresh loop
+            while self._is_running and not self._stop_event.is_set():
+                try:
+                    # Wait for refresh interval with ability to stop
+                    if self._stop_event.wait(timeout=self.config.background_refresh_interval):
+                        # Stop event was set
+                        break
+                    
+                    if not self._is_running:
+                        break
+                    
+                    # Refresh embeddings
+                    self.logger.info("Refreshing staff embeddings from server...")
+                    success = loop.run_until_complete(self._load_staff_embeddings())
+                    
+                    if success:
+                        self.logger.info("Successfully refreshed staff embeddings in background")
+                    else:
+                        self.logger.warning("Failed to refresh staff embeddings in background")
+                        
+                except Exception as e:
+                    self.logger.error(f"Error in background embedding refresh loop: {e}", exc_info=True)
+                    # Continue loop even on error
+                    time.sleep(60)  # Wait 1 minute before retry on error
+                    
+        except Exception as e:
+            self.logger.error(f"Fatal error in background refresh thread: {e}", exc_info=True)
+        finally:
+            try:
+                loop.close()
+            except:
+                pass
+            self.logger.info("Background embedding refresh loop ended")
+        
     async def _load_staff_embeddings(self) -> bool:
         """Load all staff embeddings from API and cache them."""
         if not self.face_client:
@@ -685,4 +772,11 @@ class EmbeddingManager:
             self.logger.warning(f"Unknown detection type: {search_result.detection_type}")
             return None
             
-        return detection
+        return detection
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        try:
+            self.stop_background_refresh()
+        except:
+            pass

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -15,6 +15,7 @@ Configuration options:
 - cache_ttl: Cache time-to-live in seconds (default: 3600)
 """
 import subprocess
+import logging
 import asyncio
 import os
 log_file = open("pip_jetson_btii.log", "w")
@@ -93,6 +94,7 @@ class TemporalIdentityManager:
         switch_patience: int = 5,
         fallback_margin: float = 0.05,
     ) -> None:
+        self.logger = logging.getLogger(__name__)
         self.face_client = face_client
         self.threshold = float(recognition_threshold)
         self.history_size = int(history_size)
@@ -436,12 +438,14 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         self._default_config = config
         self._initialized = False
         
-        asyncio.run(self.initialize(config))
+        # Don't call asyncio.run() in __init__ - it will fail if called from async context
+        # Initialization must be done by calling await initialize(config) after instantiation
+        # This is handled in PostProcessor._get_use_case_instance()
 
     async def initialize(self, config: Optional[FaceRecognitionEmbeddingConfig] = None) -> None:
         """
-        Async initialization method to set up face client and deployment update.
-        Should be called after __init__ to perform async setup operations.
+        Async initialization method to set up face client and all components.
+        Must be called after __init__ before process() can be called.
         
         Args:
             config: Optional config to use. If not provided, uses config from __init__.
@@ -454,25 +458,53 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         init_config = config or self._default_config
         
         if not init_config:
-            self.logger.warning("No config provided for initialization, will initialize on first process() call")
-            return
+            raise ValueError("No config provided for initialization - config is required")
             
         # Validate config type
         if not isinstance(init_config, FaceRecognitionEmbeddingConfig):
-            self.logger.warning(f"Invalid config type for initialization: {type(init_config)}, skipping early initialization")
-            return
+            raise TypeError(f"Invalid config type for initialization: {type(init_config)}, expected FaceRecognitionEmbeddingConfig")
             
         self.logger.info("Initializing face recognition use case with provided config")
         
         # Initialize face client (includes deployment update)
         try:
             self.face_client = await self._get_facial_recognition_client(init_config)
+            
+            # Initialize People activity logging if enabled
+            if init_config.enable_people_activity_logging:
+                self.people_activity_logging = PeopleActivityLogging(self.face_client)
+                self.people_activity_logging.start_background_processing()
+                self.logger.info("People activity logging enabled and started")
+            
+            # Initialize EmbeddingManager
+            if not init_config.embedding_config:
+                init_config.embedding_config = EmbeddingConfig(
+                    similarity_threshold=init_config.similarity_threshold,
+                    confidence_threshold=init_config.confidence_threshold,
+                    enable_track_id_cache=init_config.enable_track_id_cache,
+                    cache_max_size=init_config.cache_max_size,
+                    cache_ttl=3600
+                )
+            self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
+            self.logger.info("Embedding manager initialized")
+            
+            # Initialize TemporalIdentityManager
+            self.temporal_identity_manager = TemporalIdentityManager(
+                face_client=self.face_client,
+                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._initialized = True
-            self.logger.info("Face recognition use case initialized successfully")
+            self.logger.info("Face recognition use case fully initialized")
             
         except Exception as e:
             self.logger.error(f"Error during use case initialization: {e}", exc_info=True)
-            # Don't mark as initialized so it can retry during process()
+            raise RuntimeError(f"Failed to initialize face recognition use case: {e}") from e
 
     async def _get_facial_recognition_client(
         self, config: FaceRecognitionEmbeddingConfig
@@ -540,47 +572,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             )
             context = ProcessingContext()
 
-        # Ensure initialization is complete (handles lazy initialization if not done earlier)
+        # Ensure use case is initialized (should be done in _get_use_case_instance, not lazy loaded)
         if not self._initialized:
-            await self.initialize(config)
-        
-        # Fallback: If initialization failed but we still need face_client, try to initialize it
-        if not self.face_client:
-            self.face_client = await self._get_facial_recognition_client(config)
+            raise RuntimeError(
+                "Face recognition use case not initialized. "
+                "This should be initialized eagerly in PostProcessor._get_use_case_instance()"
+            )
 
         # Ensure confidence threshold is set
         if not config.confidence_threshold:
             config.confidence_threshold = 0.35
-        
-        # Ensure People activity logging is initialized if enabled
-        if config.enable_people_activity_logging and not self.people_activity_logging:
-            self.people_activity_logging = PeopleActivityLogging(self.face_client)
-            self.people_activity_logging.start_background_processing()
-            self.logger.info("People activity logging enabled and started")
-
-        # Ensure EmbeddingManager is initialized
-        if not self.embedding_manager:
-            # Create default embedding config if not provided
-            if not config.embedding_config:
-                config.embedding_config = EmbeddingConfig(
-                    similarity_threshold=config.similarity_threshold,
-                    confidence_threshold=config.confidence_threshold,
-                    enable_track_id_cache=config.enable_track_id_cache,
-                    cache_max_size=config.cache_max_size,
-                    cache_ttl=3600
-                )
-            self.embedding_manager = EmbeddingManager(config.embedding_config, self.face_client)
-
-        # Ensure TemporalIdentityManager is initialized (top-1 via API with smoothing)
-        if not self.temporal_identity_manager:
-            self.temporal_identity_manager = TemporalIdentityManager(
-                face_client=self.face_client,
-                recognition_threshold=float(config.similarity_threshold),
-                history_size=20,
-                unknown_patience=7,
-                switch_patience=5,
-                fallback_margin=0.05,
-            )
 
         
         # Detect input format and store in context
@@ -1957,3 +1958,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 self.people_activity_logging.stop_background_processing()
         except:
             pass
+        
+        try:
+            if hasattr(self, "embedding_manager") and self.embedding_manager:
+                self.embedding_manager.stop_background_refresh()
+        except:
+            pass

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -284,9 +284,10 @@ class FacialRecognitionClient:
                                   location: str,
                                   employee_id: Optional[str] = None,
                                   timestamp: str = datetime.now(timezone.utc).isoformat(),
-                                  ) -> str:
+                                  image_data: Optional[str] = None,
+                                  ) -> Dict[str, Any]:
         """
-        Store people activity data and return response with potential upload URLs
+        Store people activity data with optional image data
         
         API: POST /v1/facial_recognition/store_people_activity?projectId={projectId}&serverID={serverID}
         
@@ -297,10 +298,10 @@ class FacialRecognitionClient:
             location: Location identifier
             employee_id: Employee ID (for unknown faces, this will be generated)
             timestamp: Timestamp in ISO format
+            image_data: Base64-encoded JPEG image data (optional)
             
         Returns:
-            Dict containing response data including uploadUrl and employeeId for unknown faces,
-            or None if the request failed
+            Dict containing response data with success status
         """
         activity_request = {
             "staff_id": staff_id,
@@ -316,7 +317,11 @@ class FacialRecognitionClient:
         elif detection_type == "known" and employee_id:
             activity_request["employee_id"] = employee_id
         
-        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}")
+        # Add image data if provided
+        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}")
         
         try:
@@ -329,18 +334,14 @@ class FacialRecognitionClient:
             handled_response = self._handle_response(response)
             
             if handled_response.get("success", False):
-                data = handled_response.get("data", {})
                 self.logger.info(f"API RESPONSE: Successfully stored {detection_type} activity for staff_id={staff_id}")
-                if not data:
-                    self.logger.warning(f"No data returned from store people activity for staff_id={staff_id}")
-                    return None
-                return data
+                return handled_response
             else:
                 self.logger.warning(f"Failed to store {detection_type} activity: {handled_response.get('error', 'Unknown error')}")
-                return None
+                return handled_response
         except Exception as e:
             self.logger.error(f"API ERROR: Store people activity request failed - type={detection_type}, staff_id={staff_id} - {e}", exc_info=True)
-            return None
+            return {"success": False, "error": str(e)}
 
     async def update_staff_images(self, image_url: str, employee_id: str) -> Dict[str, Any]:
         """Update staff images with uploaded image URL