matrice-analytics 0.1.40__tar.gz → 0.1.42__tar.gz

{matrice_analytics-0.1.40 → matrice_analytics-0.1.42}/PKG-INFO

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

{matrice_analytics-0.1.40 → matrice_analytics-0.1.42}/matrice_analytics.egg-info/PKG-INFO

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

{matrice_analytics-0.1.40 → matrice_analytics-0.1.42}/src/matrice_analytics/post_processing/usecases/color/clip.py

@@ -56,28 +56,77 @@ def try_install_clip_dependencies():
     Only called when ClipProcessor is actually instantiated (lazy installation).
     Returns True if successful, False otherwise.
     """
-    global ort, Image, CLIPProcessor, ir_files, ir_as_file
-
     print("→ Color detection is being used but dependencies are missing")
     print("→ Attempting auto-installation of missing packages...")
 
+    import platform
+    import subprocess
+
+    # 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:
+            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
-    except ImportError:
-        packages_to_install.append("onnxruntime-gpu")
+        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:
-        packages_to_install.append("pillow")
+        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 as CLIP
+        print("→ transformers imported successfully")
     except ImportError:
-        packages_to_install.append("transformers")
+        if not is_package_installed("transformers"):
+            packages_to_install.append("transformers")
+        else:
+            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...")
@@ -103,30 +152,62 @@ def try_install_clip_dependencies():
             print(f"✗ Installation failed: {install_error}")
             return False
 
-    # Retry imports after installation
+    # 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:
-        print("→ Retrying imports after installation...")
         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
-        from transformers import CLIPProcessor as CLIPProc
-        from importlib.resources import files as ir_files_module, as_file as ir_as_file_module
+        print("  ✓ PIL imported")
+    except Exception as e:
+        import_errors.append(f"PIL: {e}")
+        print(f"  ✗ PIL import failed: {e}")
 
-        # Update global variables
-        ort = ort_module
-        Image = PILImage
-        CLIPProcessor = CLIPProc
-        ir_files = ir_files_module
-        ir_as_file = ir_as_file_module
+    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}")
 
-        print("✓ CLIP dependencies imported successfully after installation!")
-        return True
-    except ImportError as e:
-        print(f"✗ Import still failed after installation: {e}")
-        return False
+    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: {e}")
+        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
+
+    print("✓ CLIP dependencies imported successfully!")
+    return True
+
 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.
@@ -166,15 +247,26 @@ def load_model_from_checkpoint(checkpoint_url: str, providers: Optional[List] =
         # Resolve providers
         available = ort.get_available_providers()
         print("Available providers:", available)
-        use_providers = ["CUDAExecutionProvider"] #providers or
 
-        # Validate providers and enforce CUDA when requested
-        if any(
-            (isinstance(p, tuple) and p[0] == "CUDAExecutionProvider") or p == "CUDAExecutionProvider"
-            for p in use_providers
-        ):
-            if "CUDAExecutionProvider" not in available:
-                raise RuntimeError("CUDAExecutionProvider not available in this environment")
+        # Use provided providers or default to CUDA if available, else use first available
+        if providers is None:
+            if "CUDAExecutionProvider" in available:
+                use_providers = ["CUDAExecutionProvider"]
+            elif available:
+                use_providers = [available[0]]
+                print(f"CUDA not available, using: {use_providers[0]}")
+            else:
+                use_providers = ["CPUExecutionProvider"]
+                print("No providers detected, using CPUExecutionProvider")
+        else:
+            use_providers = providers
+
+        # Warn if requested provider is not available
+        for provider in use_providers:
+            provider_name = provider[0] if isinstance(provider, tuple) else provider
+            if provider_name not in available:
+                print(f"Warning: Requested provider '{provider_name}' not in available providers: {available}")
+                print(f"Will attempt to use it anyway, may fall back to available providers")
 
         # Load ONNX model from bytes with enforced providers
         model = ort.InferenceSession(
@@ -249,8 +341,14 @@ class ClipProcessor:
             if "CUDAExecutionProvider" in available:
                 self.providers = ["CUDAExecutionProvider"]
             else:
-                # Enforce GPU-only per requirement; raise if not available
-                print("CUDAExecutionProvider not available; ensure CUDA-enabled onnxruntime-gpu is installed and GPU is visible")
+                # CUDA not available, fall back to CPU or other available providers
+                print("CUDAExecutionProvider not available; falling back to available providers")
+                if available:
+                    self.providers = [available[0]]  # Use first available provider
+                    print(f"Using provider: {self.providers[0]}")
+                else:
+                    self.providers = ["CPUExecutionProvider"]  # Ultimate fallback
+                    print("No providers detected, using CPUExecutionProvider")
         else:
             self.providers = providers