nedo-vision-worker-core 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

nedo_vision_worker_core/__init__.py

@@ -5,19 +5,54 @@ 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.2.0"
-__all__ = ["CoreService"]
+__version__ = "0.3.1"
+__all__ = [
+    "CoreService", 
+    "DetectionType", 
+    "CallbackTrigger", 
+    "DetectionData",
+    "IntervalMetadata",
+    "DetectionAttribute",
+    "BoundingBox"
+]
 
-# Convenience functions for callback management
-def register_ppe_detection_callback(callback):
-    """Register a callback for PPE detection events."""
-    return CoreService.register_detection_callback('ppe_detection', callback)
+# Convenience functions for common callback patterns
+def register_immediate_ppe_callback(name: str, callback):
+    """Register an immediate PPE detection callback."""
+    return CoreService.register_callback(
+        name=name,
+        callback=callback,
+        trigger=CallbackTrigger.ON_NEW_DETECTION,
+        detection_types=[DetectionType.PPE_DETECTION]
+    )
 
-def register_area_violation_callback(callback):
-    """Register a callback for restricted area violation events."""
-    return CoreService.register_detection_callback('area_violation', callback)
+def register_immediate_area_callback(name: str, callback):
+    """Register an immediate area violation callback."""
+    return CoreService.register_callback(
+        name=name,
+        callback=callback,
+        trigger=CallbackTrigger.ON_NEW_DETECTION,
+        detection_types=[DetectionType.AREA_VIOLATION]
+    )
 
-def register_general_detection_callback(callback):
-    """Register a callback for all detection events."""
-    return CoreService.register_detection_callback('general_detection', callback) 
+def register_interval_ppe_callback(name: str, callback, interval_seconds: int = 60):
+    """Register an interval-based PPE violation summary callback."""
+    return CoreService.register_callback(
+        name=name,
+        callback=callback,
+        trigger=CallbackTrigger.ON_VIOLATION_INTERVAL,
+        detection_types=[DetectionType.PPE_DETECTION],
+        interval_seconds=interval_seconds
+    )
+
+def register_interval_area_callback(name: str, callback, interval_seconds: int = 60):
+    """Register an interval-based area violation summary callback."""
+    return CoreService.register_callback(
+        name=name,
+        callback=callback,
+        trigger=CallbackTrigger.ON_VIOLATION_INTERVAL,
+        detection_types=[DetectionType.AREA_VIOLATION],
+        interval_seconds=interval_seconds
+    )

nedo_vision_worker_core/callbacks/DetectionCallbackManager.py

@@ -0,0 +1,306 @@
+"""
+Callback management system for detection events.
+Supports immediate callbacks (triggered on each detection) and interval-based callbacks
+(triggered periodically based on current violation state).
+"""
+
+import logging
+import threading
+import time
+from typing import Callable, Dict, List, Any, Optional
+from collections import defaultdict, deque
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+
+from .DetectionCallbackTypes import DetectionType, CallbackTrigger, DetectionData
+
+
+@dataclass
+class CallbackConfig:
+    """Configuration for a registered callback."""
+    callback: Callable[[DetectionData], None]
+    trigger: CallbackTrigger
+    detection_types: List[DetectionType]
+    interval_seconds: Optional[int] = None
+    
+    def __post_init__(self):
+        if self.trigger == CallbackTrigger.ON_VIOLATION_INTERVAL and self.interval_seconds is None:
+            raise ValueError("interval_seconds is required for ON_VIOLATION_INTERVAL callbacks")
+
+
+class DetectionCallbackManager:
+    """Callback manager with support for immediate and current-state interval callbacks."""
+    
+    def __init__(self):
+        self._callbacks: Dict[str, CallbackConfig] = {}
+        self._current_violations: Dict[str, DetectionData] = {}  # Current active violations by key
+        self._interval_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.RLock()
+        self._last_interval_trigger: Dict[int, datetime] = {}  # Track last trigger time per interval
+        
+        self._start_interval_thread()
+    
+    def register_callback(self, 
+                         name: str,
+                         callback: Callable[[DetectionData], None],
+                         trigger: CallbackTrigger,
+                         detection_types: List[DetectionType],
+                         interval_seconds: Optional[int] = None) -> None:
+        """
+        Register a detection callback.
+        
+        Args:
+            name: Unique name for the callback
+            callback: Function to call when detection occurs
+            trigger: When to trigger the callback (immediate or interval)
+            detection_types: Types of detections to listen for
+            interval_seconds: For interval callbacks, how often to call (in seconds)
+        """
+        with self._lock:
+            config = CallbackConfig(
+                callback=callback,
+                trigger=trigger,
+                detection_types=detection_types,
+                interval_seconds=interval_seconds
+            )
+            
+            self._callbacks[name] = config
+            logging.info(f"📞 Registered callback '{name}' for {[dt.value for dt in detection_types]} "
+                        f"with trigger {trigger.value}")
+    
+    def unregister_callback(self, name: str) -> bool:
+        """
+        Unregister a callback.
+        
+        Args:
+            name: Name of the callback to remove
+            
+        Returns:
+            True if callback was found and removed, False otherwise
+        """
+        with self._lock:
+            if name in self._callbacks:
+                del self._callbacks[name]
+                logging.info(f"📞 Unregistered callback '{name}'")
+                return True
+            return False
+    
+    def trigger_detection(self, detection_data: DetectionData) -> None:
+        """
+        Trigger callbacks for a new detection.
+        Callbacks consume the data as-is, with no modification of detection logic.
+        
+        Args:
+            detection_data: The detection data to process
+        """
+        with self._lock:
+            key = f"{detection_data.pipeline_id}_{detection_data.person_id}_{detection_data.detection_type.value}"
+            
+            # Store current violations (only if they have violations)
+            if detection_data.has_violations():
+                self._current_violations[key] = detection_data
+            else:
+                # Remove from current violations if no longer violating
+                self._current_violations.pop(key, None)
+            
+            # Trigger immediate callbacks for all detections (including non-violations)
+            self._trigger_immediate_callbacks(detection_data)
+    
+    def _trigger_immediate_callbacks(self, detection_data: DetectionData) -> None:
+        """Trigger callbacks that should fire immediately on new detections."""
+        for name, config in self._callbacks.items():
+            if (config.trigger == CallbackTrigger.ON_NEW_DETECTION and 
+                detection_data.detection_type in config.detection_types):
+                
+                try:
+                    config.callback(detection_data)
+                except Exception as e:
+                    logging.error(f"❌ Error in callback '{name}': {e}")
+    
+    def _start_interval_thread(self) -> None:
+        """Start the background thread for interval-based callbacks."""
+        self._interval_thread = threading.Thread(
+            target=self._interval_processor,
+            name="DetectionCallbackInterval",
+            daemon=True
+        )
+        self._interval_thread.start()
+        logging.info("🔄 Started detection callback interval processor")
+    
+    def _interval_processor(self) -> None:
+        """Background thread that processes interval-based callbacks."""
+        while not self._stop_event.is_set():
+            try:
+                interval_groups = defaultdict(list)
+                with self._lock:
+                    for name, config in self._callbacks.items():
+                        if config.trigger == CallbackTrigger.ON_VIOLATION_INTERVAL:
+                            interval_groups[config.interval_seconds].append((name, config))
+                
+                current_time = datetime.utcnow()
+                
+                # Clean up stale violations
+                self._cleanup_stale_violations(current_time)
+                
+                for interval_seconds, callbacks in interval_groups.items():
+                    self._process_interval_group(current_time, interval_seconds, callbacks)
+                
+                self._stop_event.wait(1.0)
+                
+            except Exception as e:
+                logging.error(f"❌ Error in interval processor: {e}")
+                time.sleep(1.0)
+    
+    def _process_interval_group(self, current_time: datetime, interval_seconds: int, 
+                               callbacks: List[tuple]) -> None:
+        """Process callbacks for a specific interval. Only triggers when violations are currently active."""
+        # Check if enough time has passed for this interval
+        last_trigger = self._last_interval_trigger.get(interval_seconds)
+        if last_trigger and (current_time - last_trigger).total_seconds() < interval_seconds:
+            return  # Not time yet for this interval
+        
+        with self._lock:
+            if not self._current_violations:
+                return
+            
+            # Only process violations that are still current (updated recently)
+            recent_threshold = timedelta(seconds=3)  # Must be updated within last 3 seconds
+            current_violations = []
+            for violation in self._current_violations.values():
+                if current_time - violation.timestamp <= recent_threshold:
+                    current_violations.append(violation)
+            
+            if not current_violations:
+                return
+            
+            current_violation_summary = self._create_current_state_summary(
+                current_violations, current_time
+            )
+            
+            if not current_violation_summary:
+                return
+            
+            # Update last trigger time for this interval
+            self._last_interval_trigger[interval_seconds] = current_time
+            
+            for summary in current_violation_summary:
+                for name, config in callbacks:
+                    if summary.detection_type in config.detection_types:
+                        try:
+                            config.callback(summary)
+                        except Exception as e:
+                            logging.error(f"❌ Error in interval callback '{name}': {e}")
+    
+    def _create_current_state_summary(self, current_violations: List[DetectionData], current_time: datetime) -> List[DetectionData]:
+        """Create current state detection data from active violations."""
+        if not current_violations:
+            return []
+        
+        # Group by detection type and pipeline
+        groups = defaultdict(list)
+        for violation in current_violations:
+            key = f"{violation.detection_type.value}_{violation.pipeline_id}"
+            groups[key].append(violation)
+        
+        summaries = []
+        for group_violations in groups.values():
+            if not group_violations:
+                continue
+                
+            latest = max(group_violations, key=lambda v: v.timestamp)
+            
+            current_violation_counts = defaultdict(int)
+            total_current_violations = 0
+            
+            for violation in group_violations:
+                for attr in violation.get_violations():
+                    current_violation_counts[attr.label] += 1
+                    total_current_violations += 1
+            
+            if total_current_violations == 0:
+                continue
+            
+            metadata = {
+                'current_violation_state': dict(current_violation_counts),
+                'total_active_violations': total_current_violations,
+                'unique_persons_in_violation': len(set(v.person_id for v in group_violations)),
+                'state_timestamp': current_time.isoformat()
+            }
+            
+            summary = DetectionData(
+                detection_type=latest.detection_type,
+                detection_id=f"current_state_{latest.detection_type.value}_{int(time.time())}",
+                person_id="multiple" if len(set(v.person_id for v in group_violations)) > 1 else latest.person_id,
+                pipeline_id=latest.pipeline_id,
+                worker_source_id=latest.worker_source_id,
+                confidence_score=sum(v.confidence_score for v in group_violations) / len(group_violations),
+                bbox=latest.bbox,
+                attributes=latest.get_violations(),
+                image_path=latest.image_path,
+                image_tile_path=latest.image_tile_path,
+                timestamp=current_time,
+                frame_id=latest.frame_id,
+                metadata=metadata
+            )
+            
+            summaries.append(summary)
+        
+        return summaries
+
+    def _cleanup_stale_violations(self, current_time: datetime) -> None:
+        """Remove violations that haven't been updated recently (stale detections)."""
+        stale_threshold = timedelta(seconds=5)  # More aggressive cleanup
+        stale_keys = []
+        
+        for key, violation_data in self._current_violations.items():
+            if current_time - violation_data.timestamp > stale_threshold:
+                stale_keys.append(key)
+                logging.debug(f"🧹 Removing stale violation: {key} (age: {current_time - violation_data.timestamp})")
+        
+        for key in stale_keys:
+            self._current_violations.pop(key, None)
+    
+    def get_callback_stats(self) -> Dict[str, Any]:
+        """Get statistics about registered callbacks and recent activity."""
+        with self._lock:
+            immediate_callbacks = sum(1 for c in self._callbacks.values() 
+                                    if c.trigger == CallbackTrigger.ON_NEW_DETECTION)
+            interval_callbacks = sum(1 for c in self._callbacks.values() 
+                                   if c.trigger == CallbackTrigger.ON_VIOLATION_INTERVAL)
+            
+            return {
+                'total_callbacks': len(self._callbacks),
+                'immediate_callbacks': immediate_callbacks,
+                'interval_callbacks': interval_callbacks,
+                'current_active_violations': len(self._current_violations),
+                'callback_names': list(self._callbacks.keys())
+            }
+    
+    def list_callbacks(self) -> Dict[str, Dict[str, Any]]:
+        """List all registered callbacks with their configurations."""
+        with self._lock:
+            result = {}
+            for name, config in self._callbacks.items():
+                result[name] = {
+                    'trigger': config.trigger.value,
+                    'detection_types': [dt.value for dt in config.detection_types],
+                    'interval_seconds': config.interval_seconds,
+                    'callback_name': config.callback.__name__
+                }
+            return result
+    
+    def stop(self) -> None:
+        """Stop the callback manager and cleanup resources."""
+        logging.info("🛑 Stopping detection callback manager...")
+        self._stop_event.set()
+        
+        if self._interval_thread and self._interval_thread.is_alive():
+            self._interval_thread.join(timeout=5.0)
+        
+        with self._lock:
+            self._callbacks.clear()
+            self._current_violations.clear()
+            self._last_interval_trigger.clear()
+        
+        logging.info("✅ Detection callback manager stopped")

nedo_vision_worker_core/callbacks/DetectionCallbackTypes.py

@@ -0,0 +1,150 @@
+"""
+Detection callback types and unified data structures.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Optional
+from typing_extensions import TypedDict
+from datetime import datetime
+from enum import Enum
+
+
+class DetectionType(Enum):
+    """Types of detections."""
+    PPE_DETECTION = "ppe_detection"
+    AREA_VIOLATION = "area_violation"
+    GENERAL_DETECTION = "general_detection"
+
+
+class CallbackTrigger(Enum):
+    """When callbacks should be triggered."""
+    ON_NEW_DETECTION = "on_new_detection"
+    ON_VIOLATION_INTERVAL = "on_violation_interval"
+
+
+class IntervalMetadata(TypedDict):
+    """Metadata structure for interval-based callbacks with current state."""
+    current_violation_state: Dict[str, int]  # violation_type -> current count
+    total_active_violations: int
+    unique_persons_in_violation: int
+    state_timestamp: str  # ISO format datetime when state was captured
+
+
+@dataclass
+class BoundingBox:
+    """Unified bounding box representation."""
+    x1: float
+    y1: float
+    x2: float
+    y2: float
+    
+    @classmethod
+    def from_list(cls, bbox: List[float]) -> 'BoundingBox':
+        """Create BoundingBox from list [x1, y1, x2, y2]."""
+        return cls(x1=bbox[0], y1=bbox[1], x2=bbox[2], y2=bbox[3])
+    
+    def to_list(self) -> List[float]:
+        """Convert to list format [x1, y1, x2, y2]."""
+        return [self.x1, self.y1, self.x2, self.y2]
+
+
+@dataclass
+class DetectionAttribute:
+    """Represents a detection attribute (e.g., PPE violations)."""
+    label: str
+    confidence: float
+    count: int = 0
+    bbox: Optional[BoundingBox] = None
+    is_violation: bool = False
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation."""
+        result = {
+            'label': self.label,
+            'confidence': self.confidence,
+            'count': self.count,
+            'is_violation': self.is_violation
+        }
+        if self.bbox:
+            result['bbox'] = self.bbox.to_list()
+        return result
+
+
+@dataclass
+class DetectionData:
+    """Unified data structure for all detection types."""
+    
+    # Core identification
+    detection_type: DetectionType
+    detection_id: str
+    person_id: str
+    pipeline_id: str
+    worker_source_id: str
+    
+    # Detection details
+    confidence_score: float
+    bbox: BoundingBox
+    attributes: List[DetectionAttribute] = field(default_factory=list)
+    
+    # Images
+    image_path: str = ""
+    image_tile_path: str = ""
+    
+    # Timing
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+    frame_id: int = 0
+    
+    # Additional metadata
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def get_violations(self) -> List[DetectionAttribute]:
+        """Get only violation attributes."""
+        return [attr for attr in self.attributes if attr.is_violation]
+    
+    def get_compliance(self) -> List[DetectionAttribute]:
+        """Get only compliance attributes."""
+        return [attr for attr in self.attributes if not attr.is_violation]
+    
+    def has_violations(self) -> bool:
+        """Check if detection has any violations."""
+        return len(self.get_violations()) > 0
+    
+    def get_interval_metadata(self) -> Optional[IntervalMetadata]:
+        """Get typed metadata for interval callbacks."""
+        if not self.metadata:
+            return None
+        
+        # Check if this looks like interval metadata
+        required_keys = {'current_violation_state', 'total_active_violations', 
+                        'unique_persons_in_violation', 'state_timestamp'}
+        if not required_keys.issubset(self.metadata.keys()):
+            return None
+        
+        # Return typed metadata
+        return IntervalMetadata(
+            current_violation_state=self.metadata['current_violation_state'],
+            total_active_violations=self.metadata['total_active_violations'],
+            unique_persons_in_violation=self.metadata['unique_persons_in_violation'],
+            state_timestamp=self.metadata['state_timestamp']
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation for backward compatibility."""
+        return {
+            'type': self.detection_type.value,
+            'detection_id': self.detection_id,
+            'person_id': self.person_id,
+            'pipeline_id': self.pipeline_id,
+            'worker_source_id': self.worker_source_id,
+            'confidence_score': self.confidence_score,
+            'bbox': self.bbox.to_list(),
+            'attributes': [attr.to_dict() for attr in self.attributes],
+            'violations': [attr.to_dict() for attr in self.get_violations()],
+            'compliance': [attr.to_dict() for attr in self.get_compliance()],
+            'image_path': self.image_path,
+            'image_tile_path': self.image_tile_path,
+            'timestamp': self.timestamp.isoformat(),
+            'frame_id': self.frame_id,
+            'has_violations': self.has_violations(),
+            'metadata': self.metadata
+        }

nedo_vision_worker_core/callbacks/__init__.py

@@ -0,0 +1,27 @@
+"""
+Detection callback system for Nedo Vision Worker Core.
+"""
+
+from .DetectionCallbackTypes import (
+    CallbackTrigger,
+    DetectionType, 
+    DetectionAttribute,
+    BoundingBox,
+    DetectionData,
+    IntervalMetadata
+)
+
+from .DetectionCallbackManager import (
+    DetectionCallbackManager,
+    CallbackConfig
+)
+
+__all__ = [
+    'DetectionCallbackManager',
+    'CallbackTrigger',
+    'DetectionType',
+    'DetectionAttribute', 
+    'BoundingBox',
+    'DetectionData',
+    'IntervalMetadata'
+]

nedo_vision_worker_core/cli.py

@@ -21,7 +21,7 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
-  # Start core service with default settings
+  # Start core service with default settings (includes auto video sharing daemon)
   nedo-core run
 
   # Start with custom drawing assets path
@@ -33,12 +33,20 @@ Examples:
   # Start with custom storage path and RTMP server
   nedo-core run --storage-path /path/to/storage --rtmp-server rtmp://server.com:1935/live
 
+  # Start without automatic video sharing daemon
+  nedo-core run --disable-video-sharing-daemon
+
   # Start with all custom parameters
   nedo-core run --drawing-assets /path/to/assets --log-level DEBUG --storage-path /data --rtmp-server rtmp://server.com:1935/live
 
   # Run system diagnostics
   nedo-core doctor
 
+Video Sharing Daemon:
+  By default, the core service automatically starts video sharing daemons for devices
+  as needed. This enables multiple processes to access the same video device simultaneously
+  without "device busy" errors. Use --disable-video-sharing-daemon to turn this off.
+
 Detection Callbacks:
   The core service supports detection callbacks for extensible event handling.
   See example_callbacks.py for usage examples.
@@ -83,33 +91,15 @@ Detection Callbacks:
     
     run_parser.add_argument(
         "--rtmp-server",
-        default="rtmp://localhost:1935/live",
-        help="RTMP server URL for video streaming (default: rtmp://localhost:1935/live)"
+        default="rtmp://live.vision.sindika.co.id:1935/live",
+        help="RTMP server URL for video streaming (default: rtmp://live.vision.sindika.co.id:1935/live)"
     )
     
-    # Add legacy arguments for backward compatibility (when no subcommand is used)
-    parser.add_argument(
-        "--drawing-assets",
-        help="(Legacy) Path to drawing assets directory (optional, uses bundled assets by default)"
-    )
-    
-    parser.add_argument(
-        "--log-level",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
-        default="INFO",
-        help="(Legacy) Logging level (default: INFO)"
-    )
-    
-    parser.add_argument(
-        "--storage-path",
-        default="data",
-        help="(Legacy) Storage path for databases and files (default: data)"
-    )
-    
-    parser.add_argument(
-        "--rtmp-server",
-        default="rtmp://localhost:1935/live",
-        help="(Legacy) RTMP server URL for video streaming (default: rtmp://localhost:1935/live)"
+    run_parser.add_argument(
+        "--disable_video_sharing_daemon",
+        action="store_true",
+        default=False,
+        help="Disable automatic video sharing daemon management (default: False)"
     )
     
     parser.add_argument(
@@ -125,11 +115,7 @@ Detection Callbacks:
         run_core_service(args)
     elif args.command == 'doctor':
         run_doctor()
-    elif hasattr(args, 'drawing_assets') and args.drawing_assets is not None:  # Legacy mode - if any arguments are provided without subcommand
-        print("⚠️  Warning: Using legacy command format. Consider using 'nedo-core run --drawing-assets ...' instead.")
-        run_core_service(args)
     else:
-        # If no subcommand provided, show help
         parser.print_help()
         sys.exit(1)
 
@@ -148,9 +134,6 @@ def run_doctor():
         sys.exit(1)
 
 
-def run_core_service(args):
-    """Run the core service with the provided arguments."""
-    
 def run_core_service(args):
     """Run the core service with the provided arguments."""
     # Set up signal handlers for graceful shutdown
@@ -160,12 +143,18 @@ def run_core_service(args):
     logger = logging.getLogger(__name__)
     
     try:
+        # Determine video sharing daemon setting
+        enable_daemon = True  # Default
+        if hasattr(args, 'disable_video_sharing_daemon') and args.disable_video_sharing_daemon:
+            enable_daemon = False
+        
         # Create and start the core service
         service = CoreService(
             drawing_assets_path=args.drawing_assets,
             log_level=args.log_level,
             storage_path=args.storage_path,
-            rtmp_server=args.rtmp_server
+            rtmp_server=args.rtmp_server,
+            enable_video_sharing_daemon=enable_daemon
         )
         
         logger.info("🚀 Starting Nedo Vision Core...")
@@ -176,6 +165,7 @@ def run_core_service(args):
         logger.info(f"📝 Log Level: {args.log_level}")
         logger.info(f"💾 Storage Path: {args.storage_path}")
         logger.info(f"📡 RTMP Server: {args.rtmp_server}")
+        logger.info(f"🔗 Video Sharing Daemon: {'Enabled' if enable_daemon else 'Disabled'}")
         logger.info("Press Ctrl+C to stop the service")
         
         # Start the service