Remove non used code

Author: jrrodri

abraia/hailo/camera_utils.py

@@ -1,21 +1,15 @@
-from __future__ import annotations
 import os
-import signal
-import subprocess
-import time
-import platform
-import cv2
 import sys
+import cv2
+import threading
 from enum import Enum
 from typing import Any, Optional
-import subprocess
-from .defines import UDEV_CMD, CAMERA_RESOLUTION_MAP
+
+from .defines import CAMERA_RESOLUTION_MAP
 from .hailo_logger import get_logger
 
 hailo_logger = get_logger(__name__)
 
-# if udevadm is not installed, install it using the following command:
-# sudo apt-get install udev
 
 class PiCamera2CaptureAdapter:
     """
@@ -224,89 +218,8 @@ def _apply_resolution_and_validate(
 
 
 def open_usb_camera(input_src: str, resolution: Optional[str]):
-    """
-    USB camera open .
-
-    Supported values:
-    - "usb"         : Auto-select the first available USB camera
-    - "/dev/videoX" : Explicit Linux camera device
-    - "0"/"1"/...   : Explicit Windows camera index
-
-    The function:
-    - opens the requested source
-    - applies optional resolution
-    - vali
-    """
-    system_name = platform.system()
-
-    # ---------------------------------------------------------
-    # 1) Explicit Linux device path: /dev/videoX
-    # ---------------------------------------------------------
-    if str(input_src).startswith("/dev/video"):
-        if system_name == "Windows":
-            hailo_logger.error(
-                "On Windows, '/dev/videoX' is not supported. Use '-i 0' or '-i usb'."
-            )
-            sys.exit(1)
-
-        try:
-            cap = open_cv_capture(str(input_src), "USB camera index")
-        except SystemExit:
-            available_cameras = get_usb_video_devices()
-            if available_cameras:
-                hailo_logger.error(f"Available camera indices detected: {available_cameras}")
-            else:
-                hailo_logger.error("No cameras detected on Linux.")
-            raise
-
-        return _apply_resolution_and_validate(cap, resolution)
-
-    # ---------------------------------------------------------
-    # 2) Explicit Windows numeric index: 0/1/2...
-    # ---------------------------------------------------------
-    if str(input_src).isdigit():
-        if system_name == "Linux":
-            hailo_logger.error(
-                "On Linux, numeric camera index is not supported. "
-                "Use '-i /dev/videoX' or '-i usb'."
-            )
-            sys.exit(1)
-
-        camera_index = int(str(input_src))
-        try:
-            cap = open_cv_capture(camera_index, "USB camera index")
-        except SystemExit:
-            available_cameras = get_usb_video_devices()
-            if available_cameras:
-                hailo_logger.error(f"Available camera indices detected: {available_cameras}")
-            else:
-                hailo_logger.error("No cameras detected on Windows.")
-            raise
-
-        return _apply_resolution_and_validate(cap, resolution)
-
-
-    # ---------------------------------------------------------
-    # 3) Auto USB selection: "usb"
-    # ---------------------------------------------------------
-    if input_src != "usb":
-        hailo_logger.error(f"open_usb_camera received invalid camera input: '{input_src}'")
-        sys.exit(1)
-
-    available_cameras = get_usb_video_devices()
-    if not available_cameras:
-        hailo_logger.error(f"USB mode requested, but no cameras detected on {system_name}.")
-        sys.exit(1)
-
-    selected_camera = available_cameras[0]
-
-    try:
-        source_label = "USB camera index" if system_name == "Windows" else "USB camera device"
-        cap = open_cv_capture(selected_camera, source_label)
-    except SystemExit:
-        hailo_logger.error(f"Failed to open auto-selected USB camera: {selected_camera}")
-        raise
-
+    camera_index = int(str(input_src))
+    cap = open_cv_capture(camera_index, "USB camera index")
     return _apply_resolution_and_validate(cap, resolution)
 
 
@@ -361,143 +274,3 @@ def is_stream_url(src: str) -> bool:
         or src_lower.startswith("http://")
         or src_lower.startswith("https://")
     )
-
-
-# Checks if a Raspberry Pi camera is connected and responsive.
-def is_rpi_camera_available():
-    """Returns True if the RPi camera is connected."""
-    hailo_logger.debug("Checking if Raspberry Pi camera is available...")
-    try:
-        process = subprocess.Popen(
-            ["rpicam-hello", "-t", "0"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        hailo_logger.debug("Started rpicam-hello process.")
-        time.sleep(5)
-        process.send_signal(signal.SIGTERM)
-        hailo_logger.debug("Sent SIGTERM to rpicam-hello process.")
-        process.wait(timeout=2)
-        stdout, stderr = process.communicate()
-        stderr_str = stderr.decode().lower()
-        hailo_logger.debug(f"rpicam-hello stderr: {stderr_str}")
-        if "no cameras available" in stderr_str:
-            hailo_logger.info("No Raspberry Pi cameras detected.")
-            return False
-        hailo_logger.info("Raspberry Pi camera is available.")
-        return True
-    except Exception as e:
-        hailo_logger.error(f"Error checking Raspberry Pi camera: {e}")
-        return False
-
-
-def get_usb_video_devices():
-    """
-    Return a list of available USB video devices for the current platform.
-
-    Returns:
-        list[str | int]:
-            - On Linux: list of device paths such as ['/dev/video0', '/dev/video2']
-            - On Windows: list of OpenCV-compatible camera indices such as [0, 1]
-
-    Notes:
-        - Linux detection is based on `udevadm` and filters devices that:
-          1. are connected via USB
-          2. expose capture capability
-        - Windows detection relies on DirectShow device enumeration via `pygrabber`.
-          The returned indices follow the enumeration order and are intended for use
-          with OpenCV / DirectShow.
-    """
-    system = platform.system()
-    hailo_logger.debug(f"Detecting USB video devices on {system}...")
-
-    if system == "Linux":
-        return _get_usb_video_devices_linux()
-
-    if system == "Windows":
-        return _get_usb_video_devices_windows()
-
-    hailo_logger.warning(f"Unsupported platform: {system}")
-    return []
-
-# Checks if a USB camera is connected and responsive.
-def _get_usb_video_devices_linux():
-    """Detect USB video capture devices on Linux."""
-    hailo_logger.debug("Scanning /dev for video devices...")
-    video_devices = [
-        f"/dev/{device}" for device in os.listdir("/dev") if device.startswith("video")
-    ]
-    usb_video_devices = []
-    hailo_logger.debug(f"Found video devices: {video_devices}")
-
-    for device in video_devices:
-        try:
-            hailo_logger.debug(f"Checking device: {device}")
-            # Use udevadm to get detailed information about the device
-            udevadm_cmd = [UDEV_CMD, "info", "--query=all", "--name=" + device]
-            hailo_logger.debug(f"Running command: {' '.join(udevadm_cmd)}")
-            result = subprocess.run(udevadm_cmd, check=False, capture_output=True)
-            output = result.stdout.decode("utf-8")
-            hailo_logger.debug(f"udevadm output for {device}: {output}")
-
-            # Check if the device is connected via USB and has video capture capabilities
-            if "ID_BUS=usb" in output and ":capture:" in output:
-                hailo_logger.info(f"USB camera detected: {device}")
-                usb_video_devices.append(device)
-        except Exception as e:
-            hailo_logger.error(f"Error checking device {device}: {e}")
-
-    hailo_logger.debug(f"USB video devices found on Linux: {usb_video_devices}")
-    return usb_video_devices
-
-def _get_usb_video_devices_windows():
-    """
-    Detect USB video devices on Windows using DirectShow enumeration.
-
-    Returns:
-        list[int]: Camera indices compatible with OpenCV / DirectShow.
-    """
-    usb_video_devices = []
-
-    try:
-        from pygrabber.dshow_graph import FilterGraph
-    except ImportError as e:
-        msg = (
-            "Missing dependency 'pygrabber'.\n"
-            "Install it using:\n"
-            "    pip install pygrabber\n"
-            "Note: This dependency is required for Windows camera support."
-        )
-        hailo_logger.error(msg)
-        raise ImportError(msg) from e
-
-    try:
-        hailo_logger.debug("Enumerating DirectShow input devices...")
-        graph = FilterGraph()
-        devices = graph.get_input_devices()
-        hailo_logger.debug(f"Found DirectShow devices: {devices}")
-
-        for index, name in enumerate(devices):
-            hailo_logger.info(f"USB camera detected: index={index}, name='{name}'")
-            usb_video_devices.append(index)
-
-    except Exception as e:
-        hailo_logger.error(f"Failed to enumerate Windows video devices: {e}")
-        return []
-
-    hailo_logger.debug(f"USB video devices found on Windows: {usb_video_devices}")
-    return usb_video_devices
-
-
-def main():
-    hailo_logger.debug("Running main() to check for USB cameras.")
-    usb_video_devices = get_usb_video_devices()
-
-    if usb_video_devices:
-        hailo_logger.info(f"USB cameras found on: {', '.join(usb_video_devices)}")
-        print(f"USB cameras found on: {', '.join(usb_video_devices)}")
-    else:
-        hailo_logger.info("No available USB cameras found.")
-        print("No available USB cameras found.")
-
-
-if __name__ == "__main__":
-    main()

abraia/hailo/core.py

@@ -20,7 +20,6 @@
     RESOURCES_VIDEOS_DIR_NAME,
     CAMERA_RESOLUTION_MAP,
     RESOURCE_TYPE_IMAGE,
-    RESOURCE_TYPE_ONNX,
     RESOURCE_TYPE_VIDEO,
     RESOURCE_TYPE_MODEL,
     CAMERA_KEYWORDS,

abraia/hailo/defines.py

@@ -99,9 +99,6 @@ def _get_local_resources_path() -> str:
 # Supported config options (used for validation in config_utils.py)
 VALID_HAILORT_VERSION = [AUTO_DETECT, "4.23.0", "5.1.1", "5.2.0", "5.3.0"]
 VALID_TAPPAS_VERSION = [AUTO_DETECT, "5.1.0", "5.2.0", "5.3.0"]
-VALID_H10_MODEL_ZOO_VERSION = ["v5.1.0", "v5.2.0", "v5.3.0"]  # First element is default
-VALID_H8_MODEL_ZOO_VERSION = ["v2.17.0"]
-VALID_MODEL_ZOO_VERSION = VALID_H10_MODEL_ZOO_VERSION + VALID_H8_MODEL_ZOO_VERSION
 VALID_HOST_ARCH = [AUTO_DETECT, "x86", "rpi", "arm"]
 VALID_HAILO_ARCH = [AUTO_DETECT, HAILO8_ARCH, HAILO8L_ARCH, HAILO10H_ARCH]
 
@@ -239,10 +236,6 @@ def _get_local_resources_path() -> str:
 TEST_RUN_TIME = 10  # seconds
 TERM_TIMEOUT = 5  # seconds
 
-# USB device discovery
-UDEV_CMD = "udevadm"
-
-
 # Queue and async inference defaults
 MAX_INPUT_QUEUE_SIZE = 60
 MAX_OUTPUT_QUEUE_SIZE = 60
@@ -266,13 +259,11 @@ def _get_local_resources_path() -> str:
 RESOURCE_TYPE_MODEL = "model"
 RESOURCE_TYPE_IMAGE = "image"
 RESOURCE_TYPE_VIDEO = "video"
-RESOURCE_TYPE_ONNX = "onnx"
 
 RESOURCE_TYPES = {
     RESOURCE_TYPE_MODEL,
     RESOURCE_TYPE_IMAGE,
     RESOURCE_TYPE_VIDEO,
-    RESOURCE_TYPE_ONNX,
 }
 
 CAMERA_KEYWORDS = ["usb", "rpi"]