matrice-analytics 0.1.97__py3-none-any.whl → 0.1.124__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -63,6 +63,13 @@ except ImportError:
     aioredis = None
     HAS_AIREDIS = False
 
+try:
+    import redis as redis_sync
+    HAS_REDIS_SYNC = True
+except ImportError:
+    redis_sync = None  # type: ignore[assignment]
+    HAS_REDIS_SYNC = False
+
 from ..core.base import (
     BaseProcessor,
     ProcessingContext,
@@ -116,6 +123,13 @@ class RedisFaceMatcher:
     """Handles Redis-based face similarity search."""
 
     ACTION_ID_PATTERN = re.compile(r"^[0-9a-f]{8,}$", re.IGNORECASE)
+    # Shared sync Redis client per-process (avoids asyncio loop binding issues when caller uses asyncio.run per frame)
+    _shared_sync_client = None
+    _shared_sync_client_sig: Optional[Tuple[Any, ...]] = None
+    _shared_sync_client_lock = threading.Lock()
+    # Shared app_deployment_id cache per-process (once resolved, reused across all instances/frames)
+    _shared_app_dep_id: Optional[str] = None
+    _shared_app_dep_id_lock = threading.Lock()
 
     def __init__(
         self,
@@ -148,6 +162,8 @@ class RedisFaceMatcher:
             os.getenv("FACE_RECOG_REDIS_STREAM_MAXLEN", "5000")
         )
         self._redis_client = None  # type: ignore[assignment]
+        self._redis_client_loop_id: Optional[int] = None  # Track which event loop owns the client
+        self._redis_sync_client = None  # sync redis client (loop-agnostic)
         self._redis_connection_params: Optional[Dict[str, Any]] = None
         self._app_deployment_id = os.getenv("APP_DEPLOYMENT_ID")
         self._action_id = (
@@ -156,13 +172,166 @@ class RedisFaceMatcher:
             or self._discover_action_id()
         )
         self._redis_server_id = os.getenv("REDIS_SERVER_ID")
-        self._app_dep_lock = asyncio.Lock()
-        self._session_lock = asyncio.Lock()
-        self._redis_lock = asyncio.Lock()
+        # Locks will be created per-loop to avoid cross-loop issues
+        self._app_dep_lock: Optional[asyncio.Lock] = None
+        self._session_lock: Optional[asyncio.Lock] = None
+        self._redis_lock: Optional[asyncio.Lock] = None
+        self._locks_loop_id: Optional[int] = None
         self._redis_warning_logged = False
 
+    def _get_current_loop_id(self) -> int:
+        """Get a unique identifier for the current running event loop."""
+        try:
+            loop = asyncio.get_running_loop()
+            return id(loop)
+        except RuntimeError:
+            return 0
+
+    def _ensure_locks_for_current_loop(self) -> None:
+        """Ensure locks are created for the current event loop."""
+        current_loop_id = self._get_current_loop_id()
+        if self._locks_loop_id != current_loop_id:
+            # Create new locks for this event loop
+            self._app_dep_lock = asyncio.Lock()
+            self._session_lock = asyncio.Lock()
+            self._redis_lock = asyncio.Lock()
+            self._locks_loop_id = current_loop_id
+
     def is_available(self) -> bool:
-        return HAS_AIREDIS
+        return HAS_REDIS_SYNC or HAS_AIREDIS
+
+    def _get_app_dep_id_sync(self) -> Optional[str]:
+        """
+        Get app_deployment_id from env vars or class-level cache (SYNC - no async calls).
+        
+        This avoids async operations that would fail when asyncio.run() creates a new loop per frame.
+        """
+        # Check instance cache first
+        if self._app_deployment_id:
+            return self._app_deployment_id
+        
+        # Check class-level cache (shared across instances in this process)
+        with self.__class__._shared_app_dep_id_lock:
+            if self.__class__._shared_app_dep_id:
+                self._app_deployment_id = self.__class__._shared_app_dep_id
+                return self._app_deployment_id
+        
+        # Try env var
+        env_app_dep_id = os.getenv("APP_DEPLOYMENT_ID")
+        if env_app_dep_id:
+            self._app_deployment_id = env_app_dep_id
+            with self.__class__._shared_app_dep_id_lock:
+                self.__class__._shared_app_dep_id = env_app_dep_id
+            return self._app_deployment_id
+        
+        return None
+
+    def _get_redis_sync_client(self) -> Optional[Any]:
+        """
+        Get a **synchronous** redis client (SYNC method - no async at all).
+
+        Why sync and why no async calls?
+        - The py_inference worker calls `asyncio.run()` per frame, creating/closing a new event loop each call.
+        - `redis.asyncio` clients (and asyncio locks) are bound to the loop they were created on.
+        - Any cached async objects become invalid when the loop changes, causing:
+          - "Future attached to a different loop"
+          - "Event loop is closed"
+
+        This method is COMPLETELY SYNC:
+        - Uses only env vars for Redis connection (no async RPC to fetch params)
+        - Uses threading.Lock (not asyncio.Lock) for thread-safety
+        - Creates a sync redis client that is loop-agnostic and safe across frames
+        
+        Required env vars (set at least one):
+        - FACE_RECOG_REDIS_URL or REDIS_URL: Full Redis URL
+        - OR: FACE_RECOG_REDIS_HOST + FACE_RECOG_REDIS_PORT
+        """
+        if not HAS_REDIS_SYNC or redis_sync is None:
+            return None
+
+        # Fast path: already have a cached client for this instance
+        if self._redis_sync_client is not None:
+            return self._redis_sync_client
+
+        # Resolve URL from env vars (NO async calls)
+        redis_url = self.redis_url
+        if not redis_url:
+            redis_url = os.getenv("FACE_RECOG_REDIS_URL") or os.getenv("REDIS_URL")
+        if not redis_url:
+            host = os.getenv("FACE_RECOG_REDIS_HOST")
+            port = os.getenv("FACE_RECOG_REDIS_PORT")
+            if host and port:
+                redis_url = f"redis://{host}:{port}/0"
+
+        if not redis_url:
+            # Cannot create sync client without connection info from env
+            # This will fall back to async path (which may fail, but that's expected)
+            self.logger.debug(
+                "No Redis URL/host available from env vars for sync client. "
+                "Set FACE_RECOG_REDIS_URL or FACE_RECOG_REDIS_HOST+FACE_RECOG_REDIS_PORT."
+            )
+            return None
+
+        # Cache the URL for future use
+        self.redis_url = redis_url
+
+        def _env_float(name: str, default: float) -> float:
+            raw = os.getenv(name)
+            if raw is None or raw == "":
+                return float(default)
+            try:
+                return float(raw)
+            except Exception:
+                return float(default)
+
+        # Socket timeouts: keep bounded so a bad redis doesn't stall the worker
+        socket_connect_timeout = max(
+            0.2, _env_float("FACE_RECOG_REDIS_CONNECT_TIMEOUT_S", 1.0)
+        )
+        socket_timeout = max(
+            0.2,
+            _env_float(
+                "FACE_RECOG_REDIS_SOCKET_TIMEOUT_S", float(max(1.0, self.response_timeout))
+            ),
+        )
+
+        sig = ("url", str(redis_url))
+
+        # Use threading.Lock (NOT asyncio.Lock) for process-level sharing
+        with self.__class__._shared_sync_client_lock:
+            if (
+                self.__class__._shared_sync_client is not None
+                and self.__class__._shared_sync_client_sig == sig
+            ):
+                self._redis_sync_client = self.__class__._shared_sync_client
+                return self._redis_sync_client
+
+            # Create new shared client
+            try:
+                client = redis_sync.Redis.from_url(
+                    str(redis_url),
+                    decode_responses=True,
+                    health_check_interval=30,
+                    socket_connect_timeout=socket_connect_timeout,
+                    socket_timeout=socket_timeout,
+                    retry_on_timeout=True,
+                )
+                self.logger.info(
+                    "[SYNC] Created sync Redis client for face matcher: %s",
+                    redis_url,
+                )
+            except Exception as exc:
+                self.logger.error(
+                    "[SYNC] Failed to create sync Redis client for face matcher: %s",
+                    exc,
+                    exc_info=True,
+                )
+                return None
+
+            self.__class__._shared_sync_client = client
+            self.__class__._shared_sync_client_sig = sig
+            self._redis_sync_client = client
+            return self._redis_sync_client
 
     async def match_embedding(
         self,
@@ -172,10 +341,10 @@ class RedisFaceMatcher:
         min_confidence: Optional[float] = None,
     ) -> Optional[RedisFaceMatchResult]:
         """Send embedding to Redis stream and wait for match result."""
-        if not HAS_AIREDIS:
+        if not (HAS_REDIS_SYNC or HAS_AIREDIS):
             if not self._redis_warning_logged:
                 self.logger.warning(
-                    "redis.asyncio not available; skipping Redis face matcher flow"
+                    "redis client not available; skipping Redis face matcher flow"
                 )
                 self._redis_warning_logged = True
             return None
@@ -191,15 +360,43 @@ class RedisFaceMatcher:
             print(f"WARNING: Embedding list has zero length for search_id={search_id}")
             return None
 
-        app_dep_id = await self._ensure_app_deployment_id()
-        if not app_dep_id:
-            return None
+        resolved_search_id = str(search_id or self._generate_search_id())
 
-        redis_client = await self._ensure_redis_client()
-        if redis_client is None:
-            return None
+        # ============================================================
+        # Preferred: SYNC redis client (loop-agnostic, safe when caller
+        # uses asyncio.run() per frame and closes the loop each call).
+        # This method is COMPLETELY SYNC - no async calls at all.
+        # ============================================================
+        redis_client_sync = None
+        if HAS_REDIS_SYNC:
+            try:
+                redis_client_sync = self._get_redis_sync_client()
+            except Exception:
+                redis_client_sync = None
+
+        # Get app_dep_id - for SYNC path, use only cached/env values (no async calls)
+        app_dep_id: Optional[str] = None
+        if redis_client_sync is not None:
+            # SYNC path: get app_dep_id from cache or env only (no async)
+            app_dep_id = self._get_app_dep_id_sync()
+            if not app_dep_id:
+                self.logger.warning(
+                    "[SYNC] Cannot get app_deployment_id from env/cache. "
+                    "Set APP_DEPLOYMENT_ID env var or ensure it was resolved previously."
+                )
+                # Fall back to async path below
+                redis_client_sync = None
+
+        # If we don't have sync client (or couldn't get app_dep_id sync), use async path
+        if redis_client_sync is None:
+            app_dep_id = await self._ensure_app_deployment_id()
+            if not app_dep_id:
+                return None
+            # Cache for future sync calls
+            with self.__class__._shared_app_dep_id_lock:
+                if self.__class__._shared_app_dep_id is None:
+                    self.__class__._shared_app_dep_id = app_dep_id
 
-        resolved_search_id = str(search_id or self._generate_search_id())
         payload = {
             "appDepId": app_dep_id,
             "searchId": resolved_search_id,
@@ -210,6 +407,163 @@ class RedisFaceMatcher:
             ),
         }
 
+        if redis_client_sync is not None:
+            try:
+                self.logger.debug(
+                    f"[SYNC] Sending embedding to Redis stream {self.stream_name} with search_id={resolved_search_id}, "
+                    f"embedding_len={len(embedding_list)}, minConfidence={payload.get('minConfidence')}"
+                )
+                redis_client_sync.xadd(
+                    self.stream_name,
+                    {"data": json.dumps(payload, separators=(",", ":"))},
+                    maxlen=self.stream_maxlen,
+                    approximate=True,
+                )
+                self.logger.debug(
+                    f"[SYNC] Successfully sent embedding to Redis stream for search_id={resolved_search_id}"
+                )
+            except Exception as exc:
+                self.logger.error(
+                    "[SYNC] Failed to enqueue face embedding to Redis stream %s: %s",
+                    self.stream_name,
+                    exc,
+                    exc_info=True,
+                )
+                return None
+
+            result_key = f"{resolved_search_id}_{app_dep_id}"
+            deadline = time.monotonic() + self.response_timeout
+            poll_count = 0
+            start_poll_time = time.monotonic()
+
+            self.logger.debug(
+                f"[SYNC] Waiting for Redis response with key={result_key}, timeout={self.response_timeout:.3f}s"
+            )
+
+            while time.monotonic() < deadline:
+                try:
+                    raw_value = redis_client_sync.get(result_key)
+                    poll_count += 1
+                except Exception as exc:
+                    self.logger.error(
+                        "[SYNC] Failed to read Redis result for key %s: %s",
+                        result_key,
+                        exc,
+                        exc_info=True,
+                    )
+                    return None
+
+                if raw_value:
+                    try:
+                        redis_client_sync.delete(result_key)
+                    except Exception:
+                        pass
+
+                    try:
+                        parsed = json.loads(raw_value)
+                    except Exception as exc:
+                        self.logger.error(
+                            "[SYNC] Unable to parse Redis face match response: %s",
+                            exc,
+                            exc_info=True,
+                        )
+                        return None
+
+                    # Log and print the raw Redis response for debugging
+                    self.logger.info(
+                        f"[SYNC] Redis raw response for search_id={resolved_search_id}: {parsed}"
+                    )
+
+                    match_data = None
+                    if isinstance(parsed, list) and parsed:
+                        match_data = parsed[0]
+                    elif isinstance(parsed, dict):
+                        match_data = parsed
+                    else:
+                        self.logger.warning(
+                            "[SYNC] Redis response is neither list nor dict: %s, value: %s",
+                            type(parsed),
+                            parsed,
+                        )
+
+                    if not isinstance(match_data, dict):
+                        self.logger.warning(
+                            "[SYNC] match_data is not a dict after extraction: %s, value: %s",
+                            type(match_data),
+                            match_data,
+                        )
+                        return None
+
+                    staff_id = match_data.get("staffId") or match_data.get("staff_id")
+                    if not staff_id:
+                        self.logger.warning(
+                            "[SYNC] No staffId found in match_data: %s", match_data
+                        )
+                        return None
+
+                    person_name = str(match_data.get("name") or "Unknown")
+                    confidence = float(
+                        match_data.get("conf") or match_data.get("confidence") or 0.0
+                    )
+                    employee_id = match_data.get("employeeId") or match_data.get(
+                        "embeddingId"
+                    )
+
+                    min_conf = float(
+                        min_confidence
+                        if min_confidence is not None
+                        else self.default_min_confidence
+                    )
+                    if confidence < min_conf:
+                        self.logger.debug(
+                            "[SYNC] Redis match confidence %.3f below threshold %.3f, rejecting",
+                            confidence,
+                            min_conf,
+                        )
+                        return None
+
+                    result = RedisFaceMatchResult(
+                        staff_id=str(staff_id),
+                        person_name=person_name,
+                        confidence=round(confidence, 3),
+                        employee_id=str(employee_id) if employee_id else None,
+                        raw=match_data,
+                    )
+
+                    poll_time = (time.monotonic() - start_poll_time) * 1000.0
+                    self.logger.info(
+                        "[SYNC] Redis match result created (polls=%d, poll_time=%.2fms): staff_id=%s, name=%s, conf=%.3f",
+                        poll_count,
+                        poll_time,
+                        result.staff_id,
+                        result.person_name,
+                        result.confidence,
+                    )
+                    return result
+
+                time.sleep(self.poll_interval)
+
+            poll_time = (time.monotonic() - start_poll_time) * 1000.0
+            self.logger.warning(
+                "[SYNC] Timed out waiting for Redis face match result for key %s (timeout=%.3fs, polls=%d, poll_time=%.2fms)",
+                result_key,
+                self.response_timeout,
+                poll_count,
+                poll_time,
+            )
+            return None
+
+        # ============================================================
+        # Fallback: ASYNC redis client (kept for environments where
+        # sync redis is unavailable).
+        # ============================================================
+        if not HAS_AIREDIS:
+            return None
+
+        redis_client = await self._ensure_redis_client()
+        if redis_client is None:
+            return None
+
         try:
             self.logger.debug(
                 f"Sending embedding to Redis stream {self.stream_name} with search_id={resolved_search_id}, "
@@ -222,6 +576,44 @@ class RedisFaceMatcher:
                 approximate=True,
             )
             self.logger.debug(f"Successfully sent embedding to Redis stream for search_id={resolved_search_id}")
+        except RuntimeError as exc:
+            # Handle event loop closed/mismatch errors - invalidate client and retry once
+            exc_str = str(exc).lower()
+            if "event loop" in exc_str or "different loop" in exc_str or "closed" in exc_str:
+                self.logger.warning(
+                    "Redis client event loop error detected, invalidating client and retrying: %s", exc
+                )
+                # Invalidate the client so next call recreates it
+                self._redis_client = None
+                self._redis_client_loop_id = None
+                # Retry once with fresh client
+                try:
+                    redis_client = await self._ensure_redis_client()
+                    if redis_client:
+                        await redis_client.xadd(
+                            self.stream_name,
+                            {"data": json.dumps(payload, separators=(",", ":"))},
+                            maxlen=self.stream_maxlen,
+                            approximate=True,
+                        )
+                        self.logger.info(f"Successfully sent embedding after client refresh for search_id={resolved_search_id}")
+                    else:
+                        self.logger.error("Failed to recreate Redis client after event loop error")
+                        return None
+                except Exception as retry_exc:
+                    self.logger.error(
+                        "Retry also failed after Redis client refresh: %s", retry_exc, exc_info=True
+                    )
+                    return None
+            else:
+                self.logger.error(
+                    "Failed to enqueue face embedding to Redis stream %s: %s",
+                    self.stream_name,
+                    exc,
+                    exc_info=True,
+                )
+                print(f"ERROR: Failed to send to Redis stream {self.stream_name}: {exc}")
+                return None
         except Exception as exc:
             self.logger.error(
                 "Failed to enqueue face embedding to Redis stream %s: %s",
@@ -244,6 +636,24 @@ class RedisFaceMatcher:
             try:
                 raw_value = await redis_client.get(result_key)
                 poll_count += 1
+            except RuntimeError as exc:
+                # Handle event loop errors - invalidate client and return
+                exc_str = str(exc).lower()
+                if "event loop" in exc_str or "different loop" in exc_str or "closed" in exc_str:
+                    self.logger.warning(
+                        "Redis client event loop error in poll loop, invalidating client: %s", exc
+                    )
+                    self._redis_client = None
+                    self._redis_client_loop_id = None
+                    return None
+                self.logger.error(
+                    "Failed to read Redis result for key %s: %s",
+                    result_key,
+                    exc,
+                    exc_info=True,
+                )
+                print(f"ERROR: Failed to read Redis result for key {result_key}: {exc}")
+                return None
             except Exception as exc:
                 self.logger.error(
                     "Failed to read Redis result for key %s: %s",
@@ -374,6 +784,9 @@ class RedisFaceMatcher:
         if self._app_deployment_id:
             return self._app_deployment_id
 
+        # Ensure locks are valid for the current event loop
+        self._ensure_locks_for_current_loop()
+
         async with self._app_dep_lock:
             if self._app_deployment_id:
                 return self._app_deployment_id
@@ -420,6 +833,10 @@ class RedisFaceMatcher:
                 return None
 
             self._app_deployment_id = str(app_dep_id)
+            # Also cache at class level for sync path to use
+            with self.__class__._shared_app_dep_id_lock:
+                if self.__class__._shared_app_dep_id is None:
+                    self.__class__._shared_app_dep_id = self._app_deployment_id
             if redis_server_id:
                 self._redis_server_id = str(redis_server_id)
             self.logger.info(
@@ -437,6 +854,9 @@ class RedisFaceMatcher:
                 )
             return self._session
 
+        # Ensure locks are valid for the current event loop
+        self._ensure_locks_for_current_loop()
+
         async with self._session_lock:
             if self._session:
                 return self._session
@@ -469,12 +889,42 @@ class RedisFaceMatcher:
             return self._session
 
     async def _ensure_redis_client(self):
+        # Ensure locks are valid for the current event loop
+        self._ensure_locks_for_current_loop()
+        
+        current_loop_id = self._get_current_loop_id()
+        
+        # Check if we have a client but it was created in a different event loop
+        if self._redis_client is not None and self._redis_client_loop_id != current_loop_id:
+            self.logger.warning(
+                "Redis client was created in a different event loop (old=%s, current=%s). Recreating client.",
+                self._redis_client_loop_id,
+                current_loop_id,
+            )
+            # Close old client safely (ignore errors since the loop may be closed)
+            try:
+                await self._redis_client.close()
+            except Exception:
+                pass
+            self._redis_client = None
+            self._redis_client_loop_id = None
+
         if self._redis_client:
             return self._redis_client
 
         async with self._redis_lock:
-            if self._redis_client:
+            # Double-check after acquiring lock
+            if self._redis_client is not None and self._redis_client_loop_id == current_loop_id:
                 return self._redis_client
+            
+            # Reset client if loop mismatch detected inside lock
+            if self._redis_client is not None and self._redis_client_loop_id != current_loop_id:
+                try:
+                    await self._redis_client.close()
+                except Exception:
+                    pass
+                self._redis_client = None
+                self._redis_client_loop_id = None
 
             if not self.redis_url:
                 host = os.getenv("FACE_RECOG_REDIS_HOST")
@@ -489,10 +939,12 @@ class RedisFaceMatcher:
                         decode_responses=True,
                         health_check_interval=30,
                     )
+                    self._redis_client_loop_id = current_loop_id
                     self.logger.info(
-                        "Connected Redis face matcher client to %s (stream=%s)",
+                        "Connected Redis face matcher client to %s (stream=%s, loop_id=%s)",
                         self.redis_url,
                         self.stream_name,
+                        current_loop_id,
                     )
                     return self._redis_client
                 except Exception as exc:
@@ -503,6 +955,7 @@ class RedisFaceMatcher:
                         exc_info=True,
                     )
                     self._redis_client = None
+                    self._redis_client_loop_id = None
 
             conn_params = await self._ensure_redis_connection_params()
             if not conn_params:
@@ -525,12 +978,14 @@ class RedisFaceMatcher:
                     retry_on_timeout=True,
                     health_check_interval=30,
                 )
+                self._redis_client_loop_id = current_loop_id
                 self.logger.info(
-                    "Connected Redis face matcher client to %s:%s (db=%s, stream=%s)",
+                    "Connected Redis face matcher client to %s:%s (db=%s, stream=%s, loop_id=%s)",
                     conn_params.get("host"),
                     conn_params.get("port"),
                     conn_params.get("db"),
                     self.stream_name,
+                    current_loop_id,
                 )
             except Exception as exc:
                 self.logger.error(
@@ -539,6 +994,7 @@ class RedisFaceMatcher:
                     exc_info=True,
                 )
                 self._redis_client = None
+                self._redis_client_loop_id = None
 
             return self._redis_client
 
@@ -659,7 +1115,7 @@ class TemporalIdentityManager:
         face_client: FacialRecognitionClient,
         embedding_manager=None,
         redis_matcher: Optional[RedisFaceMatcher] = None,
-        recognition_threshold: float = 0.3,
+        recognition_threshold: float = 0.15,
         history_size: int = 20,
         unknown_patience: int = 7,
         switch_patience: int = 5,
@@ -1081,9 +1537,9 @@ class FaceRecognitionEmbeddingConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     # Base confidence threshold (separate from embedding similarity threshold)
-    similarity_threshold: float = 0.3  # Lowered to match local code - 0.45 was too conservative
+    similarity_threshold: float = 0.45  # 0.3 Lowered to match local code - 0.45 was too conservative
     # Base confidence threshold (separate from embedding similarity threshold)
-    confidence_threshold: float = 0.06  # Detection confidence threshold
+    confidence_threshold: float = 0.1  # 0.06  Detection confidence threshold
     
     # Face recognition optional features
     enable_face_tracking: bool = True  # Enable BYTE TRACKER advanced face tracking -- KEEP IT TRUE ALWAYS
@@ -1345,6 +1801,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         """
         Extract camera_name, camera_id, and location_id from stream_info.
         
+        Handles multiple sources and shapes for camera_id/camera_name/location_id to ensure
+        correct extraction even when a single container is connected to multiple camera streams.
+        
+        Supported stream_info shapes (seen across pipeline/components):
+        - stream_info["camera_info"]
+        - stream_info["input_settings"]["camera_info"]
+        - stream_info["input_settings"]["input_stream"]["camera_info"]
+        - stream_info["input_streams"][i]["input_stream"]["camera_info"]
+        - camera_id derived from stream_info["topic"] suffix markers ("_input_topic" or "_input-topic")
+        
         Args:
             stream_info: Stream information dictionary
             
@@ -1355,22 +1821,201 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         camera_id = ""
         location_id = ""
         
-        if not stream_info:
+        if not stream_info or not isinstance(stream_info, dict):
+            self.logger.debug("stream_info is None/invalid, returning empty camera info")
             return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
-        
-        # Extract camera_name from camera_info
-        camera_info = stream_info.get("camera_info", {})
-        if camera_info:
-            camera_name = camera_info.get("camera_name", "")
-            location_id = camera_info.get("location", "")
-        
-        # Extract camera_id from topic (format: {camera_id}_input_topic)
-        topic = stream_info.get("topic", "")
-        if topic and "_input_topic" in topic:
-            camera_id = topic.replace("_input_topic", "")
-        
-        self.logger.debug(f"Extracted camera info - camera_name: '{camera_name}', camera_id: '{camera_id}', location_id: '{location_id}'")
-        
+
+        def _to_str(value: Any) -> str:
+            """Convert common stream-info values to a safe string."""
+            if value is None:
+                return ""
+            if isinstance(value, str):
+                return value.strip()
+            if isinstance(value, (int, float)):
+                return str(value)
+            if isinstance(value, dict):
+                return ""
+            if isinstance(value, (list, tuple, set)):
+                for item in value:
+                    s = _to_str(item)
+                    if s:
+                        return s
+                return ""
+            try:
+                return str(value).strip()
+            except Exception:
+                return ""
+
+        def _dict_get_str(d: Any, *keys: str) -> str:
+            """Get first non-empty key from dict as string."""
+            if not isinstance(d, dict):
+                return ""
+            for k in keys:
+                val = _to_str(d.get(k))
+                if val:
+                    return val
+            return ""
+
+        def _extract_camera_id_from_topic(topic_val: Any) -> str:
+            """Extract camera_id from topic formats like '{camera_id}_input_topic' or '{camera_id}_input-topic'."""
+            topic = _to_str(topic_val)
+            if not topic:
+                return ""
+            for suffix in ("_input_topic", "_input-topic"):
+                if topic.endswith(suffix):
+                    return topic[: -len(suffix)].strip()
+            for marker in ("_input_topic", "_input-topic"):
+                if marker in topic:
+                    return topic.split(marker)[0].strip()
+            return ""
+
+        def _extract_camera_id_from_frame_id(frame_id_val: Any) -> str:
+            """
+            Best-effort fallback: extract a stable camera/stream identifier from frame_id.
+
+            Observed upstream format (py_inference legacy mode):
+              - 'legacy_{hexId}_{suffix}'
+            Example:
+              - 'legacy_694e7603a086e13d9c95dd3d_51b30e93'
+
+            We ONLY accept the middle segment if it looks like a hex identifier (>= 8 chars)
+            to avoid mis-parsing arbitrary frame_id formats.
+            """
+            fid = _to_str(frame_id_val)
+            if not fid:
+                return ""
+            if fid.startswith("legacy_"):
+                parts = fid.split("_")
+                if len(parts) >= 3:
+                    candidate = parts[1].strip()
+                    if candidate and re.fullmatch(r"[0-9a-f]{8,}", candidate, re.IGNORECASE):
+                        return candidate
+            return ""
+
+        input_settings = stream_info.get("input_settings") or {}
+        if not isinstance(input_settings, dict):
+            input_settings = {}
+
+        camera_info_root = stream_info.get("camera_info") or {}
+        if not isinstance(camera_info_root, dict):
+            camera_info_root = {}
+
+        camera_info_input_settings = input_settings.get("camera_info") or {}
+        if not isinstance(camera_info_input_settings, dict):
+            camera_info_input_settings = {}
+
+        input_stream = input_settings.get("input_stream") or {}
+        if not isinstance(input_stream, dict):
+            input_stream = {}
+
+        camera_info_input_stream = input_stream.get("camera_info") or {}
+        if not isinstance(camera_info_input_stream, dict):
+            camera_info_input_stream = {}
+
+        input_streams = stream_info.get("input_streams") or []
+        input_stream_candidates: List[Dict[str, Any]] = []
+        camera_info_input_streams: List[Dict[str, Any]] = []
+        if isinstance(input_streams, list):
+            for item in input_streams:
+                if not isinstance(item, dict):
+                    continue
+                inner = item.get("input_stream", item)
+                if not isinstance(inner, dict):
+                    continue
+                input_stream_candidates.append(inner)
+                ci = inner.get("camera_info") or {}
+                if isinstance(ci, dict) and ci:
+                    camera_info_input_streams.append(ci)
+
+        topic_camera_id = (
+            _extract_camera_id_from_topic(stream_info.get("topic"))
+            or _extract_camera_id_from_topic(input_settings.get("topic"))
+        )
+        if not topic_camera_id:
+            topics_val = stream_info.get("topics")
+            if isinstance(topics_val, (list, tuple, set)):
+                for t in topics_val:
+                    topic_camera_id = _extract_camera_id_from_topic(t)
+                    if topic_camera_id:
+                        break
+
+        camera_info_sources: List[Dict[str, Any]] = [
+            camera_info_root,
+            camera_info_input_settings,
+            camera_info_input_stream,
+        ] + camera_info_input_streams
+
+        def _camera_id_from_camera_info(ci: Dict[str, Any]) -> str:
+            return _dict_get_str(ci, "camera_id", "cameraId", "_id", "id")
+
+        matched_ci: Dict[str, Any] = {}
+        if topic_camera_id:
+            camera_id = topic_camera_id
+            for ci in camera_info_sources:
+                if _camera_id_from_camera_info(ci) == camera_id:
+                    matched_ci = ci
+                    break
+
+        if not camera_id:
+            camera_id = (
+                _dict_get_str(stream_info, "camera_id", "cameraId")
+                or _dict_get_str(input_settings, "camera_id", "cameraId")
+                or _camera_id_from_camera_info(camera_info_root)
+                or _camera_id_from_camera_info(camera_info_input_settings)
+                or _camera_id_from_camera_info(camera_info_input_stream)
+            )
+            if not camera_id:
+                for candidate in input_stream_candidates:
+                    camera_id = _dict_get_str(candidate, "camera_id", "cameraId", "_id", "id")
+                    if camera_id:
+                        break
+            if not camera_id:
+                camera_id = topic_camera_id
+
+        # Final fallback: derive camera_id from frame_id if stream_info doesn't include camera_info/topic
+        if not camera_id:
+            camera_id = _extract_camera_id_from_frame_id(stream_info.get("frame_id"))
+
+        # Use matched camera_info (if found) to set camera_name/location_id
+        if matched_ci:
+            camera_name = _dict_get_str(matched_ci, "camera_name", "cameraName", "name")
+            location_id = _dict_get_str(matched_ci, "location", "location_id", "locationId")
+
+        if not camera_name:
+            camera_name = (
+                _dict_get_str(camera_info_root, "camera_name", "cameraName", "name")
+                or _dict_get_str(camera_info_input_settings, "camera_name", "cameraName", "name")
+                or _dict_get_str(camera_info_input_stream, "camera_name", "cameraName", "name")
+                or _dict_get_str(stream_info, "camera_name", "cameraName")
+                or _dict_get_str(input_settings, "camera_name", "cameraName")
+            )
+            if not camera_name:
+                for ci in camera_info_input_streams:
+                    camera_name = _dict_get_str(ci, "camera_name", "cameraName", "name")
+                    if camera_name:
+                        break
+
+        if not location_id:
+            location_id = (
+                _dict_get_str(camera_info_root, "location", "location_id", "locationId")
+                or _dict_get_str(camera_info_input_settings, "location", "location_id", "locationId")
+                or _dict_get_str(camera_info_input_stream, "location", "location_id", "locationId")
+                or _dict_get_str(stream_info, "location_id", "location", "locationId")
+                or _dict_get_str(input_settings, "location_id", "location", "locationId")
+            )
+            if not location_id:
+                for ci in camera_info_input_streams:
+                    location_id = _dict_get_str(ci, "location", "location_id", "locationId")
+                    if location_id:
+                        break
+
+        self.logger.debug(
+            "Extracted camera info - camera_name: '%s', camera_id: '%s', location_id: '%s'",
+            camera_name,
+            camera_id,
+            location_id,
+        )
+
         return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
 
     async def _fetch_location_name(self, location_id: str) -> str:
@@ -2111,7 +2756,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         if not is_truly_unknown and detection_type == "known":
             # Mark recognized and ensure it is not counted as unknown anymore
-            self._track_person(staff_id)
+            self._track_person(staff_id, camera_id=camera_id)
             with self._tracking_lock:
                 if internal_tid is not None:
                     self._unknown_track_ids.discard(internal_tid)
@@ -2178,14 +2823,14 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         detection["error"] = error
         return detection
 
-    def _track_person(self, person_id: str) -> None:
+    def _track_person(self, person_id: str, camera_id: str = "") -> None:
         """Track person with camera ID and UTC timestamp"""
         if person_id not in self.person_tracking:
             self.person_tracking[person_id] = []
 
-        # Add current detection
+        # Add current detection with actual camera_id
         detection_record = {
-            "camera_id": "test_camera_001",  # TODO: Get from stream_info in production
+            "camera_id": camera_id or "",
             "timestamp": datetime.utcnow().isoformat() + "Z",
         }
         self.person_tracking[person_id].append(detection_record)
@@ -2382,44 +3027,32 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             stream_info, precision=True
         )
 
-        # Build total_counts array in expected format
-        total_counts = []
-        for cat, count in total_counts_dict.items():
-            if count > 0:
-                total_counts.append({"category": cat, "count": count})
-
-        # Add face recognition specific total counts
+        # Build total_counts array - only "Recognized Faces" and "Unknown Faces"
+        # Note: We exclude generic "face" category to avoid duplicate/confusing fields
         session_totals = face_summary.get("session_totals", {})
-        total_counts.extend(
-            [
-                {
-                    "category": "recognized_faces",
-                    "count": session_totals.get("total_recognized", 0),
-                },
-                {
-                    "category": "unknown_faces",
-                    "count": session_totals.get("total_unknown", 0),
-                },
-            ]
-        )
-
-        # Build current_counts array in expected format
-        current_counts = []
-        # for cat, count in per_category_count.items():
-        #     if count > 0 or total_detections > 0:
-        #         current_counts.append({"category": cat, "count": count})
+        total_counts = [
+            {
+                "category": "Recognized Faces",
+                "count": session_totals.get("total_recognized", 0),
+            },
+            {
+                "category": "Unknown Faces",
+                "count": session_totals.get("total_unknown", 0),
+            },
+        ]
 
-        # Add face recognition specific current counts
+        # Build current_counts array - only "Recognized Faces" and "Unknown Faces"
         current_frame = face_summary.get("current_frame", {})
-        current_counts.extend(
-            [
-                {
-                    "category": "Recognized Faces",
-                    "count": current_frame.get("recognized", 0),
-                },
-                {"category": "Unknown Faces", "count": current_frame.get("unknown", 0)},
-            ]
-        )
+        current_counts = [
+            {
+                "category": "Recognized Faces",
+                "count": current_frame.get("recognized", 0),
+            },
+            {
+                "category": "Unknown Faces",
+                "count": current_frame.get("unknown", 0),
+            },
+        ]
 
         # Prepare detections with face recognition info
         detections = []