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

nedo_vision_worker_core/util/DrawingUtils.py

@@ -0,0 +1,354 @@
+import math
+import cv2
+import numpy as np
+import os
+
+class DrawingUtils:
+    _color_map = {
+        True: "blue",
+        False: "red",
+        None: "blue"
+    }
+
+
+    _corner_images_by_color = {}
+    _line_images_by_color = {}
+    _inner_frame_image_by_color = {}
+    _corner_half_by_color = {}
+    _line_half_by_color = {}
+    _line_size_by_color = {}
+    _corner_quarter_by_color = {}
+    
+    _asset_cache = {}
+    _base_height = 720
+    _scale_weight = 1.3
+    _max_scale = 3.0
+    
+    @staticmethod
+    def initialize(assets_path: str):
+        for color_flag, color_name in DrawingUtils._color_map.items():
+            top_left = cv2.imread(os.path.join(assets_path, color_name, "top_left.png"), cv2.IMREAD_UNCHANGED)
+            top_right = cv2.imread(os.path.join(assets_path, color_name, "top_right.png"), cv2.IMREAD_UNCHANGED)
+
+            DrawingUtils._corner_images_by_color[color_flag] = {
+                'top_left': top_left,
+                'top_right': top_right,
+                'bottom_left': cv2.flip(top_right, -1),
+                'bottom_right': cv2.flip(top_left, -1)
+            }
+
+            line = cv2.imread(os.path.join(assets_path, color_name, "line.png"), cv2.IMREAD_UNCHANGED)
+            DrawingUtils._line_images_by_color[color_flag] = {
+                'vertical': line,
+                'horizontal': cv2.rotate(line, cv2.ROTATE_90_CLOCKWISE)
+            }
+            
+            inner_frame = cv2.imread(os.path.join(assets_path, color_name, "inner_frame.png"), cv2.IMREAD_UNCHANGED)
+            DrawingUtils._inner_frame_image_by_color[color_flag] = inner_frame
+            
+            # Initialize cache for the base resolution
+            DrawingUtils._prepare_scaled_assets(DrawingUtils._base_height, color_flag)
+
+    @staticmethod
+    def _get_scale_factor(height):
+        if height <= DrawingUtils._base_height:
+            return height / DrawingUtils._base_height * DrawingUtils._scale_weight
+        
+        base_scale = DrawingUtils._scale_weight
+        height_ratio = height / DrawingUtils._base_height
+        additional_scale = (math.sqrt(height_ratio) - 1) * 0.5
+        
+        return min(base_scale + additional_scale, DrawingUtils._max_scale)
+
+    @staticmethod
+    def _prepare_scaled_assets(frame_height, color_flag):
+        """Prepare and cache scaled assets for a specific frame height"""
+        scale_factor = DrawingUtils._get_scale_factor(frame_height)
+        key = DrawingUtils._color_map.get(color_flag)
+        
+        if (frame_height, key) in DrawingUtils._asset_cache:
+            return DrawingUtils._asset_cache[(frame_height, key)]
+            
+        corner_size = int(80 * scale_factor)
+        
+        scaled_corners = {}
+        for position, img in DrawingUtils._corner_images_by_color[color_flag].items():
+            scaled_corners[position] = cv2.resize(img, (corner_size, corner_size))
+            
+        line_size = int(15 * scale_factor)
+        
+        scaled_lines = {}
+        for direction, img in DrawingUtils._line_images_by_color[color_flag].items():
+            scaled_lines[direction] = cv2.resize(img, (line_size, line_size))
+        
+        corner_half = corner_size // 2
+        corner_quarter = corner_size // 4
+        line_half = line_size // 2
+        
+        cache_entry = {
+            'corners': scaled_corners,
+            'lines': scaled_lines,
+            'line_size': line_size,
+            'line_half': line_half,
+            'corner_half': corner_half,
+            'corner_quarter': corner_quarter,
+            'scale_factor': scale_factor
+        }
+        
+        DrawingUtils._asset_cache[(frame_height, key)] = cache_entry
+        return cache_entry
+
+    @staticmethod
+    def draw_alpha_overlay(dest, src, x, y):
+        if src is None or dest is None:
+            return
+
+        # Get source dimensions
+        src_h, src_w = src.shape[:2]
+        
+        # Calculate safe region bounds
+        dest_h, dest_w = dest.shape[:2]
+        y_start = max(y, 0)
+        x_start = max(x, 0)
+        y_end = min(y + src_h, dest_h)
+        x_end = min(x + src_w, dest_w)
+        
+        # Calculate source crop coordinates
+        crop_y1 = max(-y, 0)
+        crop_x1 = max(-x, 0)
+        crop_y2 = src_h - max((y + src_h) - dest_h, 0)
+        crop_x2 = src_w - max((x + src_w) - dest_w, 0)
+
+        # Check if there's any valid area to draw
+        if crop_y2 <= crop_y1 or crop_x2 <= crop_x1:
+            return
+
+        # Crop source image to valid region
+        src_cropped = src[crop_y1:crop_y2, crop_x1:crop_x2]
+        roi = dest[y_start:y_end, x_start:x_end]
+
+        if src_cropped.shape[2] == 4:
+            # Split source into color and alpha channels
+            src_bgr = src_cropped[:, :, :3]
+            alpha = src_cropped[:, :, 3:] / 255.0
+            
+            # Blend with ROI using alpha
+            if roi.shape[:2] == src_bgr.shape[:2]:
+                blended = (src_bgr * alpha) + (roi[:, :, :3] * (1 - alpha))
+                roi[:, :, :3] = blended.astype(np.uint8)
+        else:
+            if roi.shape == src_cropped.shape:
+                roi[:] = src_cropped
+
+    @staticmethod
+    def draw_bbox_info(frame, bbox, color_data, title, subtitle, suffix):
+        color, flag = color_data
+        x1, y1, x2, y2 = map(int, bbox)
+        
+        frame_height = frame.shape[0]
+        scale_factor = DrawingUtils._get_scale_factor(frame_height)
+
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 0.25 * scale_factor
+        title_scale = 0.4 * scale_factor
+
+        # Colors
+        text_color = (255, 255, 255)
+
+        # Measure text sizes
+        (_, title_h), _ = cv2.getTextSize(title, font, title_scale, 1)
+        (_, subtitle_h), _ = cv2.getTextSize(subtitle, font, font_scale, 1)
+        (suffix_w, _), _ = cv2.getTextSize(suffix, font, font_scale, 1)
+
+        padding = int(15 * scale_factor)
+        line_spacing = int(7 * scale_factor)
+
+        subtitle_y = y2 - padding
+        title_y = subtitle_y - subtitle_h - line_spacing
+        block_height = title_h + subtitle_h + line_spacing + 2 * padding
+
+        alpha_start = 0.6
+        alpha_end = 0
+
+        for i in range(block_height):
+            relative_pos = i / block_height
+            alpha = alpha_start + (alpha_end - alpha_start) * (1 - relative_pos) 
+            
+            y_pos = y2 - block_height + i
+            if y_pos < 0 or y_pos >= frame.shape[0]:
+                continue
+
+            original_row = frame[y_pos, x1:x2].astype(np.float32)
+            blended_row = (1 - alpha) * original_row + alpha * np.array(color, dtype=np.float32)
+            frame[y_pos, x1:x2] = blended_row.astype(np.uint8)
+
+        # Draw texts
+        cv2.putText(frame, title, (x1 + padding, title_y), font, title_scale, text_color, 2, cv2.LINE_AA)
+        cv2.putText(frame, subtitle, (x1 + padding, subtitle_y), font, font_scale, text_color, 1, cv2.LINE_AA)
+        cv2.putText(frame, suffix, (x2 - suffix_w - padding, subtitle_y), font, font_scale, text_color, 1, cv2.LINE_AA)
+
+    @staticmethod
+    def draw_corner_line(frame, bbox, color, thickness=1):
+        x1, y1, x2, y2 = map(int, bbox)
+        
+        # Scale the corner length based on frame height
+        frame_height = frame.shape[0]
+        scale_factor = DrawingUtils._get_scale_factor(frame_height)
+        
+        # Scale thickness
+        scaled_thickness = max(1, int(thickness * scale_factor))
+        
+        corner_length = min(x2 - x1, y2 - y1) // 6
+
+        cv2.line(frame, (x1, y1), (x1 + corner_length, y1), color, scaled_thickness)
+        cv2.line(frame, (x1, y1), (x1, y1 + corner_length), color, scaled_thickness)
+
+        cv2.line(frame, (x2, y1), (x2 - corner_length, y1), color, scaled_thickness)
+        cv2.line(frame, (x2, y1), (x2, y1 + corner_length), color, scaled_thickness)
+
+        cv2.line(frame, (x1, y2), (x1 + corner_length, y2), color, scaled_thickness)
+        cv2.line(frame, (x1, y2), (x1, y2 - corner_length), color, scaled_thickness)
+
+        cv2.line(frame, (x2, y2), (x2 - corner_length, y2), color, scaled_thickness)
+        cv2.line(frame, (x2, y2), (x2, y2 - corner_length), color, scaled_thickness)
+
+    @staticmethod
+    def draw_main_bbox(frame, bbox, color_data):
+        color, flag = color_data
+
+        x1, y1, x2, y2 = map(int, bbox)
+        h, w = y2 - y1, x2 - x1
+        
+        frame_height = frame.shape[0]
+        
+        assets_data = DrawingUtils._prepare_scaled_assets(frame_height, flag)
+        if not assets_data:
+            return frame
+            
+        assets = assets_data['corners']
+        lines = assets_data['lines']
+        line_size = assets_data['line_size']
+        half_line = assets_data['line_half']
+        half_corner = assets_data['corner_half']
+        quarter_corner = assets_data['corner_quarter']
+        scale_factor = assets_data['scale_factor']
+        
+        # Define minimum size threshold for corners (scaled)
+        min_size_threshold = int(half_corner * scale_factor)
+        
+        if h < min_size_threshold or w < min_size_threshold:
+            half_corner = 0
+            quarter_corner = 0
+
+        # Draw vertical lines (optimized)
+        vertical_line = lines['vertical']
+        if vertical_line is not None:
+            line_h = h - half_corner
+            if line_h > 0:
+                line = cv2.resize(vertical_line, (line_size, line_h))
+                DrawingUtils.draw_alpha_overlay(frame, line, x1 - half_line, y1 + quarter_corner)
+                DrawingUtils.draw_alpha_overlay(frame, line, x2 - half_line, y1 + quarter_corner)
+
+        # Draw horizontal lines (optimized)
+        horizontal_line = lines['horizontal']
+        if horizontal_line is not None:
+            line_w = w - half_corner
+            if line_w > 0:
+                line = cv2.resize(horizontal_line, (line_w, line_size))
+                DrawingUtils.draw_alpha_overlay(frame, line, x1 + quarter_corner, y1 - half_line)
+                DrawingUtils.draw_alpha_overlay(frame, line, x1 + quarter_corner, y2 - half_line)
+
+        if h < min_size_threshold or w < min_size_threshold:
+            # For small bounding boxes, just use lines
+            scaled_thickness = max(1, int(2 * scale_factor))
+            DrawingUtils.draw_corner_line(frame, bbox, color, scaled_thickness)
+        else:
+            # Draw corners
+            DrawingUtils.draw_alpha_overlay(frame, assets['top_left'], x1 - half_corner, y1 - half_corner)
+            DrawingUtils.draw_alpha_overlay(frame, assets['top_right'], x2 - half_corner, y1 - half_corner)
+            DrawingUtils.draw_alpha_overlay(frame, assets['bottom_left'], x1 - half_corner, y2 - half_corner)
+            DrawingUtils.draw_alpha_overlay(frame, assets['bottom_right'], x2 - half_corner, y2 - half_corner)
+
+        return frame
+
+    @staticmethod
+    def draw_inner_box(frame, bbox, color_data, thickness=1):
+        color, flag = color_data
+
+        if flag is None:
+            return frame
+
+        x1, y1, x2, y2 = map(int, bbox)
+        h, w = y2 - y1, x2 - x1
+        
+        frame_height = frame.shape[0]
+        scale_factor = DrawingUtils._get_scale_factor(frame_height)
+        
+        # Scale thickness
+        scaled_thickness = max(1, int(thickness * scale_factor))
+        
+        # Get original texture
+        texture = DrawingUtils._inner_frame_image_by_color.get(flag)
+
+        if texture is None:
+            return frame
+
+        # Draw texture with alpha blending
+        if texture.shape[2] == 4:
+            resized_texture = cv2.resize(texture, (w, h))
+            DrawingUtils.draw_alpha_overlay(frame, resized_texture, x1, y1)
+        else:
+            frame[y1:y2, x1:x2] = cv2.resize(texture, (w, h))
+
+        DrawingUtils.draw_corner_line(frame, bbox, color, scaled_thickness)
+
+        return frame
+    
+    @staticmethod
+    def crop_with_bounding_box(frame, obj, target_height=512, buffer=30):
+        img_h, img_w = frame.shape[:2]
+        x1, y1, x2, y2 = map(int, obj["bbox"])
+
+        current_height = y2 - y1
+        target_height = target_height if target_height else current_height + buffer * 2
+        scale = (target_height - buffer * 2) / current_height
+
+        # Calculate buffer based on edge proximity
+        scaled_buffer = int(buffer / scale)
+        
+        # Check if bounding box is at the edges
+        at_left_edge = x1 <= scaled_buffer
+        at_right_edge = x2 >= img_w - scaled_buffer
+        at_top_edge = y1 <= scaled_buffer
+        at_bottom_edge = y2 >= img_h - scaled_buffer
+        
+        # Apply buffer only if not at edges
+        crop_x1 = max(x1 - (0 if at_left_edge else scaled_buffer), 0)
+        crop_y1 = max(y1 - (0 if at_top_edge else scaled_buffer), 0)
+        crop_x2 = min(x2 + (0 if at_right_edge else scaled_buffer), img_w)
+        crop_y2 = min(y2 + (0 if at_bottom_edge else scaled_buffer), img_h)
+
+        cropped = frame[crop_y1:crop_y2, crop_x1:crop_x2]
+        _, cropped_w = cropped.shape[:2]
+
+        target_width = int(cropped_w * scale)
+        final_img = cv2.resize(cropped, (target_width, target_height), interpolation=cv2.INTER_AREA)
+
+        def transform_bbox(bbox):
+            x1, y1, x2, y2 = bbox
+
+            nx1 = int((x1 - crop_x1) * scale)
+            ny1 = int((y1 - crop_y1) * scale)
+            nx2 = int((x2 - crop_x1) * scale)
+            ny2 = int((y2 - crop_y1) * scale)
+            return (nx1, ny1, nx2, ny2)
+
+        obj = obj.copy()
+        obj["bbox"] = transform_bbox(obj["bbox"])
+
+        for attr in obj.get("attributes", []):
+            if "bbox" in attr:
+                attr["bbox"] = transform_bbox(attr["bbox"])
+
+        return final_img, obj
+

nedo_vision_worker_core/util/ModelReadinessChecker.py

@@ -0,0 +1,188 @@
+import logging
+from typing import Dict, Any
+from ..models.ai_model import AIModelEntity
+from ..database.DatabaseManager import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class ModelReadinessChecker:
+    """Utility class to check model readiness and provide detailed status information."""
+    
+    @staticmethod
+    def check_model_readiness(model: AIModelEntity) -> Dict[str, Any]:
+        """
+        Comprehensive check of model readiness.
+        
+        Args:
+            model: The AI model entity to check
+            
+        Returns:
+            Dictionary with readiness status and details
+        """
+        if not model:
+            return {
+                "ready": False,
+                "reason": "No model provided",
+                "status": "none"
+            }
+        
+        # Check download status
+        if not model.is_ready_for_use():
+            if model.is_downloading():
+                return {
+                    "ready": False,
+                    "reason": f"Model {model.name} is still downloading",
+                    "status": model.download_status,
+                    "model_name": model.name
+                }
+            elif model.has_download_failed():
+                return {
+                    "ready": False,
+                    "reason": f"Model {model.name} download failed: {model.download_error}",
+                    "status": model.download_status,
+                    "model_name": model.name,
+                    "error": model.download_error
+                }
+            else:
+                return {
+                    "ready": False,
+                    "reason": f"Model {model.name} is not ready (status: {model.download_status})",
+                    "status": model.download_status,
+                    "model_name": model.name
+                }
+        
+        # Check if file exists and has content
+        file_path = DatabaseManager.STORAGE_PATHS["models"] / model.file
+        if not file_path.exists():
+            return {
+                "ready": False,
+                "reason": f"Model file not found: {file_path}",
+                "status": model.download_status,
+                "model_name": model.name,
+                "file_path": str(file_path)
+            }
+        
+        if file_path.stat().st_size == 0:
+            return {
+                "ready": False,
+                "reason": f"Model file is empty: {file_path}",
+                "status": model.download_status,
+                "model_name": model.name,
+                "file_path": str(file_path)
+            }
+        
+        return {
+            "ready": True,
+            "reason": "Model is ready for use",
+            "status": model.download_status,
+            "model_name": model.name,
+            "file_path": str(file_path),
+            "file_size": file_path.stat().st_size
+        }
+    
+    @staticmethod
+    def log_model_status(model: AIModelEntity, context: str = ""):
+        """
+        Log detailed model status information.
+        
+        Args:
+            model: The AI model entity to check
+            context: Additional context for the log message
+        """
+        if not model:
+            logger.warning(f"⚠️ {context}: No model provided")
+            return
+        
+        readiness = ModelReadinessChecker.check_model_readiness(model)
+        
+        if readiness["ready"]:
+            logger.info(f"✅ {context}: Model {model.name} is ready (size: {readiness.get('file_size', 0)} bytes)")
+        else:
+            if readiness["status"] == "downloading":
+                logger.warning(f"⏳ {context}: {readiness['reason']}")
+            elif readiness["status"] == "failed":
+                logger.error(f"❌ {context}: {readiness['reason']}")
+            else:
+                logger.warning(f"⚠️ {context}: {readiness['reason']}")
+    
+    @staticmethod
+    def get_models_status(models: list) -> Dict[str, Any]:
+        """
+        Get status summary for multiple models.
+        
+        Args:
+            models: List of AI model entities
+            
+        Returns:
+            Dictionary with status summary
+        """
+        if not models:
+            return {
+                "total": 0,
+                "ready": 0,
+                "downloading": 0,
+                "failed": 0,
+                "other": 0
+            }
+        
+        summary = {
+            "total": len(models),
+            "ready": 0,
+            "downloading": 0,
+            "failed": 0,
+            "other": 0,
+            "details": []
+        }
+        
+        for model in models:
+            readiness = ModelReadinessChecker.check_model_readiness(model)
+            summary["details"].append({
+                "model_name": model.name,
+                "model_id": model.id,
+                "status": readiness["status"],
+                "ready": readiness["ready"],
+                "reason": readiness["reason"]
+            })
+            
+            if readiness["ready"]:
+                summary["ready"] += 1
+            elif readiness["status"] == "downloading":
+                summary["downloading"] += 1
+            elif readiness["status"] == "failed":
+                summary["failed"] += 1
+            else:
+                summary["other"] += 1
+        
+        return summary
+    
+    @staticmethod
+    def log_models_summary(models: list, context: str = ""):
+        """
+        Log summary of multiple models status.
+        
+        Args:
+            models: List of AI model entities
+            context: Additional context for the log message
+        """
+        summary = ModelReadinessChecker.get_models_status(models)
+        
+        if summary["total"] == 0:
+            logger.info(f"📊 {context}: No models available")
+            return
+        
+        logger.info(f"📊 {context}: Models status - "
+                   f"Ready: {summary['ready']}/{summary['total']}, "
+                   f"Downloading: {summary['downloading']}, "
+                   f"Failed: {summary['failed']}, "
+                   f"Other: {summary['other']}")
+        
+        # Log details for non-ready models
+        for detail in summary["details"]:
+            if not detail["ready"]:
+                if detail["status"] == "downloading":
+                    logger.warning(f"⏳ {context}: {detail['reason']}")
+                elif detail["status"] == "failed":
+                    logger.error(f"❌ {context}: {detail['reason']}")
+                else:
+                    logger.warning(f"⚠️ {context}: {detail['reason']}")

nedo_vision_worker_core/util/PersonAttributeMatcher.py

@@ -0,0 +1,70 @@
+from .BoundingBoxMetrics import BoundingBoxMetrics
+
+EXCLUSIVE_LABEL_GROUPS = [
+    ("helmet", "no_helmet"),
+    ("vest", "no_vest"),
+    ("gloves", "no_gloves"),
+    ("goggles", "no_goggles"),
+    ("boots", "no_boots"),
+]
+
+MULTI_INSTANCE_CLASSES = ["boots", "gloves", "goggles", "no_gloves"]
+
+NEGATIVE_CLASSES = ["no_helmet", "no_vest", "no_goggles", "no_boots"]
+
+class PersonAttributeMatcher:
+    @staticmethod
+    def match_persons_with_attributes(persons, attributes, coverage_threshold=0.2):
+        matched_results = []
+
+        exclusive_groups = []
+        for group in EXCLUSIVE_LABEL_GROUPS:
+            exclusive_groups.append(set(group))
+        exclusive_labels = set(l for group in EXCLUSIVE_LABEL_GROUPS for l in group)
+
+        for person in persons:
+            person_bbox = person["bbox"]
+            matched_attributes = []
+            for attr in attributes:
+                attr_bbox = attr["bbox"]
+                coverage = BoundingBoxMetrics.compute_coverage(person_bbox, attr_bbox)
+                if coverage >= coverage_threshold:
+                    matched_attributes.append({
+                        "label": attr["label"],
+                        "confidence": attr["confidence"],
+                        "coverage": round(coverage, 2),
+                        "bbox": attr_bbox
+                    })
+            
+            filtered_attributes = []
+            
+            for group in exclusive_groups:
+                group_attrs = [a for a in matched_attributes if a["label"] in group]
+                if group_attrs:
+                    best = max(group_attrs, key=lambda a: a["confidence"])
+                    filtered_attributes.append(best)
+
+            for attr in matched_attributes:
+                label = attr["label"]
+                is_in_exclusive_group = any(label in group for group in exclusive_groups)
+                if is_in_exclusive_group:
+                    continue
+                if label in MULTI_INSTANCE_CLASSES:
+                    filtered_attributes.append(attr)
+            
+            for attr in matched_attributes:
+                label = attr["label"]
+                if label in MULTI_INSTANCE_CLASSES and label not in NEGATIVE_CLASSES:
+                    already_added = any(
+                        a["label"] == label and list(a["bbox"]) == list(attr["bbox"]) 
+                        for a in filtered_attributes
+                    )
+                    if not already_added:
+                        filtered_attributes.append(attr)
+            matched_results.append({
+                "label": "person",
+                "confidence": person["confidence"],
+                "bbox": person_bbox,
+                "attributes": filtered_attributes
+            })
+        return matched_results

nedo_vision_worker_core/util/PersonRestrictedAreaMatcher.py

@@ -0,0 +1,45 @@
+from typing import List
+from shapely.geometry import Polygon, Point
+
+class PersonRestrictedAreaMatcher:
+    """Matches detected persons with restricted areas defined as polygons."""
+    
+    @staticmethod
+    def match_persons_with_restricted_areas(persons, restricted_areas: List[Polygon]):
+        """
+        Correlates detected persons with restricted areas defined as polygons.
+        Using center point method for detection.
+        
+        Args:
+            persons (list): List of person detections (each detection has 'bbox').
+            restricted_areas (list): List of restricted areas, each defined as a polygon with coordinates.
+            
+        Returns:
+            list: List of persons with matched restricted areas they've entered.
+        """
+        matched_results = []
+        
+        for person in persons:
+            person_bbox = person["bbox"]
+            
+            # Calculate center point of person's bounding box
+            # bbox format is typically [x_min, y_min, x_max, y_max]
+            center_x = (person_bbox[0] + person_bbox[2]) / 2
+            center_y = (person_bbox[1] + person_bbox[3]) / 2
+            center_point = Point(center_x, center_y)
+            
+            in_restricted = any(area.contains(center_point) for area in restricted_areas)
+
+            attributes = [{
+                "label": "in_restricted_area",
+                "confidence": 1.0,
+            }] if in_restricted else []
+
+            matched_results.append({
+                "label": "person",
+                "confidence": person["confidence"],
+                "bbox": person_bbox,
+                "attributes": attributes
+            })
+            
+        return matched_results

nedo_vision_worker_core/util/TablePrinter.py

@@ -0,0 +1,28 @@
+from tabulate import tabulate
+
+class TablePrinter:
+    """Utility class for printing structured data in a tabular format."""
+
+    @staticmethod
+    def print_table(data, headers=None, title="Data Table", table_format="fancy_grid"):
+        """
+        Prints a list of dictionaries or lists in a formatted table.
+
+        Args:
+            data (list): A list of dictionaries or lists containing the data.
+            headers (list, optional): Column headers (if None, inferred from dict keys).
+            title (str, optional): Title for the table (default: "Data Table").
+            table_format (str, optional): Tabulate format (default: "fancy_grid").
+        """
+        if not data:
+            print(f"\n{title}: No data available.\n")
+            return
+
+        # If data is a list of dictionaries, extract headers automatically
+        if isinstance(data[0], dict):
+            if headers is None:
+                headers = list(data[0].keys())
+            data = [[row.get(header, "") for header in headers] for row in data]
+
+        print(f"\n{title}")
+        print(tabulate(data, headers=headers, tablefmt=table_format))

nedo_vision_worker_core/util/__init__.py

@@ -0,0 +1 @@
+