nedo-vision-worker-core 0.3.5__tar.gz → 0.3.6__tar.gz

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.5
+Version: 0.3.6
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -31,7 +31,6 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: alembic>=1.8.0
 Requires-Dist: numpy>=1.21.0
-Requires-Dist: opencv-python>=4.6.0
 Requires-Dist: pillow>=8.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: scipy>=1.9.0
@@ -41,6 +40,8 @@ Requires-Dist: torch>=1.9.0
 Requires-Dist: torchvision>=0.10.0
 Requires-Dist: ultralytics>=8.0.0
 Requires-Dist: rfdetr<2.0.0,>=1.2.0
+Provides-Extra: opencv
+Requires-Dist: opencv-python>=4.6.0; extra == "opencv"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/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.5"
+__version__ = "0.3.6"
 __all__ = [
     "CoreService", 
     "DetectionType", 

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/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-0.3.5 → nedo_vision_worker_core-0.3.6}/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
@@ -48,14 +47,43 @@ class PipelineManager:
         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.
         """
@@ -64,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}")
 
@@ -93,10 +117,14 @@ class PipelineManager:
             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)
@@ -132,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."""
@@ -142,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-0.3.5 → nedo_vision_worker_core-0.3.6}/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():

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/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)

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/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-0.3.6/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-0.3.6/nedo_vision_worker_core/repositories/PPEDetectionRepository.py

@@ -0,0 +1,147 @@
+import os
+import cv2
+import datetime
+import uuid
+import logging
+from pathlib import Path
+from sqlalchemy.exc import SQLAlchemyError
+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(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"
+        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):
+        """
+        Inserts new detections only if at least one attribute's detection count is >= 5.
+
+        Args:
+            pipeline_id (str): Unique ID of the video pipeline.
+            worker_source_id (str): Source of the video stream.
+            frame_id (int): Frame number.
+            tracked_objects (list): List of detected persons and their attribute counts.
+            frame (numpy.ndarray): Image frame for saving snapshots.
+        """
+        current_datetime = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d_%H%M%S")  # Timestamp
+
+        for tracked_obj in tracked_objects:
+            person_id = tracked_obj["uuid"]
+            attributes = tracked_obj["attributes"]
+            valid_attributes = []
+
+            if not any(attr.get("count", 0) == 5 for attr in attributes):
+                continue  # Skip this detection
+
+            filtered_attributes = [attr for attr in attributes if attr.get("count", 0) >= 5]
+            
+            draw_obj = tracked_obj.copy()
+            draw_obj["attributes"] = filtered_attributes
+            
+            drawn_frame = frame_drawer.draw_frame(frame.copy(), [draw_obj])
+
+            # Save full frame image
+            full_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}.jpg"
+            full_image_path = os.path.join(self.storage_dir, full_image_filename)
+            cv2.imwrite(full_image_path, drawn_frame)
+
+            # Save cropped image with buffer
+            bbox = tracked_obj["bbox"]
+            cropped_image, obj = DrawingUtils.crop_with_bounding_box(frame, tracked_obj)
+            cropped_image = frame_drawer.draw_frame(cropped_image, [obj])
+
+            cropped_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}_cropped.jpg"
+            cropped_image_path = os.path.join(self.storage_dir, cropped_image_filename)
+            cv2.imwrite(cropped_image_path, cropped_image)
+
+            try:
+                with self._get_session() as session:
+                    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)
+                    )
+                    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:
+                logging.error(f"❌ Database error while saving detection: {e}")
+

{nedo_vision_worker_core-0.3.5 → nedo_vision_worker_core-0.3.6}/nedo_vision_worker_core/repositories/RestrictedAreaRepository.py

@@ -5,18 +5,17 @@ import cv2
 import datetime
 import logging
 from pathlib import Path
-from sqlalchemy.orm import Session
 from sqlalchemy.exc import SQLAlchemyError
+from .BaseRepository import BaseRepository
 from ..models.restricted_area_violation import RestrictedAreaViolationEntity
 from ..database.DatabaseManager import DatabaseManager
 from ..util.DrawingUtils import DrawingUtils
 
-class RestrictedAreaRepository:
+class RestrictedAreaRepository(BaseRepository):
     def __init__(self):
+        super().__init__(db_name="default")
         self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "restricted_violations"
         os.makedirs(self.storage_dir, exist_ok=True)
-        self.db_manager = DatabaseManager()
-        self.session: Session = self.db_manager.get_session("default")
 
     def save_area_violation(self, pipeline_id, worker_source_id, frame_id, tracked_objects, frame, frame_drawer):
         """
@@ -50,45 +49,45 @@ class RestrictedAreaRepository:
             cv2.imwrite(cropped_image_path, cropped_image)
 
             try:
-                new_detection = RestrictedAreaViolationEntity(
-                    worker_source_id=worker_source_id,
-                    person_id=person_id,
-                    image_path=full_image_path,
-                    image_tile_path=cropped_image_path,
-                    confidence_score=tracked_obj.get("confidence", 1),
-                    b_box_x1=bbox[0],
-                    b_box_y1=bbox[1],
-                    b_box_x2=bbox[2],
-                    b_box_y2=bbox[3],
-                )
-                self.session.add(new_detection)
-                self.session.flush()
-                self.session.commit()
-                logging.info(f"✅ Inserted restricted area violation for Person {person_id}")
-
-                # Trigger detection callback
-                try:
-                    from ..core_service import CoreService
-                    from ..detection.detection_processing.HumanDetectionProcessor import HumanDetectionProcessor
-                    
-                    # Create unified detection data using the processor's factory method
-                    unified_data = HumanDetectionProcessor.create_detection_data(
-                        pipeline_id=pipeline_id,
+                with self._get_session() as session:
+                    new_detection = RestrictedAreaViolationEntity(
                         worker_source_id=worker_source_id,
                         person_id=person_id,
-                        detection_id=new_detection.id if hasattr(new_detection, 'id') else f"area_{person_id}_{current_datetime}",
-                        tracked_obj=tracked_obj,
                         image_path=full_image_path,
                         image_tile_path=cropped_image_path,
-                        frame_id=frame_id
+                        confidence_score=tracked_obj.get("confidence", 1),
+                        b_box_x1=bbox[0],
+                        b_box_y1=bbox[1],
+                        b_box_x2=bbox[2],
+                        b_box_y2=bbox[3],
                     )
-                    
-                    # Trigger callbacks
-                    CoreService.trigger_detection(unified_data)
-                    
-                except Exception as e:
-                    logging.warning(f"⚠️ Failed to trigger area violation callback: {e}")
+                    session.add(new_detection)
+                    session.flush()
+                    # Commit happens automatically via context manager
+                    logging.info(f"✅ Inserted restricted area violation for Person {person_id}")
+
+                    # Trigger detection callback
+                    try:
+                        from ..core_service import CoreService
+                        from ..detection.detection_processing.HumanDetectionProcessor import HumanDetectionProcessor
+                        
+                        # Create unified detection data using the processor's factory method
+                        unified_data = HumanDetectionProcessor.create_detection_data(
+                            pipeline_id=pipeline_id,
+                            worker_source_id=worker_source_id,
+                            person_id=person_id,
+                            detection_id=new_detection.id if hasattr(new_detection, 'id') else f"area_{person_id}_{current_datetime}",
+                            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 area violation callback: {e}")
 
             except SQLAlchemyError as e:
-                self.session.rollback()
                 logging.error(f"❌ Database error while saving detection: {e}")