nedo-vision-worker 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

nedo_vision_worker/util/VideoProbeUtil.py

@@ -4,16 +4,36 @@ import logging
 import json
 import fractions
 import shutil
+import sys
+import platform
+from pathlib import Path
 from urllib.parse import urlparse
+from .FFmpegUtil import get_rtsp_probe_options
+
+
+try:
+    from nedo_vision_worker.services.VideoSharingDaemon import VideoSharingClient
+except ImportError:
+    logging.warning("VideoSharingDaemon not available")
+    VideoSharingClient = None
+
+# Import DatabaseManager for storage path
+try:
+    from nedo_vision_worker.database.DatabaseManager import get_storage_path
+except ImportError:
+    get_storage_path = None
 
 class VideoProbeUtil:
     """Utility to extract metadata from video URLs using OpenCV and ffmpeg."""
     
     @staticmethod
     def get_video_metadata(video_url: str) -> dict:
-        """Extracts resolution and frame rate from a video URL using OpenCV or ffmpeg."""
         try:
-            # metadata = VideoProbeUtil._get_metadata_opencv(video_url)
+            if isinstance(video_url, str) and video_url.isdigit():
+                metadata = VideoProbeUtil._get_metadata_direct_device(video_url)
+                if metadata:
+                    return metadata
+            
             metadata = VideoProbeUtil._get_metadata_ffmpeg(video_url)
             return metadata
         
@@ -45,13 +65,208 @@ class VideoProbeUtil:
             "timestamp": None
         }
     
+    @staticmethod
+    def _get_metadata_opencv_direct_device(device_idx: int) -> dict:
+        """Fallback method to get metadata directly from camera device using OpenCV."""
+        try:
+            logging.debug(f"Attempting direct OpenCV access to device {device_idx}")
+            cap = cv2.VideoCapture(device_idx)
+            
+            if not cap.isOpened():
+                logging.warning(f"⚠️ [APP] OpenCV failed to open device {device_idx}")
+                return None
+
+            # Set a reasonable timeout and try to read a frame
+            cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Reduce buffer to get fresh frames
+            
+            # Try multiple attempts to read a frame (some cameras need warm-up)
+            ret, frame = False, None
+            for attempt in range(3):
+                ret, frame = cap.read()
+                if ret and frame is not None:
+                    break
+                logging.debug(f"Attempt {attempt + 1} failed to read frame from device {device_idx}")
+            
+            if not ret or frame is None:
+                logging.warning(f"⚠️ [APP] OpenCV failed to read frame from device {device_idx} after 3 attempts")
+                cap.release()
+                return None
+
+            # Get video properties
+            height, width = frame.shape[:2]
+            frame_rate = cap.get(cv2.CAP_PROP_FPS)
+            
+            # Some cameras report 0 FPS, use a reasonable default
+            if frame_rate <= 0:
+                frame_rate = 30.0
+            else:
+                frame_rate = round(frame_rate, 2)
+            
+            cap.release()
+            
+            logging.info(f"✅ [APP] Successfully probed device {device_idx} directly: {width}x{height} @ {frame_rate}fps")
+            
+            return {
+                "resolution": f"{width}x{height}",
+                "frame_rate": frame_rate,
+                "timestamp": None
+            }
+            
+        except Exception as e:
+            logging.error(f"❌ [APP] Error probing device {device_idx} with OpenCV: {e}")
+            return None
+    
+    @staticmethod
+    def _get_metadata_ffmpeg_direct_device(device_idx: int) -> dict:
+        """Fallback method to get metadata from camera device using FFmpeg."""
+        if not shutil.which("ffprobe"):
+            logging.warning("⚠️ [APP] ffprobe not available for device probing")
+            return None
+            
+        try:
+            system = platform.system().lower()
+            
+            # Determine the device input format based on OS
+            if system == "linux":
+                device_path = f"/dev/video{device_idx}"
+                input_format = "v4l2"
+                cmd = ["ffprobe", "-f", input_format, "-i", device_path]
+            elif system == "windows":
+                # Windows DirectShow device
+                input_format = "dshow"
+                device_name = f"video={device_idx}"  # This might need adjustment based on actual device names
+                cmd = ["ffprobe", "-f", input_format, "-i", device_name]
+            elif system == "darwin":  # macOS
+                input_format = "avfoundation"
+                cmd = ["ffprobe", "-f", input_format, "-i", str(device_idx)]
+            else:
+                logging.warning(f"⚠️ [APP] Unsupported platform for FFmpeg device access: {system}")
+                return None
+            
+            # Add common ffprobe arguments
+            cmd.extend([
+                "-v", "error",
+                "-select_streams", "v:0",
+                "-show_entries", "stream=width,height,avg_frame_rate",
+                "-of", "json"
+            ])
+            
+            logging.debug(f"Running FFmpeg command: {' '.join(cmd)}")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            
+            if result.returncode != 0:
+                logging.warning(f"⚠️ [APP] FFmpeg failed for device {device_idx}: {result.stderr.strip()}")
+                return None
+                
+            if not result.stdout.strip():
+                logging.warning(f"⚠️ [APP] No output from FFmpeg for device {device_idx}")
+                return None
+
+            metadata = json.loads(result.stdout)
+            streams = metadata.get("streams", [])
+            
+            if not streams:
+                logging.warning(f"⚠️ [APP] No video streams found for device {device_idx}")
+                return None
+                
+            stream = streams[0]
+            width = stream.get("width")
+            height = stream.get("height")
+            avg_fps = stream.get("avg_frame_rate", "30/1")
+
+            try:
+                frame_rate = round(float(fractions.Fraction(avg_fps)), 2)
+            except (ValueError, ZeroDivisionError):
+                frame_rate = 30.0
+
+            if not width or not height:
+                logging.warning(f"⚠️ [APP] Invalid resolution from FFmpeg for device {device_idx}")
+                return None
+
+            logging.info(f"✅ [APP] Successfully probed device {device_idx} with FFmpeg: {width}x{height} @ {frame_rate}fps")
+            
+            return {
+                "resolution": f"{width}x{height}",
+                "frame_rate": frame_rate,
+                "timestamp": None
+            }
+
+        except subprocess.TimeoutExpired:
+            logging.warning(f"⚠️ [APP] FFmpeg timeout for device {device_idx}")
+        except json.JSONDecodeError:
+            logging.error(f"❌ [APP] Failed to parse FFmpeg output for device {device_idx}")
+        except Exception as e:
+            logging.error(f"❌ [APP] Error probing device {device_idx} with FFmpeg: {e}")
+            
+        return None
+    
+    @staticmethod
+    def _get_metadata_direct_device(device_index: str) -> dict:
+        try:
+            device_idx = int(device_index)
+            
+            logging.debug(f"VideoSharingClient available: {VideoSharingClient is not None}")
+            
+            # Try to use VideoSharingClient first for cross-process access
+            if VideoSharingClient:
+                try:
+                    logging.debug("Attempting to use VideoSharingClient...")
+                    
+                    # Get storage path from DatabaseManager
+                    storage_path = None
+                    if get_storage_path:
+                        try:
+                            storage_path = str(get_storage_path())
+                            logging.debug(f"Got storage path: {storage_path}")
+                        except Exception as e:
+                            logging.debug(f"Could not get storage path: {e}")
+                    
+                    # Create temporary client to get device properties
+                    video_client = VideoSharingClient(device_idx, storage_path=storage_path)
+                    logging.debug(f"Created VideoSharingClient, info_file: {video_client.info_file}")
+                    
+                    # Load daemon info to get properties without connecting
+                    if video_client._load_daemon_info():
+                        width = video_client.width
+                        height = video_client.height
+                        fps = video_client.fps
+                        
+                        return {
+                            "resolution": f"{width}x{height}",
+                            "frame_rate": round(fps, 2) if fps > 0 else 30.0,
+                            "timestamp": None
+                        }
+                    else:
+                        logging.debug(f"Video sharing daemon not available for device {device_idx}")
+                    
+                except Exception as e:
+                    logging.debug(f"Video sharing not available for device {device_idx}: {e}")
+                    import traceback
+                    logging.debug(traceback.format_exc())
+            
+            # Fallback 1: Try direct OpenCV access
+            logging.info(f"🔄 [APP] Daemon not available for device {device_idx}, falling back to direct OpenCV access")
+            metadata = VideoProbeUtil._get_metadata_opencv_direct_device(device_idx)
+            if metadata:
+                return metadata
+            
+            # Fallback 2: Try FFmpeg for device access (Linux v4l2, Windows dshow)
+            logging.info(f"🔄 [APP] OpenCV failed for device {device_idx}, trying FFmpeg device access")
+            return VideoProbeUtil._get_metadata_ffmpeg_direct_device(device_idx)
+            
+        except Exception as e:
+            logging.error(f"❌ [APP] Error getting metadata from direct device {device_index}: {e}")
+            return None
+    
     @staticmethod
     def _detect_stream_type(video_url: str) -> str:
-        """Detect whether the URL is RTSP, local file, or other type."""
-        # Convert PosixPath to string if needed
         if hasattr(video_url, '__str__'):
             video_url = str(video_url)
         
+        if isinstance(video_url, str) and video_url.isdigit():
+            return "direct"
+        
         parsed_url = urlparse(video_url)
         if parsed_url.scheme == "rtsp":
             return "rtsp"
@@ -62,45 +277,40 @@ class VideoProbeUtil:
     
     @staticmethod
     def _get_metadata_ffmpeg(video_url: str) -> dict:
-        # Check if ffprobe is available
         if not shutil.which("ffprobe"):
             logging.error("⚠️ [APP] ffprobe is not installed or not found in PATH.")
             return None
 
-        # Detect stream type
         stream_type = VideoProbeUtil._detect_stream_type(video_url)
         
-        # Build ffprobe command based on stream type
+        if stream_type == "direct":
+            return VideoProbeUtil._get_metadata_direct_device(video_url)
+        
         cmd = ["ffprobe", "-v", "error", "-select_streams", "v:0", 
                "-show_entries", "stream=width,height,avg_frame_rate", "-of", "json"]
         
-        # Add RTSP transport option only for RTSP streams
         if stream_type == "rtsp":
-            cmd.insert(1, "-rtsp_transport")
-            cmd.insert(2, "tcp")
+            probe_options = get_rtsp_probe_options()
+            # Insert options at the beginning (after ffprobe)
+            for i, option in enumerate(probe_options):
+                cmd.insert(1 + i, option)
         
-        # Add the video URL
         cmd.append(video_url)
 
         try:
-            # Run ffprobe command
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
 
-            # Check for errors
             if result.returncode != 0 or not result.stdout.strip():
                 logging.warning(f"⚠️ [APP] ffprobe failed for {video_url}: {result.stderr.strip()}")
                 return None
 
-            # Parse JSON output
             metadata = json.loads(result.stdout)
             streams = metadata.get("streams", [{}])[0]
 
-            # Extract metadata
             width = streams.get("width")
             height = streams.get("height")
             avg_fps = streams.get("avg_frame_rate", "0/1")
 
-            # Convert FPS safely
             try:
                 frame_rate = round(float(fractions.Fraction(avg_fps)), 2)
             except (ValueError, ZeroDivisionError):
@@ -109,7 +319,7 @@ class VideoProbeUtil:
             return {
                 "resolution": f"{width}x{height}" if width and height else None,
                 "frame_rate": frame_rate,
-                "timestamp": None  # Placeholder if you need a timestamp later
+                "timestamp": None
             }
 
         except subprocess.TimeoutExpired:

nedo_vision_worker/worker/DataSyncWorker.py

@@ -64,6 +64,7 @@ class DataSyncWorker:
         """Stop the data sync worker."""
         logging.info("🛑 [DATA SYNC] Stopping DataSyncWorker.")
         self.running = False
+        self.ai_model_client.cleanup_downloads()
         safe_join_thread(self.thread)
         logging.info("🛑 [DATA SYNC] DataSyncWorker stopped.")
 

nedo_vision_worker/worker/PipelineImageWorker.py

@@ -112,7 +112,7 @@ class PipelineImageWorker:
             response = self.worker_source_pipeline_client.send_pipeline_image(
                 worker_source_pipeline_id=worker_source_pipeline_id,
                 uuid=uuid,
-                url=worker_source.url if worker_source.type_code == "live" else worker_source.file_path,
+                url=worker_source.url if worker_source.type_code in ["live", "direct"] else worker_source.file_path,
                 token=self.token
             )
 

nedo_vision_worker/worker/VideoStreamWorker.py

@@ -4,6 +4,8 @@ import logging
 import json
 from ..database.DatabaseManager import get_storage_path
 from ..services.FileToRTMPServer import FileToRTMPStreamer
+from ..services.DirectDeviceToRTMPStreamer import DirectDeviceToRTMPStreamer
+from ..services.SharedDirectDeviceClient import SharedDirectDeviceClient
 from .RabbitMQListener import RabbitMQListener
 from ..services.RTSPtoRTMPStreamer import RTSPtoRTMPStreamer
 
@@ -44,6 +46,9 @@ class VideoStreamWorker:
         self.thread = None
         self.stop_event = threading.Event()
         self.lock = threading.Lock()
+        
+        # Initialize shared device client for direct video devices
+        self.shared_device_client = SharedDirectDeviceClient()
 
         # Initialize RabbitMQ listener
         self.listener = RabbitMQListener(
@@ -75,6 +80,11 @@ class VideoStreamWorker:
             safe_join_thread(self.thread)  # Ensures the thread stops gracefully
             self.thread = None
             logger.info(f"🛑 [APP] Stream Worker stopped (Device: {self.worker_id}).")
+    
+    def _is_direct_device(self, url) -> bool:
+        """Check if the URL is a direct video device."""
+        is_device, _ = self.shared_device_client._is_direct_device(url)
+        return is_device
 
     def _run(self):
         """Main loop to manage RabbitMQ listener."""
@@ -108,8 +118,19 @@ class VideoStreamWorker:
 
             logger.info(f"📡 [APP] Received video preview message ({data})")
 
-            if not url or (not url.startswith("rtsp://") and not url.startswith("worker-source/")):
-                logger.error(f"⚠️ [APP] Invalid URL: {url}")
+            # Validate URL - support RTSP, worker-source files, and direct devices
+            if not url:
+                logger.error(f"⚠️ [APP] Missing URL in message")
+                return
+            
+            is_valid_url = (
+                url.startswith("rtsp://") or 
+                url.startswith("worker-source/") or 
+                self._is_direct_device(url)
+            )
+            
+            if not is_valid_url:
+                logger.error(f"⚠️ [APP] Invalid URL: {url} (must be RTSP, worker-source file, or direct device)")
                 return
 
             if stream_duration <= 0:
@@ -131,13 +152,16 @@ class VideoStreamWorker:
             logger.error("🚨 [APP] Error processing video preview message.", exc_info=True)
 
     def _start_stream(self, url, rtmp_server, stream_key, stream_duration, worker_id):
-        """Runs RTSP-to-RTMP streaming in a separate thread."""
+        """Runs streaming to RTMP in a separate thread."""
         try:
             logger.info(f"🎥 [APP] Starting RTMP stream (Worker: {worker_id})")
             
             if url.startswith("worker-source/"):
                 streamer = FileToRTMPStreamer(self.source_file_path / os.path.basename(url), rtmp_server, stream_key, stream_duration)
+            elif self._is_direct_device(url):
+                streamer = DirectDeviceToRTMPStreamer(url, rtmp_server, stream_key, stream_duration)
             else:
+                # Assume RTSP or other supported protocols
                 streamer = RTSPtoRTMPStreamer(url, rtmp_server, stream_key, stream_duration)
 
             streamer.start_stream()

nedo_vision_worker/worker/WorkerManager.py

@@ -18,6 +18,7 @@ class WorkerManager:
         self.config = config
         self.worker_id = self.config.get("worker_id")
         self.server_host = self.config.get("server_host")
+        self.server_port = self.config.get("server_port", 50051)
         self.token = self.config.get("token")
 
         if not self.worker_id:
@@ -29,7 +30,7 @@ class WorkerManager:
 
         # Configure the centralized gRPC client manager
         self.client_manager = GrpcClientManager.get_instance()
-        self.client_manager.configure(self.server_host)
+        self.client_manager.configure(self.server_host, self.server_port)
         
         # Get shared client instance
         self.status_client = self.client_manager.get_client(WorkerStatusClient)
@@ -46,16 +47,9 @@ class WorkerManager:
         """Start processing workers while keeping monitoring workers running."""
         try:
             self.video_stream_worker.start()
-            logger.info("🚀 [APP] Video Stream Worker started.")
-
             self.pipeline_image_worker.start()
-            logger.info("🚀 [APP] Pipeline Image Worker started.")
-
             self.data_sender_worker.start_updating()
-            logger.info("🚀 [APP] Data Sender Worker started updating.")
-            
             self.dataset_frame_worker.start()
-            logger.info("🚀 [APP] Dataset Frame Worker started.")
             
             self._update_status("run")
 
@@ -66,16 +60,9 @@ class WorkerManager:
         """Stop processing workers while keeping monitoring workers running."""
         try:
             self.video_stream_worker.stop()
-            logger.info("🛑 [APP] Video Stream Worker stopped.")
-
             self.pipeline_image_worker.stop()
-            logger.info("🛑 [APP] Pipeline Image Worker stopped.")
-
             self.data_sender_worker.stop_updating()
-            logger.info("🛑 [APP] Data Sender Worker stopped updating.")
-
             self.dataset_frame_worker.stop()
-            logger.info("🛑 [APP] Dataset Frame Worker stopped.")
 
             self._update_status("stop")
 
@@ -87,16 +74,9 @@ class WorkerManager:
         try:
             # Start monitoring workers first
             self.core_action_worker.start()
-            logging.info("🚀 [APP] Core Action Worker started and listening for commands.")
-
             self.data_sync_worker.start()
-            logger.info("🚀 [APP] Data Sync Worker started.")
-
             self.data_sender_worker.start()
-            logger.info("🚀 [APP] Data Sender Worker started.")
-
             self.pipeline_action_worker.start()
-            logger.info("🚀 [APP] Pipeline Action Worker started.")
 
             self._start_workers()
 
@@ -109,16 +89,9 @@ class WorkerManager:
         """Stop all workers including monitoring workers."""
         try:
             self.core_action_worker.stop()
-            logger.info("🛑 [APP] Core Action Worker stopped.")
-
             self.data_sync_worker.stop()
-            logger.info("🛑 [APP] Data Sync Worker stopped.")
-
             self.data_sender_worker.stop()
-            logger.info("🛑 [APP] Data Sender Worker stopped.")
-
             self.pipeline_action_worker.stop()
-            logger.info("🛑 [APP] Pipeline Action Worker stopped.")
 
             self._stop_workers()
 

nedo_vision_worker/worker_service.py

@@ -4,11 +4,9 @@ import signal
 import sys
 import logging
 
-# Set multiprocessing start method to 'spawn' for CUDA compatibility
 try:
     multiprocessing.set_start_method('spawn', force=True)
 except RuntimeError:
-    # Method already set, ignore
     pass
 
 from .initializer.AppInitializer import AppInitializer
@@ -17,7 +15,7 @@ from .config.ConfigurationManager import ConfigurationManager
 from .util.HardwareID import HardwareID
 from .services.GrpcClientBase import set_auth_failure_callback
 from .database.DatabaseManager import set_storage_path
-from . import models  # Ensure all models are registered before DB init
+from . import models
 
 
 class WorkerService:
@@ -33,6 +31,7 @@ class WorkerService:
         system_usage_interval: int = 30,
         rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live",
         storage_path: str = "data",
+        server_port: int = 50051,
     ):
         """
         Initialize the worker service.
@@ -43,6 +42,7 @@ class WorkerService:
             system_usage_interval: Interval for system usage reporting (default: 30)
             rtmp_server: RTMP server URL for video streaming
             storage_path: Storage path for databases and files (default: 'data')
+            server_port: gRPC server port (default: 50051)
         """
         # Set the global storage path before any database operations
         set_storage_path(storage_path)
@@ -55,6 +55,7 @@ class WorkerService:
         self.system_usage_interval = system_usage_interval
         self.rtmp_server = rtmp_server
         self.storage_path = storage_path
+        self.server_port = server_port
         self.config = None
         self.auth_failure_detected = False
         
@@ -119,10 +120,13 @@ class WorkerService:
             # Initialize with token
             AppInitializer.initialize_configuration(hardware_id, server_host, self.token)
 
+            # Set server_port in config for first-time setup
+            ConfigurationManager.set_config("server_port", str(self.server_port))
+
             # Get configuration
             config = ConfigurationManager.get_all_configs()
         else:
-            # Check if server_host or token has changed and update if needed
+            # Check if server_host, server_port, or token has changed and update if needed
             config_updated = False
             
             if config['server_host'] != server_host:
@@ -130,6 +134,12 @@ class WorkerService:
                 config_updated = True
                 self.logger.info(f"✅ [APP] Updated server host to: {server_host}")
             
+            # Check if server_port has changed and update if needed
+            if str(config.get('server_port')) != str(self.server_port):
+                ConfigurationManager.set_config("server_port", str(self.server_port))
+                config_updated = True
+                self.logger.info(f"✅ [APP] Updated server port to: {self.server_port}")
+            
             # Check if token has changed and update if needed
             if self.token and config.get('token') != self.token:
                 ConfigurationManager.set_config("token", self.token)
@@ -240,6 +250,12 @@ def main():
         default="be.vision.sindika.co.id",
         help="Manager server host (default: be.vision.sindika.co.id)"
     )
+    parser.add_argument(
+        "--server-port",
+        type=int,
+        default=50051,
+        help="gRPC server port (default: 50051)"
+    )
     parser.add_argument(
         "--system-usage-interval",
         type=int,
@@ -251,10 +267,11 @@ def main():
     # Create and run worker service
     service = WorkerService(
         server_host=args.server_host,
+        server_port=args.server_port,
         system_usage_interval=args.system_usage_interval
     )
     service.run()
 
 
 if __name__ == "__main__":
-    main() 
+    main()

{nedo_vision_worker-1.1.3.dist-info → nedo_vision_worker-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker
-Version: 1.1.3
+Version: 1.2.1
 Summary: Nedo Vision Worker Service Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -179,10 +179,8 @@ This will check:
 - ✅ Python version and dependencies
 - ✅ FFmpeg installation and functionality
 - ✅ OpenCV installation and optimizations
-- ✅ gRPC connectivity
 - ✅ NVIDIA GPU support and capabilities
 - ✅ Storage permissions
-- ✅ Network connectivity
 
 ## 📖 Quick Start