nedo-vision-worker-core 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

nedo_vision_worker_core/__init__.py

@@ -7,7 +7,7 @@ A library for running AI vision processing and detection in the Nedo Vision plat
 from .core_service import CoreService
 from .callbacks import DetectionType, CallbackTrigger, DetectionData, IntervalMetadata
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 __all__ = [
     "CoreService", 
     "DetectionType", 

nedo_vision_worker_core/database/DatabaseManager.py

@@ -121,7 +121,23 @@ class DatabaseManager:
         # Initialize engines and session factories for each database
         for name, path in DB_PATHS.items():
             path.parent.mkdir(parents=True, exist_ok=True)  # Ensure directory exists
-            engine = create_engine(f"sqlite:///{path.as_posix()}")
+            
+            # Configure connection pool for multi-threaded usage
+            # pool_size: Max connections to keep open
+            # max_overflow: Additional connections that can be created temporarily
+            # pool_pre_ping: Test connections before using (prevents stale connections)
+            # pool_recycle: Recycle connections after N seconds (prevents long-lived stale connections)
+            engine = create_engine(
+                f"sqlite:///{path.as_posix()}",
+                pool_size=20,          # Base pool size for persistent connections
+                max_overflow=30,       # Allow up to 30 additional temporary connections
+                pool_pre_ping=True,    # Verify connection health before use
+                pool_recycle=3600,     # Recycle connections after 1 hour
+                connect_args={
+                    "check_same_thread": False,  # Required for SQLite with multiple threads
+                    "timeout": 30.0              # Connection timeout
+                }
+            )
             ENGINES[name] = engine
             SESSION_FACTORIES[name] = scoped_session(sessionmaker(bind=engine))  # Use scoped sessions
             DatabaseManager.synchronize(name)

nedo_vision_worker_core/pipeline/PipelineManager.py

@@ -1,6 +1,5 @@
 import logging
 import threading
-from concurrent.futures import ThreadPoolExecutor, Future
 from typing import Dict
 from .PipelineProcessor import PipelineProcessor
 from ..streams.VideoStreamManager import VideoStreamManager
@@ -9,8 +8,8 @@ class PipelineManager:
     """Manages AI pipeline execution and video stream processing."""
 
     def __init__(self, video_manager: VideoStreamManager, on_pipeline_stopped, max_workers=50):
-        self.executor = ThreadPoolExecutor(max_workers=max_workers)  # Thread pool for parallel execution
-        self.pipeline_threads = {}  # Stores Future objects {pipeline_id: Future}
+        self.max_workers = max_workers
+        self.pipeline_threads = {}  # Stores Thread objects {pipeline_id: Thread}
         self.pipeline_metadata = {}  # Stores actual pipeline data {pipeline_id: metadata}
         self.video_manager = video_manager  # Manages video streams
         self.processors: Dict[str, PipelineProcessor] = {}  # Stores PipelineProcessor instances per pipeline
@@ -39,18 +38,52 @@ class PipelineManager:
 
         logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
 
+        # Acquire the video stream (starts it if not already running)
+        if not self.video_manager.acquire_stream(worker_source_id, pipeline_id):
+            logging.error(f"❌ Failed to acquire stream {worker_source_id} for pipeline {pipeline_id}")
+            return
+
         processor = PipelineProcessor(pipeline, detector, False)
         processor.frame_drawer.location_name = pipeline.location_name
         self.processors[pipeline_id] = processor  # Store processor instance
 
-        future = self.executor.submit(processor.process_pipeline, self.video_manager)
-        self.pipeline_threads[pipeline_id] = future
-        self.pipeline_metadata[pipeline_id] = pipeline
+        active_count = len([t for t in self.pipeline_threads.values() if t.is_alive()])
+        logging.info(f"📋 Starting pipeline {pipeline_id} thread (active threads: {active_count})")
+        
+        try:
+            # Wrap the execution to catch any early errors
+            def _safe_process_pipeline():
+                try:
+                    logging.info(f"🏁 Pipeline {pipeline_id} thread execution beginning...")
+                    processor.process_pipeline(self.video_manager)
+                except Exception as e:
+                    logging.error(f"❌ Unhandled error in pipeline {pipeline_id} thread: {e}", exc_info=True)
+                finally:
+                    # Ensure cleanup callback is called
+                    self._handle_pipeline_completion(pipeline_id)
+            
+            # Create and start thread directly
+            thread = threading.Thread(
+                target=_safe_process_pipeline,
+                name=f"pipeline-{pipeline_id[:8]}",
+                daemon=True
+            )
+            
+            self.pipeline_threads[pipeline_id] = thread
+            self.pipeline_metadata[pipeline_id] = pipeline
+            
+            logging.info(f"⚙️ Starting thread for pipeline {pipeline_id}")
+            thread.start()
+            logging.info(f"✅ Pipeline {pipeline_id} thread started successfully")
 
-        # Add callback to detect when a pipeline finishes
-        future.add_done_callback(lambda f: self._handle_pipeline_completion(pipeline_id, f))
+        except Exception as e:
+            logging.error(f"❌ Failed to start pipeline {pipeline_id} thread: {e}", exc_info=True)
+            # Clean up on failure
+            self.processors.pop(pipeline_id, None)
+            self.video_manager.release_stream(worker_source_id, pipeline_id)
+            raise
 
-    def _handle_pipeline_completion(self, pipeline_id: str, future: Future):
+    def _handle_pipeline_completion(self, pipeline_id: str):
         """
         Handles cleanup when a pipeline finishes processing.
         """
@@ -59,11 +92,7 @@ class PipelineManager:
                 return  # If it's already being stopped manually, don't trigger again
 
         try:
-            if future.cancelled():
-                logging.info(f"🚫 Pipeline {pipeline_id} was cancelled.")
-            elif future.exception():
-                logging.error(f"❌ Pipeline {pipeline_id} encountered an error: {future.exception()}", exc_info=True)
-
+            logging.info(f"🏁 Pipeline {pipeline_id} completed execution")
         except Exception as e:
             logging.error(f"⚠️ Error in handling pipeline {pipeline_id} completion: {e}")
 
@@ -79,19 +108,31 @@ class PipelineManager:
             self._stopping_pipelines.add(pipeline_id)
 
         try:
+            # Get worker_source_id before removing metadata
+            pipeline = self.pipeline_metadata.get(pipeline_id)
+            worker_source_id = pipeline.worker_source_id if pipeline else None
+
             # Stop AI processing
             processor = self.processors.pop(pipeline_id, None)
             if processor:
                 processor.stop()
 
-            # Cancel execution thread
-            future = self.pipeline_threads.pop(pipeline_id, None)
-            if future:
-                future.cancel()
+            # Stop execution thread (thread will terminate naturally)
+            thread = self.pipeline_threads.pop(pipeline_id, None)
+            if thread and thread.is_alive():
+                # Thread is daemon, will stop when processor.running becomes False
+                logging.debug(f"Waiting for pipeline {pipeline_id} thread to terminate...")
+                thread.join(timeout=5.0)
+                if thread.is_alive():
+                    logging.warning(f"Pipeline {pipeline_id} thread did not terminate cleanly")
 
             # Remove metadata
             self.pipeline_metadata.pop(pipeline_id, None)
 
+            # Release the video stream (stops it if no more pipelines use it)
+            if worker_source_id:
+                self.video_manager.release_stream(worker_source_id, pipeline_id)
+
             logging.info(f"✅ Pipeline {pipeline_id} stopped successfully.")
 
         except Exception as e:
@@ -119,7 +160,8 @@ class PipelineManager:
         Returns:
             bool: True if the pipeline is running, False otherwise.
         """
-        return pipeline_id in self.pipeline_threads and not self.pipeline_threads[pipeline_id].done()
+        thread = self.pipeline_threads.get(pipeline_id)
+        return thread is not None and thread.is_alive()
 
     def shutdown(self):
         """Shuts down the pipeline manager gracefully."""
@@ -129,5 +171,7 @@ class PipelineManager:
         for pipeline_id in list(self.pipeline_threads.keys()):
             self.stop_pipeline(pipeline_id)
 
+        logging.info("✅ PipelineManager stopped.")
+
         self.executor.shutdown(wait=True)  # Wait for all threads to finish
         logging.info("✅ PipelineManager stopped.")

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -137,6 +137,7 @@ class PipelineProcessor:
     def process_pipeline(self, video_manager: VideoStreamManager):
         pipeline_id = self.pipeline_id
         worker_source_id = self.worker_source_id
+        
         logging.info(f"🎯 Running pipeline processing for pipeline {pipeline_id} | Source: {worker_source_id}")
 
         self._update_config_internal()
@@ -148,9 +149,6 @@ class PipelineProcessor:
             logging.error(f"❌ Pipeline {pipeline_id} | Source {worker_source_id}: No initial frame available. Exiting...")
             return
 
-        # Start RTMP (internal pacer thread will begin on first push_frame())
-        self.rtmp_streamer = RTMPStreamer(pipeline_id)
-
         # Start detection thread
         self.detection_thread = threading.Thread(
             target=self._detection_worker,
@@ -204,20 +202,27 @@ class PipelineProcessor:
                         logging.warning(f"Debug save failed: {e}")
                     self.debug_flag = False
 
-                # ---- RTMP push (latest-only; pacing handled inside RTMPStreamer) ----
-                if self.rtmp_streamer is None or not self.rtmp_streamer.is_active():
-                    # (re)create; it will learn WxH on first push
-                    self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
+                # Push frame to RTMP stream
+                # RTMPStreamer handles its own restarts internally
+                if self.rtmp_streamer is None:
+                    try:
+                        self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
+                        logging.info(f"🎬 RTMP streamer initialized for pipeline {pipeline_id}")
+                    except Exception as e:
+                        logging.error(f"❌ Failed to initialize RTMP streamer for pipeline {pipeline_id}: {e}")
+                        self.rtmp_streamer = None
 
-                try:
-                    self.rtmp_streamer.push_frame(drawn_frame)
-                except Exception as e:
-                    logging.error(f"❌ RTMP push error: {e}")
+                if self.rtmp_streamer:
                     try:
-                        self.rtmp_streamer.stop_stream()
-                    except Exception:
-                        pass
-                    self.rtmp_streamer = None
+                        self.rtmp_streamer.push_frame(drawn_frame)
+                    except Exception as e:
+                        logging.error(f"❌ RTMP push error for pipeline {pipeline_id}: {e}")
+                        if "initialization_failed" in str(e).lower():
+                            try:
+                                self.rtmp_streamer.stop_stream()
+                            except Exception:
+                                pass
+                            self.rtmp_streamer = None
 
                 # feed detection worker with latest-only behavior
                 if self.detection_thread and self.detection_thread.is_alive():
@@ -459,9 +464,10 @@ class PipelineProcessor:
                 logging.error(f"   Cannot get stream URL for {worker_source_id}")
                 return False
             
-            video_manager.remove_stream(worker_source_id)
+            # Use internal methods to restart the stream without affecting reference counting
+            video_manager._stop_stream(worker_source_id)
             time.sleep(1.0)
-            video_manager.add_stream(worker_source_id, stream_url)
+            video_manager._start_stream(worker_source_id, stream_url)
             time.sleep(2.0)
             
             if not video_manager.has_stream(worker_source_id):

nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -38,9 +38,13 @@ class PipelineSyncThread(threading.Thread):
         
     def on_pipeline_stopped(self, pipeline_id: str) -> None:
         """Set the pipeline as stopped in the database."""
-        pipeline = self.pipeline_repo.get_worker_source_pipeline(pipeline_id)
-        pipeline.pipeline_status_code = "run" if pipeline.pipeline_status_code == "restart" else "stop"
-        self.pipeline_repo.session.commit()
+        try:
+            pipeline = self.pipeline_repo.get_worker_source_pipeline(pipeline_id)
+            if pipeline:
+                new_status = "run" if pipeline.pipeline_status_code == "restart" else "stop"
+                self.pipeline_repo.update_pipeline_status(pipeline_id, new_status)
+        except Exception as e:
+            logging.error(f"Failed to update pipeline status for {pipeline_id}: {e}")
 
     def run(self) -> None:
         """Continuously updates pipelines based on database changes."""
@@ -52,16 +56,11 @@ class PipelineSyncThread(threading.Thread):
                 local_pipeline_ids = set(self.pipeline_manager.get_active_pipelines())
                 db_pipeline_ids = set(db_pipelines.keys())
 
-                restarted_pipeline = False
-
                 # Process pipeline changes
-                self._add_new_pipelines(db_pipeline_ids - local_pipeline_ids, db_pipelines, restarted_pipeline)
+                self._add_new_pipelines(db_pipeline_ids - local_pipeline_ids, db_pipelines)
                 self._remove_deleted_pipelines(local_pipeline_ids - db_pipeline_ids)
                 self._update_existing_pipelines(db_pipeline_ids & local_pipeline_ids, db_pipelines)
 
-                if restarted_pipeline:
-                    self.pipeline_repo.session.commit()
-
                 # Sync the cache to remove unused detectors
                 active_model_ids = {p.ai_model_id for p in db_pipelines.values() if p.pipeline_status_code == 'run'}
                 self.model_manager.sync_cache(active_model_ids)
@@ -71,15 +70,16 @@ class PipelineSyncThread(threading.Thread):
 
             time.sleep(self.polling_interval) 
 
-    def _add_new_pipelines(self, pipeline_ids: Set[str], db_pipelines: Dict[str, object], 
-                           restarted_pipeline: bool) -> None:
+    def _add_new_pipelines(self, pipeline_ids: Set[str], db_pipelines: Dict[str, object]) -> None:
         """Add new pipelines that exist in DB but not locally."""
         for pid in pipeline_ids:
             pipeline = db_pipelines[pid]
 
             if pipeline.pipeline_status_code == 'restart':
+                # Update status in database
+                self.pipeline_repo.update_pipeline_status(pid, 'run')
+                # Update local object too for consistency
                 pipeline.pipeline_status_code = 'run'
-                restarted_pipeline = True
 
             if pipeline.pipeline_status_code == 'run':
                 detector = self.model_manager.get_detector(pipeline.ai_model_id)
@@ -103,8 +103,22 @@ class PipelineSyncThread(threading.Thread):
 
         for pid in pipeline_ids:
             db_pipeline = db_pipelines[pid]
+            
+            # Check if pipeline should be stopped (status changed to stop/restart in DB)
+            if db_pipeline.pipeline_status_code in ['stop', 'restart']:
+                if self.pipeline_manager.is_running(pid):
+                    logging.info(f"⏹️ Stopping pipeline due to status change: {pid}")
+                    self.pipeline_manager.stop_pipeline(pid)
+                continue
+            
             processor = self.pipeline_manager.processors.get(pid)
             if not processor:
+                # Pipeline exists in both sets but processor doesn't exist - shouldn't happen
+                # but if it does, try to start it if status is 'run'
+                if db_pipeline.pipeline_status_code == 'run':
+                    logging.warning(f"⚠️ Pipeline {pid} exists locally but has no processor. Restarting...")
+                    detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
+                    self.pipeline_manager.start_pipeline(db_pipeline, detector)
                 continue
 
             local_detector = processor.detector
@@ -114,29 +128,12 @@ class PipelineSyncThread(threading.Thread):
                 processor.enable_debug()
 
     def update_pipeline(self, pid: str, db_pipeline: object, local_detector: object) -> None:
-        """Updates a single pipeline if necessary."""
+        """Updates a single pipeline if necessary (only called for running pipelines)."""
         processor = self.pipeline_manager.processors.get(pid)
         if not processor:
             return
 
-        # Stop/start based on status change
-        if db_pipeline.pipeline_status_code != processor._pipeline.pipeline_status_code:
-            if db_pipeline.pipeline_status_code == 'run':
-                logging.info(f"▶️ Resuming pipeline: {pid}")
-                self.pipeline_manager.start_pipeline(db_pipeline, self.model_manager.get_detector(db_pipeline.ai_model_id))
-            elif db_pipeline.pipeline_status_code in ['stop', 'restart']:
-                logging.info(f"⏹️ Stopping pipeline: {pid}")
-                self.pipeline_manager.stop_pipeline(pid)
-                if db_pipeline.pipeline_status_code == 'restart':
-                    # This will be picked up by the 'add_new_pipelines' logic in the next cycle
-                    return 
-            else:
-                 processor.update_config(db_pipeline) # Update config for non-running pipelines
-            return
-        elif db_pipeline.pipeline_status_code != 'run':
-            processor.update_config(db_pipeline)
-            return
-
+        # At this point, we know db_pipeline.pipeline_status_code == 'run' (checked in caller)
         # Check for significant changes that require a restart
         db_detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
 
@@ -146,7 +143,7 @@ class PipelineSyncThread(threading.Thread):
             local_detector != db_detector
         ])
 
-        if requires_restart and db_pipeline.pipeline_status_code == 'run':
+        if requires_restart:
             logging.info(f"🔄 Restarting pipeline due to significant changes: {pid}")
             self.pipeline_manager.stop_pipeline(pid)
             self.pipeline_manager.start_pipeline(db_pipeline, db_detector)

nedo_vision_worker_core/repositories/AIModelRepository.py

@@ -1,15 +1,13 @@
 import logging
-from sqlalchemy.orm import Session
 from sqlalchemy.exc import SQLAlchemyError
-from ..database.DatabaseManager import DatabaseManager
+from .BaseRepository import BaseRepository
 from ..models.ai_model import AIModelEntity
 
-class AIModelRepository:
+class AIModelRepository(BaseRepository):
     """Handles storage of AI Models into SQLite using SQLAlchemy."""
 
     def __init__(self):
-        self.db_manager = DatabaseManager()
-        self.session: Session = self.db_manager.get_session("default")
+        super().__init__(db_name="default")
 
     def get_models(self) -> list:
         """
@@ -19,13 +17,14 @@ class AIModelRepository:
             list: A list of AIModelEntity objects.
         """
         try:
-            self.session.expire_all()
-            models = self.session.query(AIModelEntity).all()
-            
-            for model in models:
-                self.session.expunge(model)
-
-            return models
+            with self._get_session() as session:
+                session.expire_all()
+                models = session.query(AIModelEntity).all()
+                
+                for model in models:
+                    session.expunge(model)
+
+                return models
         except SQLAlchemyError as e:
             logging.error(f"Error retrieving models: {e}")
             return []
@@ -41,11 +40,12 @@ class AIModelRepository:
             An AIModelEntity object or None if not found.
         """
         try:
-            self.session.expire_all()
-            model = self.session.query(AIModelEntity).filter_by(id=model_id).first()
-            if model:
-                self.session.expunge(model)
-            return model
+            with self._get_session() as session:
+                session.expire_all()
+                model = session.query(AIModelEntity).filter_by(id=model_id).first()
+                if model:
+                    session.expunge(model)
+                return model
         except SQLAlchemyError as e:
             logging.error(f"Error retrieving model {model_id}: {e}")
             return None

nedo_vision_worker_core/repositories/BaseRepository.py

@@ -0,0 +1,44 @@
+from contextlib import contextmanager
+from ..database.DatabaseManager import DatabaseManager
+
+
+class BaseRepository:
+    """
+    Base repository class that provides thread-safe database session management.
+    
+    All repositories should inherit from this class to ensure proper connection pooling
+    and to prevent connection leaks in multi-threaded environments.
+    """
+    
+    def __init__(self, db_name: str = "default"):
+        """
+        Initialize the base repository.
+        
+        Args:
+            db_name: Name of the database to connect to ('default', 'config', or 'logging')
+        """
+        self.db_manager = DatabaseManager()
+        self.db_name = db_name
+    
+    @contextmanager
+    def _get_session(self):
+        """
+        Context manager for database sessions.
+        
+        Ensures sessions are properly opened and closed, preventing connection leaks.
+        Each operation gets a fresh session that is automatically closed when done.
+        
+        Usage:
+            with self._get_session() as session:
+                results = session.query(Model).all()
+                return results
+        """
+        session = self.db_manager.get_session(self.db_name)
+        try:
+            yield session
+            session.commit()  # Commit any pending changes
+        except Exception:
+            session.rollback()  # Rollback on error
+            raise
+        finally:
+            session.close()  # Always close the session

nedo_vision_worker_core/repositories/PPEDetectionRepository.py

@@ -4,21 +4,19 @@ import datetime
 import uuid
 import logging
 from pathlib import Path
-from sqlalchemy.orm import Session
 from sqlalchemy.exc import SQLAlchemyError
-from ..database.DatabaseManager import DatabaseManager
+from .BaseRepository import BaseRepository
 from ..models.ppe_detection import PPEDetectionEntity
 from ..models.ppe_detection_label import PPEDetectionLabelEntity
 from ..util.DrawingUtils import DrawingUtils
+from ..database.DatabaseManager import DatabaseManager
 
-class PPEDetectionRepository:
+class PPEDetectionRepository(BaseRepository):
     """Handles storage of PPE detections into SQLite using SQLAlchemy."""
 
     def __init__(self):
-        
+        super().__init__(db_name="default")
         self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "ppe_detections"
-        self.db_manager = DatabaseManager()
-        self.session: Session = self.db_manager.get_session("default")
         os.makedirs(self.storage_dir, exist_ok=True) 
 
     def save_ppe_detection(self, pipeline_id, worker_source_id, frame_id, tracked_objects, frame, frame_drawer):
@@ -64,86 +62,86 @@ class PPEDetectionRepository:
             cv2.imwrite(cropped_image_path, cropped_image)
 
             try:
-                new_detection = PPEDetectionEntity(
-                    id=str(uuid.uuid4()),
-                    worker_id=pipeline_id,
-                    worker_source_id=worker_source_id,
-                    person_id=person_id,
-                    image_path=full_image_path,
-                    image_tile_path=cropped_image_path,
-                    b_box_x1=bbox[0],
-                    b_box_y1=bbox[1],
-                    b_box_x2=bbox[2],
-                    b_box_y2=bbox[3],
-                    detection_count=tracked_obj.get("detections", 0)
-                )
-                self.session.add(new_detection)
-                self.session.flush()
-
-                for attr in filtered_attributes:
-                    label = attr["label"]
-                    valid_attributes.append(label)
-
-                    if attr and "bbox" in attr:
-                        attr_bbox = attr["bbox"]
-                        # Assuming attr_bbox is in [x, y, width, height] format.
-                        attr_b_box_x1 = attr_bbox[0]
-                        attr_b_box_y1 = attr_bbox[1]
-                        attr_b_box_x2 = attr_bbox[2]
-                        attr_b_box_y2 = attr_bbox[3]
-                    else:
-                        # Fallback to default values if the attribute bbox is not available.
-                        attr_b_box_x1 = 0.0
-                        attr_b_box_y1 = 0.0
-                        attr_b_box_x2 = 0.0
-                        attr_b_box_y2 = 0.0
-
-                    # Retrieve confidence score; default to 1.0 if not available.
-                    if attr:
-                        confidence_score = attr.get("confidence", 1.0)
-                    else:
-                        confidence_score = 1.0
-
-                    new_label = PPEDetectionLabelEntity(
+                with self._get_session() as session:
+                    new_detection = PPEDetectionEntity(
                         id=str(uuid.uuid4()),
-                        detection_id=new_detection.id,
-                        code=label,
-                        confidence_score=confidence_score,
-                        detection_count=attr.get("count", 0),
-                        b_box_x1=attr_b_box_x1,
-                        b_box_y1=attr_b_box_y1,
-                        b_box_x2=attr_b_box_x2,
-                        b_box_y2=attr_b_box_y2
-                    )
-                    self.session.add(new_label)
-
-                self.session.commit()
-                logging.info(f"✅ Inserted detection for Person {person_id}, Attributes: {valid_attributes}")
-
-                # Trigger detection callback with unified data structure
-                try:
-                    from ..core_service import CoreService
-                    from ..detection.detection_processing.PPEDetectionProcessor import PPEDetectionProcessor
-                    
-                    # Create unified detection data using the processor's factory method
-                    unified_data = PPEDetectionProcessor.create_detection_data(
-                        pipeline_id=pipeline_id,
+                        worker_id=pipeline_id,
                         worker_source_id=worker_source_id,
                         person_id=person_id,
-                        detection_id=new_detection.id,
-                        tracked_obj=tracked_obj,
                         image_path=full_image_path,
                         image_tile_path=cropped_image_path,
-                        frame_id=frame_id
+                        b_box_x1=bbox[0],
+                        b_box_y1=bbox[1],
+                        b_box_x2=bbox[2],
+                        b_box_y2=bbox[3],
+                        detection_count=tracked_obj.get("detections", 0)
                     )
-                    
-                    # Trigger callbacks
-                    CoreService.trigger_detection(unified_data)
-                    
-                except Exception as e:
-                    logging.warning(f"⚠️ Failed to trigger PPE detection callback: {e}")
+                    session.add(new_detection)
+                    session.flush()
+
+                    for attr in filtered_attributes:
+                        label = attr["label"]
+                        valid_attributes.append(label)
+
+                        if attr and "bbox" in attr:
+                            attr_bbox = attr["bbox"]
+                            # Assuming attr_bbox is in [x, y, width, height] format.
+                            attr_b_box_x1 = attr_bbox[0]
+                            attr_b_box_y1 = attr_bbox[1]
+                            attr_b_box_x2 = attr_bbox[2]
+                            attr_b_box_y2 = attr_bbox[3]
+                        else:
+                            # Fallback to default values if the attribute bbox is not available.
+                            attr_b_box_x1 = 0.0
+                            attr_b_box_y1 = 0.0
+                            attr_b_box_x2 = 0.0
+                            attr_b_box_y2 = 0.0
+
+                        # Retrieve confidence score; default to 1.0 if not available.
+                        if attr:
+                            confidence_score = attr.get("confidence", 1.0)
+                        else:
+                            confidence_score = 1.0
+
+                        new_label = PPEDetectionLabelEntity(
+                            id=str(uuid.uuid4()),
+                            detection_id=new_detection.id,
+                            code=label,
+                            confidence_score=confidence_score,
+                            detection_count=attr.get("count", 0),
+                            b_box_x1=attr_b_box_x1,
+                            b_box_y1=attr_b_box_y1,
+                            b_box_x2=attr_b_box_x2,
+                            b_box_y2=attr_b_box_y2
+                        )
+                        session.add(new_label)
+
+                    # Commit happens automatically via context manager
+                    logging.info(f"✅ Inserted detection for Person {person_id}, Attributes: {valid_attributes}")
+
+                    # Trigger detection callback with unified data structure
+                    try:
+                        from ..core_service import CoreService
+                        from ..detection.detection_processing.PPEDetectionProcessor import PPEDetectionProcessor
+                        
+                        # Create unified detection data using the processor's factory method
+                        unified_data = PPEDetectionProcessor.create_detection_data(
+                            pipeline_id=pipeline_id,
+                            worker_source_id=worker_source_id,
+                            person_id=person_id,
+                            detection_id=new_detection.id,
+                            tracked_obj=tracked_obj,
+                            image_path=full_image_path,
+                            image_tile_path=cropped_image_path,
+                            frame_id=frame_id
+                        )
+                        
+                        # Trigger callbacks
+                        CoreService.trigger_detection(unified_data)
+                        
+                    except Exception as e:
+                        logging.warning(f"⚠️ Failed to trigger PPE detection callback: {e}")
 
             except SQLAlchemyError as e:
-                self.session.rollback()
                 logging.error(f"❌ Database error while saving detection: {e}")