matrice-analytics 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

matrice_analytics/post_processing/usecases/age_gender_detection.py

@@ -31,94 +31,31 @@ import numpy as np
 #import torch
 import re
 from matrice_analytics.post_processing.core.config import BaseConfig, AlertConfig, ZoneConfig
-# 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()
+# Try to import optional age/gender dependencies (fail gracefully if missing)
+ort = None
+Image = None
+
+try:
+    import onnxruntime as ort
+    from PIL import Image
+    print("✓ Age/Gender dependencies available (onnxruntime, PIL)")
+except ImportError as e:
+    error_msg = str(e)
+    print(f"⚠ Age/Gender dependencies not available: {e}")
+
+    # Check if it's a NumPy version mismatch issue and provide helpful message
+    if "NumPy" in error_msg and ("1.x" in error_msg or "2." in error_msg):
+        print("→ DETECTED: NumPy version mismatch!")
+        print("  onnxruntime was compiled with NumPy 1.x but NumPy 2.x is installed")
+        print("  To fix manually: pip install 'numpy<2' --force-reinstall")
+    else:
+        print("  To enable manually: pip install onnxruntime-gpu pillow")
+
+    print("→ Age/Gender detection will be disabled")
+except Exception as e:
+    print(f"⚠ Error importing Age/Gender dependencies: {e}")
+    print("→ Age/Gender detection will be disabled")
 
 
 def apply_category_mapping(results: Any, index_to_category: Dict[str, str]) -> Any:

matrice_analytics/post_processing/usecases/color/clip.py

@@ -29,89 +29,184 @@ import cv2
 import io
 import threading
 
-# Auto-install and import required dependencies for CLIP color detection
-def try_import_with_auto_install():
+# Try to import optional CLIP dependencies (fail gracefully if missing)
+# These will be None if not available, and auto-install will be attempted on first use
+ort = None
+Image = None
+CLIPProcessor = None
+ir_files = None
+ir_as_file = None
+
+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 available (onnxruntime, PIL, transformers)")
+except ImportError as e:
+    print(f"⚠ CLIP dependencies not available at import time: {e}")
+    print("→ Will attempt auto-installation when color detection is first used")
+except Exception as e:
+    print(f"⚠ Error importing CLIP dependencies: {e}")
+    print("→ Color detection may be disabled")
+
+def try_install_clip_dependencies():
     """
-    Try to import required dependencies, auto-install if missing, then try again.
-    Returns tuple of (ort, Image, CLIPProcessor, ir_files, ir_as_file)
+    Attempt to install missing CLIP dependencies.
+    Only called when ClipProcessor is actually instantiated (lazy installation).
+    Returns True if successful, False otherwise.
     """
-    # 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...")
+    print("→ Color detection is being used but dependencies are missing")
+    print("→ Attempting auto-installation of missing packages...")
 
-        # Try to install missing packages
-        packages_to_install = []
+    import platform
+    import subprocess
 
-        # Check which specific packages are missing
-        try:
-            import onnxruntime
-        except ImportError:
-            packages_to_install.append("onnxruntime-gpu")
+    # Detect platform
+    machine = platform.machine().lower()
+    is_jetson = machine in ['aarch64', 'arm64'] or os.path.exists('/etc/nv_tegra_release')
+
+    if is_jetson:
+        print(f"→ Detected Jetson/ARM platform ({machine})")
+    else:
+        print(f"→ Detected x86_64 platform ({machine})")
 
+    packages_to_install = []
+
+    # Helper function to check if package is installed
+    def is_package_installed(package_name):
         try:
-            from PIL import Image
-        except ImportError:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "show", package_name],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    # Check which packages are missing
+    try:
+        import onnxruntime
+        print("→ onnxruntime imported successfully")
+    except ImportError as e:
+        # Check if onnxruntime is installed but import is failing
+        if is_package_installed("onnxruntime"):
+            print(f"→ onnxruntime is installed but import failed: {e}")
+            print("→ This may be due to NumPy version mismatch or CUDA library issues")
+            print("→ Skipping installation, will check other dependencies")
+        elif is_jetson and is_package_installed("onnxruntime-gpu"):
+            print("→ onnxruntime-gpu found on Jetson (this may not work on ARM)")
+            print("→ Attempting import with installed version")
+        else:
+            # Choose appropriate onnxruntime package based on platform
+            if is_jetson:
+                print("→ onnxruntime not installed on Jetson platform")
+                print("→ Note: Jetson usually has onnxruntime pre-installed via JetPack")
+                print("→ If you see this, check your JetPack installation")
+                # Try installing anyway
+                packages_to_install.append("onnxruntime")
+            else:
+                packages_to_install.append("onnxruntime-gpu")
+
+    try:
+        from PIL import Image as PILImage
+        print("→ PIL/Pillow imported successfully")
+    except ImportError:
+        if not is_package_installed("pillow") and not is_package_installed("PIL"):
             packages_to_install.append("pillow")
+        else:
+            print("→ pillow is installed but import failed")
 
-        try:
-            from transformers import CLIPProcessor
-        except ImportError:
+    try:
+        from transformers import CLIPProcessor as CLIP
+        print("→ transformers imported successfully")
+    except ImportError:
+        if not is_package_installed("transformers"):
             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
+            print("→ transformers is installed but import failed (may be incompatible with torch version)")
+
+    if not packages_to_install:
+        print("→ All packages are available, retrying import...")
+    else:
+        print(f"→ Installing: {', '.join(packages_to_install)}")
+
+        import subprocess
+        try:
+            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
+                )
+                if result.returncode == 0:
+                    print(f"  ✓ {package} installed successfully")
+                else:
+                    print(f"  ✗ Failed to install {package}: {result.stderr}")
+                    return False
+        except Exception as install_error:
+            print(f"✗ Installation failed: {install_error}")
+            return False
+
+    # Retry imports after installation (or if packages were already installed)
+    print("→ Attempting to import dependencies...")
+
+    ort_module = None
+    PILImage = None
+    CLIPProc = None
+    ir_files_module = None
+    ir_as_file_module = None
+
+    import_errors = []
+
+    # Try importing each package individually
+    try:
+        import onnxruntime as ort_module
+        print("  ✓ onnxruntime imported")
+    except Exception as e:
+        import_errors.append(f"onnxruntime: {e}")
+        print(f"  ✗ onnxruntime import failed: {e}")
+
+    try:
+        from PIL import Image as PILImage
+        print("  ✓ PIL imported")
+    except Exception as e:
+        import_errors.append(f"PIL: {e}")
+        print(f"  ✗ PIL import failed: {e}")
+
+    try:
+        from transformers import CLIPProcessor as CLIPProc
+        print("  ✓ transformers imported")
+    except Exception as e:
+        import_errors.append(f"transformers: {e}")
+        print(f"  ✗ transformers import failed: {e}")
+
+    try:
+        from importlib.resources import files as ir_files_module, as_file as ir_as_file_module
+        print("  ✓ importlib.resources imported")
     except Exception as e:
-        print(f"✗ Unexpected error during import: {e}")
-        return None, None, None, None, None
+        import_errors.append(f"importlib.resources: {e}")
+        print(f"  ✗ importlib.resources import failed: {e}")
+
+    # Check if we have at least the critical dependencies
+    if ort_module is None or PILImage is None or CLIPProc is None:
+        print(f"✗ Critical dependencies missing after installation attempt")
+        print(f"  Errors: {'; '.join(import_errors)}")
+        return False
+
+    # Update global variables with successfully imported modules
+    globals()['ort'] = ort_module
+    globals()['Image'] = PILImage
+    globals()['CLIPProcessor'] = CLIPProc
+    globals()['ir_files'] = ir_files_module
+    globals()['ir_as_file'] = ir_as_file_module
 
-# Execute the auto-install import
-ort, Image, CLIPProcessor, ir_files, ir_as_file = try_import_with_auto_install()
+    print("✓ CLIP dependencies imported successfully!")
+    return True
 
 def load_model_from_checkpoint(checkpoint_url: str, providers: Optional[List] = None):
     """
@@ -186,16 +281,22 @@ class ClipProcessor:
                  processor_dir: Optional[str] = None,
                  providers: Optional[List[str]] = None):
 
-        # Check if required dependencies are available
+        # Check if required dependencies are available, try auto-install if not
         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"
-            )
+            print("⚠ Color detection dependencies missing, attempting auto-installation...")
+
+            # Try to auto-install missing dependencies (lazy installation)
+            if not try_install_clip_dependencies():
+                raise RuntimeError(
+                    "Required dependencies for ClipProcessor are not available.\n"
+                    "Auto-installation failed. 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 manually: pip install transformers onnxruntime-gpu pillow"
+                )
+
+            print("✓ Auto-installation successful, continuing with ClipProcessor initialization")
 
         self.color_category: List[str] = ["black", "white", "yellow", "gray", "red", "blue", "light blue",
         "green", "brown"]

{matrice_analytics-0.1.39.dist-info → matrice_analytics-0.1.41.dist-info}/METADATA

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

{matrice_analytics-0.1.39.dist-info → matrice_analytics-0.1.41.dist-info}/RECORD

@@ -87,7 +87,7 @@ matrice_analytics/post_processing/usecases/__init__.py,sha256=tsu51e2q2gbr5UcALe
 matrice_analytics/post_processing/usecases/abandoned_object_detection.py,sha256=zVrqlvgsjc5F2JHd-Zav6d-poVIpTJBpPKZ3CC71lQk,40332
 matrice_analytics/post_processing/usecases/advanced_customer_service.py,sha256=ELt5euxr6P4X2s8-YGngmj27QscOHefjOsx3774sNFk,75914
 matrice_analytics/post_processing/usecases/age_detection.py,sha256=yn1LXOgbnOWSMDnsCds6-uN6W-I1Hy4_-AMrjbT5PtY,41318
-matrice_analytics/post_processing/usecases/age_gender_detection.py,sha256=liWcwP4-rC97iVH2wzeDTdCPud-eZ5ZKg4odHLIrI4M,55131
+matrice_analytics/post_processing/usecases/age_gender_detection.py,sha256=ok8uCG8pHKqouTSOQyUANou29k6OOohxnhFsTwayOL0,52533
 matrice_analytics/post_processing/usecases/anti_spoofing_detection.py,sha256=XdtDdXGzZMLQdWcoOoiE5t4LPYHhgOtJ7tZCNlq1A2E,31329
 matrice_analytics/post_processing/usecases/assembly_line_detection.py,sha256=I_oeuec84KJnGMg_A8Wgs9U6h_IiopkDz9FbM1JG110,40410
 matrice_analytics/post_processing/usecases/banana_defect_detection.py,sha256=uKvB550Xve3iWfdWeOU3VhgORxD-M_UzsQDQKkYcFBc,30338
@@ -166,7 +166,7 @@ matrice_analytics/post_processing/usecases/weld_defect_detection.py,sha256=b0dAJ
 matrice_analytics/post_processing/usecases/wildlife_monitoring.py,sha256=TMVHJ5GLezmqG7DywmqbLggqNXgpsb63MD7IR6kvDkk,43446
 matrice_analytics/post_processing/usecases/windmill_maintenance.py,sha256=G1eqo3Z-HYmGJ6oeZYrpZwhpvqQ9Lc_T-6S7BLBXHeA,40498
 matrice_analytics/post_processing/usecases/wound_segmentation.py,sha256=ehNX6VuWMB3xAnCySO3ra3Tf_5FUNg5LCSdq_91h374,38342
-matrice_analytics/post_processing/usecases/color/clip.py,sha256=ZUqj0s0KFcU6kZ21hpiQWO3CRqn8s5EZ3IhWTskHbS8,21322
+matrice_analytics/post_processing/usecases/color/clip.py,sha256=qtG1YUngpt-5Emx4vdX1Hv_X9U6Sa4BMCNRDYpuM_4g,24828
 matrice_analytics/post_processing/usecases/color/color_map_utils.py,sha256=SP-AEVcjLmL8rxblu-ixqUJC2fqlcr7ab4hWo4Fcr_k,2677
 matrice_analytics/post_processing/usecases/color/color_mapper.py,sha256=nKPc28mJLlrl2HPua5EUUMweRRSI6WrrUBkeitTm7ms,17459
 matrice_analytics/post_processing/usecases/color/clip_processor/merges.txt,sha256=n9aR98gDkhDg_O0VhlRmxlgg0JtjmIsBdL_iXeKZBRo,524619
@@ -188,8 +188,8 @@ matrice_analytics/post_processing/utils/format_utils.py,sha256=UTF7A5h9j0_S12xH9
 matrice_analytics/post_processing/utils/geometry_utils.py,sha256=BWfdM6RsdJTTLR1GqkWfdwpjMEjTCJyuBxA4zVGKdfk,9623
 matrice_analytics/post_processing/utils/smoothing_utils.py,sha256=78U-yucAcjUiZ0NIAc9NOUSIT0PWP1cqyIPA_Fdrjp0,14699
 matrice_analytics/post_processing/utils/tracking_utils.py,sha256=rWxuotnJ3VLMHIBOud2KLcu4yZfDp7hVPWUtNAq_2xw,8288
-matrice_analytics-0.1.39.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_analytics-0.1.39.dist-info/METADATA,sha256=3btcsrjFcTzAkncEjVaPi4hUNRHDBFe34x4uJ6Mf1Kg,14378
-matrice_analytics-0.1.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_analytics-0.1.39.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
-matrice_analytics-0.1.39.dist-info/RECORD,,
+matrice_analytics-0.1.41.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_analytics-0.1.41.dist-info/METADATA,sha256=aGpFsA4ZZ5rNPFR2iqDy8JlA-gAhpAtjniELau5yH1I,14378
+matrice_analytics-0.1.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_analytics-0.1.41.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
+matrice_analytics-0.1.41.dist-info/RECORD,,