Add the pyright type gate and the unit coverage that goes with it

.github/workflows/ci.yaml

@@ -16,15 +16,15 @@ on:
         type: string
         default: ""
       ml_ref:
-        description: "luxonis-ml version (branch/tag/SHA)"
+        description: "luxonis-ml version (branch/tag/SHA). Empty keeps the pinned release. The unit and type-check jobs then use `main`, but not on a release branch."
         required: false
         type: string
-        default: main
+        default: ""
       modelconv_ref:
-        description: "modelconverter version (branch/tag/SHA)"
+        description: "modelconverter version (branch/tag/SHA). Empty tests the branch the run starts from."
         required: false
         type: string
-        default: main
+        default: ""
   workflow_call:
     inputs:
       platforms:
@@ -38,10 +38,10 @@ on:
         type: string
         default: ""
       ml_ref:
-        description: "luxonis-ml version (branch/tag/SHA)"
+        description: "luxonis-ml version (branch/tag/SHA). Empty keeps the pinned release. The unit and type-check jobs then use `main`, but not on a release branch."
         required: false
         type: string
-        default: main
+        default: ""
       modelconv_ref:
         description: "modelconverter version (branch/tag/SHA)"
         required: false
@@ -75,8 +75,63 @@ env:
   LUXONIS_TELEMETRY_ENABLED: "false"
 
 jobs:
+  typecheck:
+    name: Type check
+    runs-on: ubuntu-latest
+    env:
+      GS_BUILD_ARTIFACTS: gs://luxonis-test-bucket/modelconverter/build-artifacts
+      HAILO_WHEEL: hailo_dataflow_compiler-5.3.0-py3-none-linux_x86_64.whl
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          repository: ${{ inputs.modelconv_ref && 'Luxonis/modelconverter' || github.repository }}
+          ref: ${{ inputs.modelconv_ref || github.head_ref || github.ref }}
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97
+        with:
+          python-version: "3.10"
+          cache: pip
+
+      - name: Install package
+        run: pip install -e .[dev]
+
+      - name: Install LuxonisML from main
+        if: ${{ inputs.ml_ref || !startsWith(inputs.modelconv_ref || github.head_ref || github.ref_name, 'release/') }}
+        env:
+          ML_REF: ${{ inputs.ml_ref || 'main' }}
+        run: |
+          pip uninstall luxonis-ml -y
+          pip install \
+            "luxonis-ml[data,nn_archive,s3,gcs,telemetry] @ git+https://github.com/luxonis/luxonis-ml.git@${ML_REF}" \
+            --upgrade --force-reinstall
+
+      - name: Authenticate to Google Cloud
+        uses: google-github-actions/auth@7c6bc770dae815cd3e89ee6cdf493a5fab2cc093
+        with:
+          credentials_json: ${{ secrets.GCP_CREDENTIALS }}
+          token_format: access_token
+
+      - name: Install platform dependencies
+        run: |
+          gcloud storage cp "${GS_BUILD_ARTIFACTS}/${HAILO_WHEEL}" .
+          pip install --no-deps \
+            -r requirements-typecheck.txt \
+            "./${HAILO_WHEEL}"
+
+      - name: Run pyright
+        uses: jakebailey/pyright-action@8ec14b5cfe41f26e5f41686a31eb6012758217ef
+        with:
+          # `version: PATH` runs the pyright that `.[dev]` pins, so CI and a
+          # local run agree.
+          version: PATH
+          warnings: true
+
   unit:
     name: Unit tests
+    needs: [typecheck]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -95,14 +150,14 @@ jobs:
       - name: Install package
         run: pip install -e .[dev]
 
-      - name: Install specified LuxonisML
-        if: ${{ inputs.ml_ref != '' }}
+      - name: Install LuxonisML from main
+        if: ${{ inputs.ml_ref || !startsWith(inputs.modelconv_ref || github.head_ref || github.ref_name, 'release/') }}
         env:
-          ML_REF: ${{ inputs.ml_ref }}
+          ML_REF: ${{ inputs.ml_ref || 'main' }}
         run: |
           pip uninstall luxonis-ml -y
           pip install \
-            "luxonis-ml[data,nn-archive] @ git+https://github.com/luxonis/luxonis-ml.git@${ML_REF}" \
+            "luxonis-ml[data,nn_archive,s3,gcs,telemetry] @ git+https://github.com/luxonis/luxonis-ml.git@${ML_REF}" \
             --upgrade --force-reinstall
 
       - name: Run unit tests

modelconverter/__main__.py

@@ -34,6 +34,7 @@
     get_inferer,
     get_visualizer,
 )
+from modelconverter.platforms.base_benchmark import Configuration
 from modelconverter.platforms.multistage_exporter import MultiStageExporter
 from modelconverter.utils import (
     ModelconverterException,
@@ -559,7 +560,7 @@ def benchmark(
         Whether to monitor the device performance during benchmarking and include it in the results. Only relevant for RVC4 platform.
     """
     if platform in {Platform.RVC2, Platform.RVC4}:
-        kwargs = {
+        kwargs: Configuration = {
             "repetitions": repetitions,
             "benchmark_time": benchmark_time,
             "num_threads": num_threads,

modelconverter/platforms/rvc2/exporter.py

@@ -256,7 +256,7 @@ def export(self) -> Path:
         if "-iop" not in args:
             self._add_args(args, ["-ip", "U8"])
 
-        args += ["-m", xml_path]
+        args += ["-m", str(xml_path)]
 
         if self._superblob:
             return self._compile_superblob(args)
@@ -348,7 +348,7 @@ def _superblob_compile_step(shaves: int) -> None:
                 blobs_directory
                 / f"{self._model_name}_{DEFAULT_SUPER_SHAVES}shave.blob"
             )
-            args += ["-o", blob_path]
+            args += ["-o", str(blob_path)]
 
             logger.info(f"Compiling {shaves}-shave patch...")
             with SubprocessHandle(

modelconverter/platforms/rvc3/exporter.py

@@ -3,6 +3,7 @@
 
 import cv2
 from loguru import logger
+from luxonis_ml.typing import Params
 
 from modelconverter.platforms.base_exporter import Exporter
 from modelconverter.platforms.rvc2.exporter import RVC2Exporter
@@ -65,17 +66,17 @@ def export(self) -> Path:
                 self.output_dir
                 / f"{self._model_name}-{self.platform.name.lower()}-int8"
             )
-            args += ["-m", calibrated_xml_path]
+            args += ["-m", str(calibrated_xml_path)]
         else:
             output_path = (
                 self.output_dir
                 / f"{self._model_name}-{self.platform.name.lower()}"
             )
-            args += ["-m", xml_path]
+            args += ["-m", str(xml_path)]
 
         if "-o" not in args:
             blob_output_path = output_path.with_suffix(".blob")
-            args += ["-o", blob_output_path]
+            args += ["-o", str(blob_output_path)]
         else:  # pragma: no cover
             blob_output_path = Path(args[args.index("-o") + 1])
 
@@ -112,6 +113,16 @@ def _calibrate(self, xml_path: Path) -> Path:
                 str((calibration_img_dir / file.stem).with_suffix(suffix)), img
             )
 
+        dataset: Params = {
+            "name": "calibration",
+            "data_source": str(calibration_img_dir),
+            "reader": "opencv_imread",
+        }
+        if inp.encoding.to == Encoding.GRAY:
+            dataset["preprocessing"] = [{"type": "bgr_to_gray"}]
+        elif not self._reverse_input_channels:
+            dataset["preprocessing"] = [{"type": "bgr_to_rgb"}]
+
         config = {
             "model": {
                 "model_name": f"{xml_path.stem}-int8",
@@ -125,13 +136,7 @@ def _calibrate(self, xml_path: Path) -> Path:
                         "device": "CPU",
                     }
                 ],
-                "datasets": [
-                    {
-                        "name": "calibration",
-                        "data_source": str(calibration_img_dir),
-                        "reader": "opencv_imread",
-                    }
-                ],
+                "datasets": [dataset],
             },
             "compression": {
                 "target_device": self._pot_target_device.name,
@@ -147,15 +152,6 @@ def _calibrate(self, xml_path: Path) -> Path:
             },
         }
 
-        if inp.encoding.to == Encoding.GRAY:
-            config["engine"]["datasets"][0]["preprocessing"] = [
-                {"type": "bgr_to_gray"}
-            ]
-        elif not self._reverse_input_channels:
-            config["engine"]["datasets"][0]["preprocessing"] = [
-                {"type": "bgr_to_rgb"}
-            ]
-
         pot_config_path = self.intermediate_outputs_dir / "pot_config.json"
 
         with open(pot_config_path, "w") as f:

modelconverter/platforms/rvc4/analyze.py

@@ -185,7 +185,7 @@ def _check_dir_sizes(self) -> None:
                 "Input dirs must contain at least one supported image or .npy file."
             )
 
-    def _prepare_input_matcher(self) -> dict[str, dict[str, str]]:
+    def _prepare_input_matcher(self) -> dict[int, dict[str, str]]:
         image_names = self._get_selected_image_paths()
 
         input_matcher = {}
@@ -198,13 +198,13 @@ def _prepare_input_matcher(self) -> dict[str, dict[str, str]]:
 
     def _prepare_raw_inputs(
         self,
-        input_matcher: dict[str, dict[str, str]],
-        type: type = np.uint8,
+        input_matcher: dict[int, dict[str, str]],
+        dtype: type[np.generic] = np.uint8,
         *,
         verbose: bool = True,
         reset_workspace: bool = True,
         stable_input_names: bool = False,
-    ) -> dict[str, str]:
+    ) -> dict[int, str]:
         if verbose:
             logger.info("Preparing raw inputs for RVC4 analysis.")
         if reset_workspace:
@@ -231,15 +231,15 @@ def _prepare_raw_inputs(
                         raise TypeError(
                             f"Input `{img_name}` is not a single array."
                         )
-                    raw_image = loaded.astype(type)
+                    raw_image = loaded.astype(dtype)
 
                     if raw_image.shape != tuple(width_height):
                         raise ValueError(
                             f"Input image {img_name} has incorrect shape: {raw_image.shape}, expected: {tuple(width_height)}"
                         )
                 else:
                     image = self._resize_image(img_path, width_height)
-                    raw_image = image.astype(type)
+                    raw_image = image.astype(dtype)
 
                 raw_file_name = (
                     f"{input_name}.raw"
@@ -395,8 +395,8 @@ def _collect_comparison_statistics(
         output_names: list[str],
         layer_names: list[str],
         onnx_input_shapes: dict[str, list[int | str | None]],
-        input_matcher: dict[str, dict[str, str]],
-        dlc_matcher: dict[str, Path],
+        input_matcher: dict[int, dict[str, str]],
+        dlc_matcher: dict[int, Path],
         *,
         verbose: bool = True,
     ) -> list[list]:
@@ -570,7 +570,7 @@ def _run_dlc(
         return str(pulled_output_dir)
 
     def _flatten_dlc_outputs(
-        self, dlc_matcher: dict[str, Path], *, verbose: bool = True
+        self, dlc_matcher: dict[int, Path], *, verbose: bool = True
     ) -> None:
         if verbose:
             logger.info("Flattening SNPE results.")

modelconverter/platforms/rvc4/visualize.py

@@ -222,7 +222,7 @@ def _visualize_layer_outputs(self) -> go.Figure:
 
     def _get_csv_paths(
         self, dir_path: Path, comparison_type: str = "layer_comparison"
-    ) -> dict[str, str]:
+    ) -> dict[str, Path]:
         dir_path = dir_path or constants.OUTPUTS_DIR / "analysis"
         csv_paths = {}
 

modelconverter/utils/device_monitors.py

@@ -234,7 +234,7 @@ def _read_cpu(self) -> dict[str, float | None]:
             "cpu_utilization": self._read_cpu_utilization(),
         }
 
-    def _read_dsp(self) -> dict[str, float]:
+    def _read_dsp(self) -> dict[str, float | None]:
 
         def parse_freq_file(
             text: str,