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

nedo_vision_worker/__init__.py

@@ -6,5 +6,5 @@ A library for running worker agents in the Nedo Vision platform.
 
 from .worker_service import WorkerService
 
-__version__ = "1.2.1"
+__version__ = "1.2.3"
 __all__ = ["WorkerService"] 

nedo_vision_worker/doctor.py

@@ -87,8 +87,8 @@ class WorkerServiceDoctor:
     def check_python_environment(self) -> None:
         """Comprehensive Python environment validation."""
         version = sys.version_info
-        min_version = (3, 8)
-        recommended_version = (3, 9)
+        min_version = (3, 10)
+        recommended_version = (3, 10)
         
         details = [
             f"Python {version.major}.{version.minor}.{version.micro}",
@@ -891,6 +891,36 @@ class WorkerServiceDoctor:
             performance_impact=performance_impact
         ))
     
+    def check_psutil_installation(self) -> None:
+        """Check if psutil is installed for system monitoring."""
+        details = []
+        recommendations = []
+        try:
+            import psutil
+            version = getattr(psutil, '__version__', 'N/A')
+            details.append(f"psutil version: {version}")
+            status = HealthStatus.GOOD
+            message = "psutil is installed"
+            is_blocking = False
+            performance_impact = "None"
+        except ImportError:
+            status = HealthStatus.WARNING
+            message = "psutil not installed"
+            details.append("System resource monitoring will be disabled.")
+            recommendations.append("Install psutil for system monitoring: pip install psutil")
+            is_blocking = False
+            performance_impact = "Low"
+
+        self._add_result(HealthCheck(
+            name="System Monitoring (psutil)",
+            status=status,
+            message=message,
+            details=details,
+            recommendations=recommendations if recommendations else None,
+            is_blocking=is_blocking,
+            performance_impact=performance_impact
+        ))
+    
     def run_comprehensive_health_check(self) -> List[HealthCheck]:
         """Execute all health checks with progress indication."""
         print("🏥 Nedo Vision Worker Service - Comprehensive Health Check")

nedo_vision_worker/repositories/WorkerSourceRepository.py

@@ -17,6 +17,15 @@ class WorkerSourceRepository:
         except Exception as e:
             logger.error(f"🚨 [APP] Database error while fetching worker sources: {e}", exc_info=True)
             return []
+        
+    
+    def get_worker_sources_by_worker_id(self, worker_id: str):
+        """Retrieve all worker sources from the database."""
+        try:
+            return self.session.query(WorkerSourceEntity).filter_by(worker_id=worker_id).all()
+        except Exception as e:
+            logger.error(f"🚨 [APP] Database error while fetching worker sources: {e}", exc_info=True)
+            return []
     
     def bulk_update_worker_sources(self, updated_records):
         """Batch update worker sources in the database."""
@@ -43,4 +52,4 @@ class WorkerSourceRepository:
                 return None
         except Exception as e:
             logger.error(f"🚨 [APP] Database error while fetching worker source by ID {worker_source_id}: {e}", exc_info=True)
-            return None
+            return None

nedo_vision_worker/services/AIModelClient.py

@@ -160,8 +160,12 @@ class AIModelClient(GrpcClientBase):
 
     def _handle_existing_model(self, server_model, local_model, updated_models: List):
         if not self._model_file_exists(local_model.file):
-            logging.warning(f"⚠️ Model file missing for {local_model.name}. Re-downloading...")
-            self._schedule_download(server_model)
+            # Only schedule download if not already downloading
+            if not self._is_downloading(server_model.id):
+                logging.warning(f"⚠️ Model file missing for {local_model.name}. Re-downloading...")
+                self._schedule_download(server_model)
+            else:
+                logging.debug(f"⏳ Model {local_model.name} is already being downloaded, skipping...")
             return
 
         needs_update, changes = self._check_model_changes(server_model, local_model)
@@ -246,6 +250,12 @@ class AIModelClient(GrpcClientBase):
         local_model.set_main_class(server_model.main_class)
 
     def _schedule_download(self, model):
+        # Check if already downloading - don't cancel and restart
+        if self._is_downloading(model.id):
+            logging.debug(f"⏳ Model {model.name} download already in progress, skipping reschedule")
+            return
+            
+        # Only cancel if there's a stale download entry
         self._cancel_download(model.id)
         
         download_info = DownloadInfo(

nedo_vision_worker/services/GrpcClientBase.py

@@ -68,7 +68,7 @@ class GrpcClientBase:
                 self.connected = False
                 error_msg = str(e)
                 
-                logger.error(f"⚠️ Connection failed ({attempts}/{self.max_retries}): {error_msg}")
+                logger.error(f"⚠️ Connection failed ({attempts}/{self.max_retries}): {error_msg}", exc_info=True)
 
                 if attempts < self.max_retries:
                     sleep_time = retry_interval * (2 ** (attempts - 1))

nedo_vision_worker/services/WorkerSourcePipelineClient.py

@@ -1,18 +1,28 @@
 import logging
 import os
 import time
-import ffmpeg
+import subprocess
 from urllib.parse import urlparse
 from pathlib import Path
 
 from ..database.DatabaseManager import _get_storage_paths
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineDetectionRepository import WorkerSourcePipelineDetectionRepository
-from ..util.FFmpegUtil import get_rtsp_ffmpeg_options, get_stream_timeout_duration
+from ..util.FFmpegUtil import (
+    get_rtsp_ffmpeg_options,
+    get_stream_timeout_duration,
+    get_ffmpeg_version,
+)
 from .GrpcClientBase import GrpcClientBase
 from .SharedDirectDeviceClient import SharedDirectDeviceClient
 from ..protos.WorkerSourcePipelineService_pb2_grpc import WorkerSourcePipelineServiceStub
-from ..protos.WorkerSourcePipelineService_pb2 import GetListByWorkerIdRequest, SendPipelineImageRequest, UpdatePipelineStatusRequest, SendPipelineDebugRequest, SendPipelineDetectionDataRequest
+from ..protos.WorkerSourcePipelineService_pb2 import (
+    GetListByWorkerIdRequest,
+    SendPipelineImageRequest,
+    UpdatePipelineStatusRequest,
+    SendPipelineDebugRequest,
+    SendPipelineDetectionDataRequest,
+)
 from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
 
 
@@ -23,12 +33,11 @@ class WorkerSourcePipelineClient(GrpcClientBase):
         self.debug_repo = WorkerSourcePipelineDebugRepository()
         self.detection_repo = WorkerSourcePipelineDetectionRepository()
         storage_paths = _get_storage_paths()
-        self.source_file_path = storage_paths["files"] / "source_files"
+        self.source_file_path: Path = storage_paths["files"] / "source_files"
         self.shared_device_client = SharedDirectDeviceClient()
-        
-        # Track video playback positions and last fetch times
-        self.video_positions = {}  # {video_path: current_position_in_seconds}
-        self.last_fetch_times = {}  # {video_path: last_fetch_timestamp}
+
+        self.video_positions = {}
+        self.last_fetch_times = {}
 
         try:
             self.connect(WorkerSourcePipelineServiceStub)
@@ -36,132 +45,127 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             logging.error(f"Failed to connect to gRPC server: {e}")
             self.stub = None
 
+
+    # ---------- small helpers ----------
+
+    @staticmethod
+    def _opts_dict_to_cli(opts: dict) -> list:
+        out = []
+        for k, v in opts.items():
+            out += [f"-{k}", str(v)]
+        return out
+
+    @staticmethod
+    def _strip_timeout_keys(d: dict) -> dict:
+        o = dict(d)
+        o.pop("rw_timeout", None)
+        o.pop("stimeout", None)
+        o.pop("timeout", None)
+        return o
+
+    @staticmethod
+    def _rtsp_timeout_flag_by_version() -> str:
+        major, minor, patch = get_ffmpeg_version()
+        return "-timeout" if major >= 5 else "-stimeout"
+
+
+    # ---------- stream detection & video position ----------
+
     def _detect_stream_type(self, url):
         if isinstance(url, str) and url.isdigit():
             return "direct"
-        
+
         parsed_url = urlparse(url)
         if parsed_url.scheme == "rtsp":
             return "rtsp"
-        elif parsed_url.scheme in ["http", "https"] and url.endswith(".m3u8"):
+        if parsed_url.scheme in ["http", "https"] and url.endswith(".m3u8"):
             return "hls"
-        elif url.startswith("worker-source/"):
+        if url.startswith("worker-source/"):
             file_path = self.source_file_path / os.path.basename(url)
             if file_path.exists():
-                video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm', '.m4v']
-                if file_path.suffix.lower() in video_extensions:
+                if file_path.suffix.lower() in (".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv", ".webm", ".m4v"):
                     return "video_file"
             return "image_file"
-        else:
-            return "unknown"
-    
+        return "unknown"
+
     def _get_video_duration(self, file_path):
-        """Get the duration of a video file in seconds."""
         try:
             file_path_str = str(file_path)
             if not os.path.exists(file_path_str):
                 logging.error(f"Video file does not exist: {file_path_str}")
                 return None
-            import subprocess
+
             import json
-            cmd = [
-                'ffprobe',
-                '-v', 'quiet',
-                '-print_format', 'json',
-                '-show_format',
-                file_path_str
-            ]
+            cmd = ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", file_path_str]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
             if result.returncode != 0:
                 logging.error(f"FFprobe failed for {file_path_str}: {result.stderr}")
                 return None
+
             try:
                 probe_data = json.loads(result.stdout)
             except json.JSONDecodeError as e:
                 logging.error(f"Failed to parse ffprobe output for {file_path_str}: {e}")
                 return None
-            if 'format' not in probe_data or 'duration' not in probe_data['format']:
+
+            if "format" not in probe_data or "duration" not in probe_data["format"]:
                 logging.error(f"No duration found in probe result for {file_path_str}")
                 return None
-            duration = probe_data['format']['duration']
-            # Defensive: ensure duration is a float or convertible to float
+
             try:
-                duration_val = float(duration)
+                duration_val = float(probe_data["format"]["duration"])
             except Exception as e:
-                logging.error(f"Duration value not convertible to float: {duration} ({type(duration)}) - {e}", exc_info=True)
+                logging.error(f"Duration value not convertible to float: {e}", exc_info=True)
                 return None
+
             if isinstance(duration_val, bool):
-                logging.error(f"Duration value is boolean, which is invalid: {duration_val}")
+                logging.error("Duration value is boolean, which is invalid")
                 return None
+
             return duration_val
+
         except Exception as e:
             logging.error(f"Error getting video duration for {file_path}: {e}", exc_info=True)
             return None
-    
+
     def _get_current_video_position(self, video_path):
-        """Get or advance the current playback position for a video file based on real time elapsed."""
-        current_time = time.time()
-        
+        now = time.time()
+
         if video_path not in self.video_positions:
             self.video_positions[video_path] = 0.0
-            self.last_fetch_times[video_path] = current_time
+            self.last_fetch_times[video_path] = now
             return 0.0
-        
+
         current_pos = self.video_positions[video_path]
         last_fetch_time = self.last_fetch_times[video_path]
-        
-        # Calculate time elapsed since last fetch
-        time_elapsed = current_time - last_fetch_time
-        
-        # Advance position by the actual time elapsed
-        current_pos += time_elapsed
-        
-        # Get video duration to handle looping
+        current_pos += (now - last_fetch_time)
+
         duration = self._get_video_duration(video_path)
         if duration is not None and isinstance(duration, (int, float)):
-            # Loop back to beginning if we've reached the end
             if current_pos >= duration:
                 current_pos = 0.0
         else:
-            # Default to 120 seconds if we can't get duration
             if current_pos >= 120.0:
                 current_pos = 0.0
-        
-        # Update the stored position and fetch time
+
         self.video_positions[video_path] = current_pos
-        self.last_fetch_times[video_path] = current_time
-        
+        self.last_fetch_times[video_path] = now
         return current_pos
-    
-    def reset_video_position(self, video_path):
-        """Reset the playback position for a specific video file."""
-        if video_path in self.video_positions:
-            self.video_positions[video_path] = 0.0
-            self.last_fetch_times[video_path] = time.time()
-            logging.info(f"Reset video position for {video_path}")
-    
-    def reset_all_video_positions(self):
-        """Reset all video playback positions."""
-        self.video_positions.clear()
-        self.last_fetch_times.clear()
-        logging.info("Reset all video positions")
-    
+
     def get_video_positions_status(self):
-        """Get the current status of all video positions for debugging."""
         status = {}
         for video_path, position in self.video_positions.items():
             duration = self._get_video_duration(video_path)
             last_fetch_time = self.last_fetch_times.get(video_path, None)
             time_since_last_fetch = time.time() - last_fetch_time if last_fetch_time else None
-            
+
             if duration:
-                progress = (position / duration) * 100
                 status[video_path] = {
                     "current_position": position,
                     "duration": duration,
-                    "progress_percent": progress,
+                    "progress_percent": (position / duration) * 100,
                     "last_fetch_time": last_fetch_time,
-                    "time_since_last_fetch": time_since_last_fetch
+                    "time_since_last_fetch": time_since_last_fetch,
                 }
             else:
                 status[video_path] = {
@@ -169,108 +173,126 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                     "duration": None,
                     "progress_percent": None,
                     "last_fetch_time": last_fetch_time,
-                    "time_since_last_fetch": time_since_last_fetch
+                    "time_since_last_fetch": time_since_last_fetch,
                 }
         return status
-    
+
+
+    # ---------- ffmpeg cmd builders ----------
+
+    def _build_ffmpeg_cmd_rtsp(self, url: str) -> list:
+        base_opts = self._strip_timeout_keys(get_rtsp_ffmpeg_options())
+        timeout_flag = self._rtsp_timeout_flag_by_version()
+        in_args = self._opts_dict_to_cli(base_opts) + ["-rtsp_transport", "tcp", timeout_flag, "5000000", "-i", url]
+        return ["ffmpeg", "-hide_banner", "-loglevel", "error"] + in_args + [
+            "-vframes", "1", "-q:v", "2", "-f", "mjpeg", "pipe:1"
+        ]
+
+    def _build_ffmpeg_cmd_hls(self, url: str) -> list:
+        in_args = ["-f", "hls", "-analyzeduration", "10000000", "-probesize", "10000000", "-i", url]
+        return ["ffmpeg", "-hide_banner", "-loglevel", "error"] + in_args + [
+            "-vframes", "1", "-q:v", "2", "-f", "mjpeg", "pipe:1"
+        ]
+
+    def _build_ffmpeg_cmd_video_file(self, file_path: str, pos: float) -> list:
+        in_args = ["-ss", f"{pos:.3f}", "-i", file_path]
+        return ["ffmpeg", "-hide_banner", "-loglevel", "error"] + in_args + [
+            "-vframes", "1", "-q:v", "2", "-f", "mjpeg", "pipe:1"
+        ]
+
+    def _build_ffmpeg_cmd_image_file(self, file_path: str) -> list:
+        in_args = ["-i", file_path]
+        return ["ffmpeg", "-hide_banner", "-loglevel", "error"] + in_args + [
+            "-vframes", "1", "-q:v", "2", "-f", "mjpeg", "pipe:1"
+        ]
+
+
+    # ---------- frame capture ----------
+
     def _get_single_frame_bytes(self, url):
         stream_type = self._detect_stream_type(url)
-        
-        if stream_type == "direct":
-            device_index = int(url)
-            logging.info(f"📹 [APP] Capturing frame from direct video device: {device_index}")
-            
-            # Use the shared device client for direct devices
-            try:
-                # Get device properties first
+        proc = None
+
+        try:
+            if stream_type == "direct":
+                device_index = int(url)
+                logging.info(f"📹 [APP] Capturing frame from direct device: {device_index}")
+
                 width, height, fps, pixel_format = self.shared_device_client.get_video_properties(url)
                 if not width or not height:
                     logging.error(f"Failed to get properties for device {device_index}")
                     return None
-                
-                # Create ffmpeg input using shared device client
-                ffmpeg_input = self.shared_device_client.create_ffmpeg_input(url, width, height, fps)
-                
-            except Exception as e:
-                logging.error(f"Error setting up direct device {device_index}: {e}")
+
+                cmd = self.shared_device_client.create_ffmpeg_cli(url, width, height, fps)
+                cmd += ["-vframes", "1", "-q:v", "2", "-f", "mjpeg", "pipe:1"]
+
+            elif stream_type == "rtsp":
+                cmd = self._build_ffmpeg_cmd_rtsp(url)
+
+            elif stream_type == "hls":
+                cmd = self._build_ffmpeg_cmd_hls(url)
+
+            elif stream_type == "video_file":
+                file_path = self.source_file_path / os.path.basename(url)
+                if not file_path.exists():
+                    logging.error(f"Video file does not exist: {file_path}")
+                    return None
+                pos = self._get_current_video_position(str(file_path))
+                logging.info(f"🎬 [APP] Capturing video frame at {pos:.2f}s from {file_path}")
+                cmd = self._build_ffmpeg_cmd_video_file(str(file_path), pos)
+
+            elif stream_type == "image_file":
+                file_path = self.source_file_path / os.path.basename(url)
+                logging.info(f"🖼️ [APP] Capturing image frame from {file_path}")
+                cmd = self._build_ffmpeg_cmd_image_file(str(file_path))
+
+            else:
+                logging.error(f"Unsupported stream type: {url}")
                 return None
-        elif stream_type == "rtsp":
-            rtsp_options = get_rtsp_ffmpeg_options()
-            ffmpeg_input = ffmpeg.input(url, **rtsp_options)
-        elif stream_type == "hls":
-            ffmpeg_input = (
-                ffmpeg
-                .input(url, format="hls", analyzeduration="10000000", probesize="10000000")
-            )
-        elif stream_type == "video_file":
-            file_path = self.source_file_path / os.path.basename(url)
-            file_path_str = str(file_path)
-            
-            if not os.path.exists(file_path_str):
-                logging.error(f"Video file does not exist: {file_path_str}")
+
+            timeout_s = get_stream_timeout_duration(stream_type)
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+            try:
+                stdout, stderr = proc.communicate(timeout=timeout_s)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                stdout, stderr = proc.communicate()
+                logging.error(f"FFmpeg timed out after {timeout_s}s for {stream_type} stream")
                 return None
-            
-            current_position = self._get_current_video_position(file_path_str)
-            logging.info(f"🎬 [APP] Capturing video frame at position {current_position:.2f}s from {file_path_str}")
-            
-            ffmpeg_input = (
-                ffmpeg
-                .input(file_path_str, ss=current_position)
-            )
-        elif stream_type == "image_file":
-            file_path = self.source_file_path / os.path.basename(url)
-            logging.info(f"🖼️ [APP] Capturing image frame from {file_path}")
-            
-            ffmpeg_input = (
-                ffmpeg
-                .input(str(file_path))
-            )   
-        else:
-            logging.error(f"Unsupported stream type: {url}")
-            return None
 
-        if stream_type == "video_file":
-            process = (
-                ffmpeg_input
-                .output('pipe:', format='mjpeg', vframes=1, q=2)
-                .overwrite_output()
-                .run_async(pipe_stdout=True, pipe_stderr=True)
-            )
-        else:
-            process = (
-                ffmpeg_input
-                .output('pipe:', format='mjpeg', vframes=1, q=2)
-                .overwrite_output()
-                .run_async(pipe_stdout=True, pipe_stderr=True)
-            )
-            
-        try:    
-            # Use appropriate timeout for different stream types
-            timeout_duration = get_stream_timeout_duration(stream_type)
-            stdout, stderr = process.communicate(timeout=timeout_duration)
-            
-            if process.returncode != 0:
-                error_msg = stderr.decode('utf-8', errors='ignore')
-                logging.error(f"FFmpeg error for {stream_type} stream: {error_msg}")
+            if proc.returncode != 0:
+                logging.error(f"FFmpeg error for {stream_type} stream: {(stderr or b'').decode('utf-8', 'ignore')}")
                 return None
-            
+
             if not stdout:
                 logging.error("No data received from FFmpeg")
                 return None
-        
+
             return stdout
-        
+
         except Exception as e:
             logging.error(f"Error capturing frame: {e}", exc_info=True)
             return None
-        
+
         finally:
-            # Release device access for direct devices
             if stream_type == "direct":
-                self.shared_device_client.release_device_access(url)
-            
-            process.terminate()
-            process.wait()
+                try:
+                    self.shared_device_client.release_device_access(url)
+                except Exception:
+                    pass
+            if proc and proc.poll() is None:
+                try:
+                    proc.terminate()
+                    proc.wait(timeout=2)
+                except Exception:
+                    try:
+                        proc.kill()
+                    except Exception:
+                        pass
+
+
+    # ---------- RPCs ----------
 
     def update_pipeline_status(self, pipeline_id: str, status_code: str, token: str):
         if not self.stub:
@@ -283,7 +305,7 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                 pipeline_id=pipeline_id,
                 status_code=status_code,
                 timestamp=timestamp,
-                token=token
+                token=token,
             )
             response = self.handle_rpc(self.stub.UpdateStatus, request)
 
@@ -304,11 +326,10 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             response = self.handle_rpc(self.stub.GetListByWorkerId, request)
 
             if response and response.success:
-                # Create a wrapper function that captures the token
                 def update_status_callback(pipeline_id: str, status_code: str):
                     return self.update_pipeline_status(pipeline_id, status_code, token)
-                
-                self.repo.sync_worker_source_pipelines(response, update_status_callback)  # Sync includes delete, update, insert
+
+                self.repo.sync_worker_source_pipelines(response, update_status_callback)
                 return {"success": True, "message": response.message, "data": response.data}
 
             return {"success": False, "message": response.message if response else "Unknown error"}
@@ -316,22 +337,22 @@ class WorkerSourcePipelineClient(GrpcClientBase):
         except Exception as e:
             logging.error(f"Error fetching worker source pipeline list: {e}")
             return {"success": False, "message": f"Error occurred: {e}"}
-        
+
     def send_pipeline_image(self, worker_source_pipeline_id: str, uuid: str, url: str, token: str):
         if not self.stub:
             return {"success": False, "message": "gRPC connection is not established."}
 
         try:
             frame_bytes = self._get_single_frame_bytes(url)
-            
+
             if not frame_bytes:
                 return {"success": False, "message": "Failed to retrieve frame from source"}
-            
+
             request = SendPipelineImageRequest(
                 worker_source_pipeline_id=worker_source_pipeline_id,
                 uuid=uuid,
                 image=frame_bytes,
-                token=token
+                token=token,
             )
             response = self.handle_rpc(self.stub.SendPipelineImage, request)
 
@@ -342,28 +363,19 @@ class WorkerSourcePipelineClient(GrpcClientBase):
         except Exception as e:
             logging.error(f"Error sending pipeline image: {e}")
             return {"success": False, "message": f"Error occurred: {e}"}
-        
+
     @staticmethod
     def read_image_as_binary(image_path: str) -> bytes:
-        """
-        Reads an image file and returns its binary content.
-
-        Args:
-            image_path (str): Path to the image file.
-
-        Returns:
-            bytes: Binary content of the image.
-        """
-        with open(image_path, 'rb') as image_file:
-            return image_file.read()
-        
+        with open(image_path, "rb") as f:
+            return f.read()
+
     def sync_pipeline_debug(self, token: str):
         if not self.stub:
             return {"success": False, "message": "gRPC connection is not established."}
 
         try:
             debug_entries = self.debug_repo.get_debug_entries_with_data()
-            
+
             for debug_entry in debug_entries:
                 image_binary = self.read_image_as_binary(debug_entry.image_path)
 
@@ -372,7 +384,7 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                     uuid=debug_entry.uuid,
                     data=debug_entry.data,
                     image=image_binary,
-                    token=token
+                    token=token,
                 )
                 response = self.handle_rpc(self.stub.SendPipelineDebug, request)
 
@@ -392,7 +404,7 @@ class WorkerSourcePipelineClient(GrpcClientBase):
 
         try:
             entries = self.detection_repo.get_entries()
-            
+
             for entry in entries:
                 image_binary = self.read_image_as_binary(entry.image_path)
 
@@ -401,7 +413,7 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                     data=entry.data,
                     image=image_binary,
                     timestamp=int(entry.created_at.timestamp() * 1000),
-                    token=token
+                    token=token,
                 )
                 response = self.handle_rpc(self.stub.SendPipelineDetectionData, request)
 
@@ -413,4 +425,4 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             return {"success": True, "message": "Successfully synced debug entries"}
 
         except Exception as e:
-            logging.error(f"Error syncing pipeline debug: {e}")
+            logging.error(f"Error syncing pipeline debug: {e}")

nedo_vision_worker/services/WorkerSourceUpdater.py

@@ -16,9 +16,10 @@ class WorkerSourceUpdater:
     This class is thread-safe and can be used concurrently from multiple threads.
     """
 
-    def __init__(self, server_host: str, token: str):
+    def __init__(self, worker_id: str, token: str):
         storage_paths = _get_storage_paths()
         self.source_file_path = storage_paths["files"] / "source_files"
+        self.worker_id = worker_id
         # Use shared client instead of creating new instance
         self.client = GrpcClientManager.get_shared_client(WorkerSourceClient)
         self.repo = WorkerSourceRepository()
@@ -49,7 +50,7 @@ class WorkerSourceUpdater:
         """
         with self._lock:
             try:
-                worker_sources = self.repo.get_all_worker_sources()
+                worker_sources = self.repo.get_worker_sources_by_worker_id(self.worker_id)
                 updated_records = []
 
                 for source in worker_sources:
@@ -130,7 +131,7 @@ class WorkerSourceUpdater:
         """
         with self._lock:
             try:
-                worker_sources = self.repo.get_all_worker_sources()
+                worker_sources = self.repo.get_worker_sources_by_worker_id(self.worker_id)
                 updated_records = []
 
                 for source in worker_sources:

nedo_vision_worker/util/FFmpegUtil.py

@@ -1,124 +1,73 @@
-"""
-FFmpeg utilities for Jetson compatibility and RTSP stream handling.
-
-This module provides common FFmpeg configurations and utilities that work
-reliably on Jetson devices with FFmpeg 4.4.1 and newer versions.
-"""
-
 import logging
 import subprocess
 import re
-from typing import Dict, Any, Tuple
+from typing import Dict, Any, Tuple, List
 
 
 def get_ffmpeg_version() -> Tuple[int, int, int]:
-    """
-    Get the FFmpeg version as a tuple of (major, minor, patch).
-    
-    Returns:
-        Tuple[int, int, int]: Version tuple (major, minor, patch)
-    """
     try:
-        result = subprocess.run(['ffmpeg', '-version'], capture_output=True, text=True, timeout=5)
+        result = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
         if result.returncode == 0:
-            # Extract version from output like "ffmpeg version n7.1.1" or "ffmpeg version 4.4.1"
-            match = re.search(r'ffmpeg version n?(\d+)\.(\d+)\.(\d+)', result.stdout)
-            if match:
-                return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+            m = re.search(r"ffmpeg version n?(\d+)\.(\d+)(?:\.(\d+))?", result.stdout)
+            if m:
+                major = int(m.group(1))
+                minor = int(m.group(2))
+                patch = int(m.group(3)) if m.group(3) else 0
+                return major, minor, patch
     except Exception as e:
         logging.warning(f"Could not determine FFmpeg version: {e}")
-    
-    # Default to a reasonable version if detection fails
-    return (4, 4, 1)
+    return 4, 4, 1
+
+
+def _supports_rw_timeout(v: Tuple[int, int, int]) -> bool:
+    major, minor, _ = v
+    return major >= 5 or (major == 4 and minor >= 3)
 
 
 def get_rtsp_ffmpeg_options() -> Dict[str, Any]:
-    """
-    Get FFmpeg options optimized for RTSP streams with version compatibility.
-    
-    These options work across different FFmpeg versions:
-    - FFmpeg 4.4.x: Uses stimeout
-    - FFmpeg 5.x+: Uses timeout 
-    - FFmpeg 7.x+: Uses timeout
-    
-    Returns:
-        Dict[str, Any]: FFmpeg input options for RTSP streams
-    """
-    version = get_ffmpeg_version()
-    major, minor, patch = version
-    
-    # Base options that work across all versions
-    options = {
+    v = get_ffmpeg_version()
+
+    opts = {
         "rtsp_transport": "tcp",
-        "fflags": "nobuffer+genpts", 
-        "max_delay": "5000000",  # Max buffering delay
-        "buffer_size": "1024000",  # Input buffer size
-        "avoid_negative_ts": "make_zero"  # Handle timestamp issues
+        "probesize": "256k",
+        "analyzeduration": "1000000",
+        "buffer_size": "1024000",
+        "max_delay": "700000",
+        "fflags": "nobuffer+genpts",
     }
-    
-    # Add version-specific timeout option
-    if major == 4 and minor == 4:
-        # FFmpeg 4.4.x uses stimeout
-        options["stimeout"] = "5000000"
-        logging.debug("Using stimeout for FFmpeg 4.4.x")
+
+    if _supports_rw_timeout(v):
+        opts["rw_timeout"] = "5000000"
     else:
-        # FFmpeg 5.x+ uses timeout (microseconds)
-        options["timeout"] = "5000000"
-        logging.debug(f"Using timeout for FFmpeg {major}.{minor}.{patch}")
-    
-    return options
+        opts["stimeout"] = "5000000"
 
+    return opts
 
-def get_rtsp_probe_options() -> list:
-    """
-    Get ffprobe command line options for RTSP streams with version compatibility.
-    
-    Returns:
-        list: Command line options to insert into ffprobe command
-    """
-    version = get_ffmpeg_version()
-    major, minor, patch = version
-    
-    base_options = ["-rtsp_transport", "tcp"]
-    
-    # Add version-specific timeout option
-    if major == 4 and minor == 4:
-        # FFmpeg 4.4.x uses stimeout
-        return base_options + ["-stimeout", "5000000"]
-    else:
-        # FFmpeg 5.x+ uses timeout
-        return base_options + ["-timeout", "5000000"]
 
+def get_rtsp_probe_options() -> List[str]:
+    v = get_ffmpeg_version()
 
-def log_ffmpeg_version_info():
-    """Log information about FFmpeg compatibility."""
-    version = get_ffmpeg_version()
-    major, minor, patch = version
-    
-    logging.info(f"Detected FFmpeg version: {major}.{minor}.{patch}")
-    
-    if major == 4 and minor == 4:
-        logging.info("Using 'stimeout' parameter for FFmpeg 4.4.x compatibility")
-    else:
-        logging.info(f"Using 'timeout' parameter for FFmpeg {major}.{minor}.{patch}")
-    
-    logging.info("RTSP configuration optimized for embedded devices")
+    opts = [
+        "-v", "error",
+        "-rtsp_transport", "tcp",
+        "-probesize", "256k",
+        "-analyzeduration", "1000000",
+    ]
 
+    opts += ["-rw_timeout" if _supports_rw_timeout(v) else "-stimeout", "5000000"]
+    return opts
 
-def get_stream_timeout_duration(stream_type: str) -> int:
-    """
-    Get appropriate timeout duration for different stream types.
-    
-    Args:
-        stream_type (str): Type of stream (rtsp, hls, direct, etc.)
-        
-    Returns:
-        int: Timeout duration in seconds
-    """
-    timeouts = {
-        "rtsp": 30,     # RTSP streams may take longer to connect
-        "hls": 20,      # HLS streams need time for manifest download
-        "direct": 10,   # Direct device access should be faster
-        "video_file": 5 # Local files should be very fast
-    }
-    return timeouts.get(stream_type, 15)  # Default 15 seconds
+
+def get_stream_timeout_duration(t: str) -> int:
+    return {
+        "rtsp": 30,
+        "hls": 20,
+        "direct": 10,
+        "video_file": 5,
+    }.get(t, 15)

nedo_vision_worker/util/VideoProbeUtil.py

@@ -103,8 +103,7 @@ class VideoProbeUtil:
                 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}",
@@ -183,8 +182,6 @@ class VideoProbeUtil:
             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}",
@@ -246,13 +243,11 @@ class VideoProbeUtil:
                     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:

nedo_vision_worker/worker/DataSenderWorker.py

@@ -61,7 +61,7 @@ class DataSenderWorker:
         self.restricted_area_manager = RestrictedAreaManager(self.server_host, self.worker_id, "worker_source_id", self.token)
         self.dataset_frame_sender = DatasetFrameSender(self.server_host, self.token)
 
-        self.source_updater = WorkerSourceUpdater(self.server_host, self.token)
+        self.source_updater = WorkerSourceUpdater(self.worker_id, self.token)
 
     def start(self):
         """Start the Data Sender Worker threads."""

nedo_vision_worker/worker/PipelineImageWorker.py

@@ -119,7 +119,7 @@ class PipelineImageWorker:
             if response.get("success"):
                 logger.info("✅ [APP] Successfully sent Pipeline Image Preview.")
             else:
-                logger.error(f"❌ [APP] Failed to send Pipeline Image Preview: {response.get('message')}")
+                logger.error(f"❌ [APP] Failed to send Pipeline Image Preview: {response.get('message')}", exc_info=True)
 
         except json.JSONDecodeError:
             logger.error("⚠️ [APP] Invalid JSON message format.")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker
-Version: 1.2.1
+Version: 1.2.3
 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>
@@ -165,6 +165,8 @@ pip install -e .
 pip install -e .[dev]
 ```
 
+See [INSTALL.md](INSTALL.md) for detailed installation instructions.
+
 ## 🔍 System Diagnostics
 
 Before running the worker service, use the built-in diagnostic tool to verify your system:

{nedo_vision_worker-1.2.1.dist-info → nedo_vision_worker-1.2.3.dist-info}/RECORD

@@ -1,6 +1,6 @@
-nedo_vision_worker/__init__.py,sha256=OuQTi_CjaQDpS1kVellEttgj1dkluSOCwxE0teArbyY,203
+nedo_vision_worker/__init__.py,sha256=pqDMDsWMdJa9lhiPGbws0_2MkJ9HTN-LRnS2eJvzCus,203
 nedo_vision_worker/cli.py,sha256=ddWspJmSgVkcUYvRdkvTtMNuMTDvNCqLLuMVU9KE3Ik,7457
-nedo_vision_worker/doctor.py,sha256=uZ-NM_PfaTG5CG5OWFnl7cEsOTBWMGXNuKWuTV07deg,47228
+nedo_vision_worker/doctor.py,sha256=wNkpe8gLVd76Y_ViyK2h1ZFdqeSl37MnzZN5frWKu30,48410
 nedo_vision_worker/worker_service.py,sha256=rXUVmyxcJPGhQEZ4UQvjQS5UqlnLBYudHQZCj0dQDxo,10421
 nedo_vision_worker/config/ConfigurationManager.py,sha256=QrQaQ9Cdjpkcr2JE_miyrWJIZmMgZwJYBz-wE45Zzes,8011
 nedo_vision_worker/config/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
@@ -45,14 +45,14 @@ nedo_vision_worker/repositories/RestrictedAreaRepository.py,sha256=y3n2ZfQbth1I_
 nedo_vision_worker/repositories/WorkerSourcePipelineDebugRepository.py,sha256=kOlVEnPOoDRZdZIm8uWXlc89GMvBPI-36QyKecX7ucE,3350
 nedo_vision_worker/repositories/WorkerSourcePipelineDetectionRepository.py,sha256=cbgg_7p0eNUIgCHoPDZBaRZ1b2Y68p_dfSxpvuGMtRE,1773
 nedo_vision_worker/repositories/WorkerSourcePipelineRepository.py,sha256=xfmEvgnyt-DdfSApGyFfy0H0dXjFFkjeo4LMr0fVFXU,10053
-nedo_vision_worker/repositories/WorkerSourceRepository.py,sha256=Rw9wJ27TETECCNwDxQu19KaKipQ_XHU0JJP6-0rzgmU,1982
+nedo_vision_worker/repositories/WorkerSourceRepository.py,sha256=AhAJLAacMFdsOgtQNiu7Pahl1DAGI0T1THHeUlKwQJc,2385
 nedo_vision_worker/repositories/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker/services/AIModelClient.py,sha256=lxRNax6FR-pV0G1NpJnlaqjbQeu3kRolIUNSw1RkoZA,15406
+nedo_vision_worker/services/AIModelClient.py,sha256=l9Cn9p_ux3vfUD9fZ8T_PSUWsZmX9OTl3qs-GxanXx8,15958
 nedo_vision_worker/services/ConnectionInfoClient.py,sha256=toC9zuY2Hrx1Cwq8Gycy_iFlaG1DvFT4qewlLlitpEQ,2214
 nedo_vision_worker/services/DatasetSourceClient.py,sha256=O5a7onxFl0z47zXaMXWxHAMPuuc-i_vzkd2w5fwrukc,3319
 nedo_vision_worker/services/DirectDeviceToRTMPStreamer.py,sha256=M5ei0cd3_KDhHZp6EkrOowhAY-hAHfAQh9YDVjQtbQI,22278
 nedo_vision_worker/services/FileToRTMPServer.py,sha256=yUJxrouoTLSq9XZ88dhDYhP-px10jLoHopkPoy4lQxk,2663
-nedo_vision_worker/services/GrpcClientBase.py,sha256=9tNOGFfcm1Vy7ELgiA78KmGYCT13d4nBzpZkRkhsFKI,7385
+nedo_vision_worker/services/GrpcClientBase.py,sha256=bRNeajiPGcJZtNofD_HU7JhLHVPbnuGacqv5Dp62GC0,7400
 nedo_vision_worker/services/GrpcClientManager.py,sha256=DLXekmxlQogLo8V9-TNDXtyHT_UG-BaggqwsIups55k,5568
 nedo_vision_worker/services/ImageUploadClient.py,sha256=T353YsRfm74G7Mh-eWr5nvdQHXTfpKwHJFmNW8HyjT8,3019
 nedo_vision_worker/services/PPEDetectionClient.py,sha256=CC-b0LRAgrftfIKp6TFKpeBkTYefe-C6Z1oz_X3HArQ,4345
@@ -65,34 +65,34 @@ nedo_vision_worker/services/SystemWideDeviceCoordinator.py,sha256=9zBJMCbTMZS7gw
 nedo_vision_worker/services/VideoSharingDaemon.py,sha256=hYMjUIKNUVT1qSxuUuHN-7Bd85MDkxfqslxDLe2PBYQ,29721
 nedo_vision_worker/services/VideoStreamClient.py,sha256=QSgUV3LijYrNdnBG1ylABOdUaSatQamfXaqJhAiol9M,7260
 nedo_vision_worker/services/WorkerSourceClient.py,sha256=vDZeCuHL5QQ2-knZ4TOSA59jzmbbThGIwFKKLEZ72Ws,9198
-nedo_vision_worker/services/WorkerSourcePipelineClient.py,sha256=amhZOua0lmlWl7ZkU-SSbT2E1Y5D-uKde9bDCVxOqM4,17924
-nedo_vision_worker/services/WorkerSourceUpdater.py,sha256=MsUsKL75sXj2odCcbupkFDW0KXg9LSu6-67iMWpYkHs,7679
+nedo_vision_worker/services/WorkerSourcePipelineClient.py,sha256=qaBx9T2gWMzpqZaeQdbIeklsXNwzWD5kqgB41rrSkBI,17135
+nedo_vision_worker/services/WorkerSourceUpdater.py,sha256=r_pCL1NiUlgPUFrntE1DWFG-KJygZPK51lAUGPwlzxo,7758
 nedo_vision_worker/services/WorkerStatusClient.py,sha256=7kC5EZjEBwWtHOE6UQ29OPCpYnv_6HSuH7Tc0alK_2Q,2531
 nedo_vision_worker/services/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker/util/FFmpegUtil.py,sha256=_TRA_Q2CAKatrbhOMKG5Uhhk6FrMJ6sbwMnd0Qwq0co,4086
+nedo_vision_worker/util/FFmpegUtil.py,sha256=QnQrzurmllzGb7SlAAYCrzKBUblweoFU-0h-X-32IYg,1829
 nedo_vision_worker/util/HardwareID.py,sha256=rSW8-6stm7rjXEdkYGqXMUn56gyw62YiWnSwZQVCCLM,4315
 nedo_vision_worker/util/ImageUploader.py,sha256=2xipN3fwpKgFmbvoGIdElpGn5ARJyrgR4dXtbRf73hw,3764
 nedo_vision_worker/util/Networking.py,sha256=uOtL8HkKZXJp02ZZIHWYMAvAsaYb7BsAPTncfdvJx2c,3241
 nedo_vision_worker/util/PlatformDetector.py,sha256=-iLPrKs7hp_oltkCI3hESJQkC2uRyu1-8mAbZrvgWx0,1501
 nedo_vision_worker/util/SystemMonitor.py,sha256=2MWYaEXoL91UANT_-SuDWrFMq1ajPorh8co6Py9PV_c,11300
-nedo_vision_worker/util/VideoProbeUtil.py,sha256=1ViUjt6NSMilquapHf6XC0h93OwhA40LwGSnYOtpMh0,13362
+nedo_vision_worker/util/VideoProbeUtil.py,sha256=cF-vJ7hIDlXfEJby2a0s9tqwkPGVz_6B3Vv4D5pMmIw,12876
 nedo_vision_worker/util/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/worker/CoreActionWorker.py,sha256=lb7zPY3yui6I3F4rX4Ii7JwpWZahLEO72rh3iWOgFmg,5441
-nedo_vision_worker/worker/DataSenderWorker.py,sha256=o32MT28EqYwAPmd9NKhX3rfNlDKekNOI2n8mZ6s8CpU,7162
+nedo_vision_worker/worker/DataSenderWorker.py,sha256=9FudRRItiMOcQx5UfVyu4p0Enb9BbgwZZ5EgX6Ho2U4,7160
 nedo_vision_worker/worker/DataSyncWorker.py,sha256=WvYfi3bG4mOKHU09J_MavfjFPrVgmxrrZYtrlQ-bnio,6265
 nedo_vision_worker/worker/DatasetFrameSender.py,sha256=1SFYj8LJFNi-anBTapsbq8U_NGMM7mnoMKg9NeFAHys,8087
 nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=Ni5gPeDPk9Rz4_cbg63u7Y6LVw_-Bz24OvfeY-6Yp44,19320
 nedo_vision_worker/worker/PPEDetectionManager.py,sha256=fAolWlrsY5SQAWygvjNBNU56IlC0HLlhPgpz7shL-gk,3588
 nedo_vision_worker/worker/PipelineActionWorker.py,sha256=xgvryjKtEsMj4BKqWzDIaK_lFny-DfMCj5Y2DxHnWww,5651
-nedo_vision_worker/worker/PipelineImageWorker.py,sha256=c8_cTasgN-NJABD_qHSRb3hatg81sY_rV3lAAnuW49U,5627
+nedo_vision_worker/worker/PipelineImageWorker.py,sha256=J8VBUG0cwcH3qOJp2zTl30B-XhmPFyvJLjxitKJYq0E,5642
 nedo_vision_worker/worker/RabbitMQListener.py,sha256=9gR49MDplgpyb-D5HOH0K77-DJQFvhS2E7biL92SjSU,6950
 nedo_vision_worker/worker/RestrictedAreaManager.py,sha256=3yoXgQ459tV1bOa5choEzR9gE6LklrtHR_e0472U3L0,3521
 nedo_vision_worker/worker/SystemUsageManager.py,sha256=StutV4UyLUfduYfK20de4SbPd7wqkR7io0gsOajxWSU,4509
 nedo_vision_worker/worker/VideoStreamWorker.py,sha256=5n6v1PNO7IB-jj_McALLkUP-cBjJoIEw4UiSAs3vTb0,7606
 nedo_vision_worker/worker/WorkerManager.py,sha256=T0vMfhOd7YesgQ9o2w6soeJ6n9chUAcuwcGe7p31xr0,5298
 nedo_vision_worker/worker/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker-1.2.1.dist-info/METADATA,sha256=GUzjnngaGQ7i48oY3BMpdPB701o8_n2LxwlayNJb3uw,14591
-nedo_vision_worker-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker-1.2.1.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
-nedo_vision_worker-1.2.1.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
-nedo_vision_worker-1.2.1.dist-info/RECORD,,
+nedo_vision_worker-1.2.3.dist-info/METADATA,sha256=kYHKUmfVIA83cwJaUsW_fmdhf_rBKXW0iCJv2pP1CUQ,14661
+nedo_vision_worker-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker-1.2.3.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
+nedo_vision_worker-1.2.3.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
+nedo_vision_worker-1.2.3.dist-info/RECORD,,