matrice-analytics 0.1.37__tar.gz → 0.1.39__tar.gz

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.37
+Version: 0.1.39
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/matrice_analytics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.37
+Version: 0.1.39
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/src/matrice_analytics/post_processing/usecases/age_gender_detection.py

@@ -31,11 +31,94 @@ import numpy as np
 #import torch
 import re
 from matrice_analytics.post_processing.core.config import BaseConfig, AlertConfig, ZoneConfig
-try:
-    from PIL import Image
-    import onnxruntime as ort
-except:
-    print("Unable to import onnxruntime")
+# Auto-install and import required dependencies for age/gender detection
+def try_import_age_gender_deps():
+    """Try to import onnxruntime and PIL, auto-install if missing or fix NumPy issues."""
+    try:
+        import onnxruntime as ort
+        from PIL import Image
+        print("✓ Age/Gender dependencies imported successfully (onnxruntime, PIL)")
+        return ort, Image
+    except ImportError as e:
+        error_msg = str(e)
+        print(f"⚠ Import failed: {e}")
+
+        # Check if it's a NumPy version mismatch issue
+        if "NumPy" in error_msg and ("1.x" in error_msg or "2." in error_msg):
+            print("→ DETECTED: NumPy version mismatch issue!")
+            print("→ onnxruntime was compiled with NumPy 1.x but NumPy 2.x is installed")
+            print("→ Attempting to downgrade NumPy to version <2...")
+
+            import subprocess
+            import sys
+            try:
+                print("  Downgrading numpy...")
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "numpy<2", "--force-reinstall", "--no-warn-script-location"],
+                    capture_output=True,
+                    text=True,
+                    timeout=300
+                )
+                if result.returncode == 0:
+                    print("  ✓ NumPy downgraded successfully")
+                    print("→ Retrying onnxruntime import...")
+                    import onnxruntime as ort
+                    from PIL import Image
+                    print("✓ Dependencies imported after NumPy downgrade!")
+                    return ort, Image
+                else:
+                    print(f"  ✗ NumPy downgrade failed: {result.stderr}")
+                    return None, None
+            except Exception as numpy_fix_err:
+                print(f"✗ Failed to fix NumPy issue: {numpy_fix_err}")
+                return None, None
+
+        # Not a NumPy issue, try regular installation
+        print("→ Attempting auto-installation of missing packages...")
+        packages = []
+        try:
+            import onnxruntime
+        except ImportError:
+            packages.append("onnxruntime-gpu")
+
+        try:
+            from PIL import Image
+        except ImportError:
+            packages.append("pillow")
+
+        if packages:
+            print(f"→ Installing: {', '.join(packages)}")
+            import subprocess
+            import sys
+            try:
+                for pkg in packages:
+                    print(f"  Installing {pkg}...")
+                    result = subprocess.run(
+                        [sys.executable, "-m", "pip", "install", pkg, "--no-warn-script-location"],
+                        capture_output=True,
+                        text=True,
+                        timeout=300
+                    )
+                    if result.returncode == 0:
+                        print(f"  ✓ {pkg} installed")
+                    else:
+                        print(f"  ✗ Failed: {result.stderr}")
+
+                # Retry import
+                print("→ Retrying imports...")
+                import onnxruntime as ort
+                from PIL import Image
+                print("✓ Dependencies imported after auto-installation!")
+                return ort, Image
+            except Exception as install_err:
+                print(f"✗ Installation failed: {install_err}")
+                return None, None
+        return None, None
+    except Exception as e:
+        print(f"✗ Unexpected error: {e}")
+        return None, None
+
+ort, Image = try_import_age_gender_deps()
 
 
 def apply_category_mapping(results: Any, index_to_category: Dict[str, str]) -> Any:
@@ -89,9 +172,16 @@ def load_model_from_checkpoint(checkpoint_path,local_path):
     """
     Load a model from checkpoint URL
     """
+    if ort is None:
+        raise RuntimeError(
+            "onnxruntime is not available. Cannot load age/gender detection models.\n"
+            "Please install: pip install onnxruntime-gpu\n"
+            "Or downgrade numpy: pip install 'numpy<2'"
+        )
+
     try:
         print(f"Loading model from checkpoint: {checkpoint_path}")
-        
+
         # Check if checkpoint is a URL
         if checkpoint_path.startswith(('http://', 'https://')):
             # Download checkpoint from URL
@@ -153,10 +243,25 @@ class AgeGenderConfig(BaseConfig):
 
     def __post_init__(self):
         if self.gender_url and self.age_url:
-            self.age_url = load_model_from_checkpoint(self.age_url, "age_detection_prod_model.onnx")
-            self.gender_url = load_model_from_checkpoint(self.gender_url, "gender_detection_prod_model.onnx")
+            try:
+                self.age_url = load_model_from_checkpoint(self.age_url, "age_detection_prod_model.onnx")
+                self.gender_url = load_model_from_checkpoint(self.gender_url, "gender_detection_prod_model.onnx")
+                print("✓ Age and Gender models loaded successfully")
+            except RuntimeError as e:
+                print(f"✗ Failed to load Age/Gender models: {e}")
+                print("→ Age/Gender detection will be disabled")
+                self.age_url = None
+                self.gender_url = None
+            except Exception as e:
+                print(f"✗ Unexpected error loading Age/Gender models: {e}")
+                import traceback
+                traceback.print_exc()
+                self.age_url = None
+                self.gender_url = None
         else:
-            raise ValueError("Age and Gender model URL must be passed!")
+            print("⚠ Age and Gender model URLs not provided - detection will be disabled")
+            self.age_url = None
+            self.gender_url = None
         
 
 class AgeGenderUseCase(BaseProcessor):

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/src/matrice_analytics/post_processing/usecases/color/clip.py

@@ -28,24 +28,102 @@ from dataclasses import dataclass, field
 import cv2
 import io
 import threading
-import onnxruntime as ort
-from PIL import Image
 
+# Auto-install and import required dependencies for CLIP color detection
+def try_import_with_auto_install():
+    """
+    Try to import required dependencies, auto-install if missing, then try again.
+    Returns tuple of (ort, Image, CLIPProcessor, ir_files, ir_as_file)
+    """
+    # First attempt: try to import
+    try:
+        import onnxruntime as ort
+        from PIL import Image
+        from transformers import CLIPProcessor
+        from importlib.resources import files as ir_files, as_file as ir_as_file
+        print("✓ CLIP dependencies imported successfully (onnxruntime, PIL, transformers)")
+        return ort, Image, CLIPProcessor, ir_files, ir_as_file
+    except ImportError as e:
+        print(f"⚠ Import failed on first attempt: {e}")
+        print("→ Attempting auto-installation of missing packages...")
+
+        # Try to install missing packages
+        packages_to_install = []
+
+        # Check which specific packages are missing
+        try:
+            import onnxruntime
+        except ImportError:
+            packages_to_install.append("onnxruntime-gpu")
+
+        try:
+            from PIL import Image
+        except ImportError:
+            packages_to_install.append("pillow")
+
+        try:
+            from transformers import CLIPProcessor
+        except ImportError:
+            packages_to_install.append("transformers")
+
+        if packages_to_install:
+            print(f"→ Installing: {', '.join(packages_to_install)}")
+            try:
+                # Use sys.executable to ensure we install to the correct Python environment
+                for package in packages_to_install:
+                    print(f"  Installing {package}...")
+                    result = subprocess.run(
+                        [sys.executable, "-m", "pip", "install", package, "--no-warn-script-location"],
+                        capture_output=True,
+                        text=True,
+                        timeout=300  # 5 minute timeout
+                    )
+                    if result.returncode == 0:
+                        print(f"  ✓ {package} installed successfully")
+                    else:
+                        print(f"  ✗ Failed to install {package}: {result.stderr}")
+
+                # Second attempt: try to import after installation
+                print("→ Retrying imports after installation...")
+                try:
+                    import onnxruntime as ort
+                    from PIL import Image
+                    from transformers import CLIPProcessor
+                    from importlib.resources import files as ir_files, as_file as ir_as_file
+                    print("✓ CLIP dependencies imported successfully after auto-installation!")
+                    return ort, Image, CLIPProcessor, ir_files, ir_as_file
+                except ImportError as e2:
+                    print(f"✗ Import still failed after installation: {e2}")
+                    print("→ Color detection will be disabled")
+                    return None, None, None, None, None
+
+            except subprocess.TimeoutExpired:
+                print("✗ Installation timeout - packages took too long to install")
+                return None, None, None, None, None
+            except Exception as install_error:
+                print(f"✗ Installation error: {install_error}")
+                return None, None, None, None, None
+        else:
+            print("✗ Unable to determine which packages are missing")
+            return None, None, None, None, None
+    except Exception as e:
+        print(f"✗ Unexpected error during import: {e}")
+        return None, None, None, None, None
 
-try:
-    from transformers import CLIPProcessor
-    print("transformers imported successfully")
-    from importlib.resources import files as ir_files, as_file as ir_as_file
-except:
-    ir_files = None
-    ir_as_file = None
-    print("Unable to import transformers/irlib-resources @ clip.py")
+# Execute the auto-install import
+ort, Image, CLIPProcessor, ir_files, ir_as_file = try_import_with_auto_install()
 
 def load_model_from_checkpoint(checkpoint_url: str, providers: Optional[List] = None):
     """
     Load an ONNX model from a URL directly into memory without writing locally.
     Enforces the specified providers (e.g., CUDAExecutionProvider) for execution.
     """
+    if ort is None:
+        raise RuntimeError(
+            "onnxruntime is not available. Cannot load ONNX model.\n"
+            "Please install: pip install onnxruntime-gpu"
+        )
+
     try:
         print(f"Loading model from checkpoint: {checkpoint_url}")
 
@@ -108,6 +186,17 @@ class ClipProcessor:
                  processor_dir: Optional[str] = None,
                  providers: Optional[List[str]] = None):
 
+        # Check if required dependencies are available
+        if ort is None or CLIPProcessor is None or Image is None:
+            raise RuntimeError(
+                "Required dependencies for ClipProcessor are not available.\n"
+                "Missing: " +
+                (("onnxruntime " if ort is None else "") +
+                 ("transformers(CLIPProcessor) " if CLIPProcessor is None else "") +
+                 ("PIL(Image) " if Image is None else "")).strip() + "\n"
+                "Please install: pip install transformers onnxruntime-gpu pillow"
+            )
+
         self.color_category: List[str] = ["black", "white", "yellow", "gray", "red", "blue", "light blue",
         "green", "brown"]
 
@@ -125,14 +214,14 @@ class ClipProcessor:
                 cmd,
                 stdout=log_file,
                 stderr=subprocess.STDOUT,
-                preexec_fn=os.setpgrp   
+                preexec_fn=os.setpgrp
             )
 
         # Determine and enforce providers (prefer CUDA only)
         try:
             available = ort.get_available_providers()
         except Exception:
-            print("You are seein this error because of ort :(")
+            print("Error getting ONNX providers - this should not happen if dependencies check passed")
             available = []
         print("True OG Available ONNX providers:", available, 'providers(if any):',providers)
 
@@ -155,6 +244,14 @@ class ClipProcessor:
 
         # Load CLIPProcessor tokenizer/config from local package data if available
         self.processor = None
+
+        # Double-check CLIPProcessor is available (should never be None at this point due to check above)
+        if CLIPProcessor is None:
+            raise RuntimeError(
+                "CRITICAL: CLIPProcessor is None despite early check. This should never happen.\n"
+                "The auto-installation may have failed. Please manually install: pip install transformers"
+            )
+
         try:
             if self.processor_path and os.path.isdir(self.processor_path):
                 self.processor = CLIPProcessor.from_pretrained(self.processor_path, local_files_only=True)
@@ -163,7 +260,13 @@ class ClipProcessor:
                 self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
         except Exception as e:
             print(f"Falling back to remote CLIPProcessor due to error loading local assets: {e}")
-            self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+            try:
+                self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+            except Exception as e2:
+                raise RuntimeError(
+                    f"Failed to load CLIPProcessor from both local and remote: {e2}\n"
+                    "Please ensure transformers package is properly installed and you have internet connection."
+                )
 
         tok = self.processor.tokenizer(self.color_category, padding=True, return_tensors="np")
         ort_inputs_text = {
@@ -344,7 +447,8 @@ class ClipProcessor:
     def run_image_onnx_on_crops(self, crops):
         valid_crops = []
         for i, crop in enumerate(crops):
-            if isinstance(crop, Image.Image):  # PIL.Image
+            # Check if crop is PIL Image (only if PIL.Image is available)
+            if Image is not None and isinstance(crop, Image.Image):
                 crop = np.array(crop)
             if not isinstance(crop, np.ndarray):
                 print(f"Skipping crop {i}: not a numpy array ({type(crop)})")

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/src/matrice_analytics/post_processing/usecases/color_detection.py

@@ -220,11 +220,10 @@ class ColorDetectionUseCase(BaseProcessor):
                 context = ProcessingContext()
 
             if not input_bytes:
-                print("input_bytes is required for color detection")
+                self.logger.warning("input_bytes is required for color detection")
 
             if not data:
-                #print("data",data)
-                print("Detection data is required for color detection")
+                self.logger.warning("Detection data is required for color detection")
 
             input_format = match_results_structure(data)
             context.input_format = input_format
@@ -296,36 +295,31 @@ class ColorDetectionUseCase(BaseProcessor):
             
             # Initialize detector lazily on first use if enabled
             try:
-                print("About to call process_color_in_frame...")
-                
+                self.logger.debug("About to call process_color_in_frame...")
+
                 if config.enable_detector and self.detector is None:
-                    print("Initializing ClipProcessor for color detection...")
+                    self.logger.info("Initializing ClipProcessor for color detection...")
                     try:
                         self.detector = ClipProcessor()
-                        print("ClipProcessor loaded successfully!")
-                        logger.info("ClipProcessor loaded successfully!")
+                        self.logger.info("ClipProcessor loaded successfully!")
                     except Exception as init_error:
-                        print(f"Failed to initialize ClipProcessor: {init_error}")
-                        logger.error(f"Failed to initialize ClipProcessor: {init_error}")
+                        self.logger.error(f"Failed to initialize ClipProcessor: {init_error}")
                         self.detector = None
 
                 if self.detector is None:
-                    print("Detector is disabled or failed to initialize, skipping color detection")
-                    logger.warning("Detector is disabled or failed to initialize, skipping color detection")
+                    self.logger.warning("Detector is disabled or failed to initialize, skipping color detection")
                     curr_frame_color = {}
                 else:
-                    print(len(color_processed_data))
+                    self.logger.debug(f"Processing {len(color_processed_data)} detections for color classification")
                     curr_frame_color = self.detector.process_color_in_frame(
                         color_processed_data,
                         input_bytes,
                         config.zone_config,
                         stream_info,
                     )
-                    print("process_color_in_frame completed successfully")
+                    self.logger.debug("process_color_in_frame completed successfully")
             except Exception as e:
-                print(f"ERROR in process_color_in_frame: {e}")
-                import traceback
-                traceback.print_exc()
+                self.logger.error(f"ERROR in process_color_in_frame: {e}", exc_info=True)
                 curr_frame_color = {}
 
             self.update_vehicle_stats(curr_frame_color)

{matrice_analytics-0.1.37 → matrice_analytics-0.1.39}/src/matrice_analytics/post_processing/usecases/vehicle_monitoring.py

@@ -606,11 +606,13 @@ class VehicleMonitoringUseCase(BaseProcessor):
                                                 getattr(config.alert_config, 'alert_value', ['JSON']))}
             })
 
-        human_text_lines = [f"Tracking Statistics:"]
-        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
-        # Append zone-wise current counts if available
+        # Generate human text similar to people_counting format
+        human_text_lines = []
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
+
+        # Display current counts - zone-wise or category-wise
         if zone_analysis:
-            human_text_lines.append("\tZones (current):")
+            human_text_lines.append("\t- Vehicles Detected by Zone:")
             for zone_name, zone_data in zone_analysis.items():
                 current_count = 0
                 if isinstance(zone_data, dict):
@@ -622,14 +624,20 @@ class VehicleMonitoringUseCase(BaseProcessor):
                             "total",
                             sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
                         )
-                human_text_lines.append(f"\t{zone_name}: {int(current_count)}")
+                human_text_lines.append(f"\t\t- {zone_name}: {int(current_count)}")
         else:
-            for cat, count in per_category_count.items():
-                human_text_lines.append(f"\t{cat}: {count}")
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
-        # Append zone-wise total counts if available
+            human_text_lines.append(f"\t- Vehicles Detected: {total_detections}")
+            if per_category_count:
+                for cat, count in per_category_count.items():
+                    if count > 0:
+                        human_text_lines.append(f"\t\t- {cat}: {count}")
+
+        human_text_lines.append("")
+        human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+
+        # Display total counts - zone-wise or category-wise
         if zone_analysis:
-            human_text_lines.append("\tZones (total):")
+            human_text_lines.append("\t- Total Vehicles by Zone:")
             for zone_name, zone_data in zone_analysis.items():
                 total_count = 0
                 if isinstance(zone_data, dict):
@@ -643,16 +651,23 @@ class VehicleMonitoringUseCase(BaseProcessor):
                         # Last resort: try to sum numeric values present
                         counts_dict = zone_data if isinstance(zone_data, dict) else {}
                         total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
-                human_text_lines.append(f"\t{zone_name}: {int(total_count)}")
+                human_text_lines.append(f"\t\t- {zone_name}: {int(total_count)}")
         else:
-            for cat, count in total_counts_dict.items():
-                if count > 0:
-                    human_text_lines.append(f"\t{cat}: {count}")
+            if total_counts_dict:
+                human_text_lines.append("\t- Total Unique Vehicles:")
+                for cat, count in total_counts_dict.items():
+                    if count > 0:
+                        human_text_lines.append(f"\t\t- {cat}: {count}")
+
+        # Display alerts
         if alerts:
+            human_text_lines.append("")
             for alert in alerts:
                 human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
         else:
+            human_text_lines.append("")
             human_text_lines.append("Alerts: None")
+
         human_text = "\n".join(human_text_lines)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]