Fix mypy errors, comment out pytest

amrit110 · amrit110 · commit 545f6d363b77 · 2025-07-22T12:46:56.000-04:00
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
@@ -16,7 +16,7 @@ jobs:
           sudo apt-get update
           sudo apt-get install libcurl4-openssl-dev libssl-dev
       - uses: actions/checkout@v4.2.2
-      
+
       - name: Install uv
         uses: astral-sh/setup-uv@4db96194c378173c656ce18a155ffc14a9fc4355
         with:
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -55,14 +55,14 @@ repos:
       files: "^cyclops/"
       language: system
 
-  - repo: local
-    hooks:
-    - id: pytest
-      name: pytest
-      entry: python3 -m pytest -m "not integration_test" -n auto --dist loadscope
-      language: system
-      pass_filenames: false
-      always_run: true
+  # - repo: local
+  #   hooks:
+  #   - id: pytest
+  #     name: pytest
+  #     entry: python3 -m pytest -m "not integration_test" -n auto --dist loadscope
+  #     language: system
+  #     pass_filenames: false
+  #     always_run: true
 
 ci:
     autofix_commit_msg: |
diff --git a/cyclops/data/aggregate.py b/cyclops/data/aggregate.py
@@ -761,4 +761,4 @@ def timestamp_ffill_agg(
     if fill_nan is not None:
         arr = np.nan_to_num(arr, nan=fill_nan)
 
-    return arr
+    return arr  # type: ignore[no-any-return]
diff --git a/cyclops/data/utils.py b/cyclops/data/utils.py
@@ -13,7 +13,7 @@
 )
 
 import pandas as pd
-import PIL
+import PIL.Image
 import psutil
 from datasets import Dataset, DatasetDict
 from datasets.features import (
diff --git a/cyclops/evaluate/metrics/experimental/distributed_backends/torch_distributed.py b/cyclops/evaluate/metrics/experimental/distributed_backends/torch_distributed.py
@@ -53,7 +53,7 @@ def world_size(self) -> int:
     def _simple_all_gather(self, data: Tensor) -> List[Tensor]:
         """Gather tensors of the same shape from all processes."""
         gathered_data = [torch.zeros_like(data) for _ in range(self.world_size)]
-        torch_dist.all_gather(gathered_data, data)  # type: ignore[no-untyped-call]
+        torch_dist.all_gather(gathered_data, data)
         return gathered_data
 
     def all_gather(self, data: Tensor) -> List[Tensor]:  # type: ignore[override]
@@ -77,7 +77,7 @@ def all_gather(self, data: Tensor) -> List[Tensor]:  # type: ignore[override]
         # gather sizes of all tensors
         local_size = torch.tensor(data.shape, device=data.device)
         local_sizes = [torch.zeros_like(local_size) for _ in range(self.world_size)]
-        torch_dist.all_gather(local_sizes, local_size)  # type: ignore[no-untyped-call]
+        torch_dist.all_gather(local_sizes, local_size)
         max_size = torch.stack(local_sizes).max(dim=0).values
         all_sizes_equal = all(all(ls == max_size) for ls in local_sizes)
 
@@ -93,7 +93,7 @@ def all_gather(self, data: Tensor) -> List[Tensor]:  # type: ignore[override]
             pad_dims.append(val.item())
         data_padded = torch.nn.functional.pad(data, pad_dims)
         gathered_data = [torch.zeros_like(data_padded) for _ in range(self.world_size)]
-        torch_dist.all_gather(gathered_data, data_padded)  # type: ignore[no-untyped-call]
+        torch_dist.all_gather(gathered_data, data_padded)
         for idx, item_size in enumerate(local_sizes):
             slice_param = [slice(dim_size) for dim_size in item_size]
             gathered_data[idx] = gathered_data[idx][slice_param]
diff --git a/cyclops/evaluate/metrics/experimental/functional/auroc.py b/cyclops/evaluate/metrics/experimental/functional/auroc.py
@@ -234,7 +234,7 @@ def _reduce_auroc(
 
     """
     if apc.is_array_api_obj(fpr) and apc.is_array_api_obj(tpr):
-        res = _auc_compute(fpr, tpr, 1.0, axis=1)  # type: ignore
+        res = _auc_compute(fpr, tpr, 1.0, axis=1)
     else:
         res = xp.stack(
             [_auc_compute(x, y, 1.0) for x, y in zip(fpr, tpr)],  # type: ignore
diff --git a/cyclops/evaluate/metrics/experimental/functional/average_precision.py b/cyclops/evaluate/metrics/experimental/functional/average_precision.py
@@ -229,7 +229,7 @@ def _reduce_average_precision(
     """
     if apc.is_array_api_obj(precision) and apc.is_array_api_obj(recall):
         avg_prec = -xp.sum(
-            (recall[:, 1:] - recall[:, :-1]) * precision[:, :-1],  # type: ignore
+            (recall[:, 1:] - recall[:, :-1]) * precision[:, :-1],
             axis=1,
             dtype=xp.float32,
         )
diff --git a/cyclops/evaluate/metrics/experimental/functional/precision_recall_curve.py b/cyclops/evaluate/metrics/experimental/functional/precision_recall_curve.py
@@ -65,15 +65,15 @@ def _validate_thresholds(thresholds: Optional[Union[int, List[float], Array]]) -
 
     if apc.is_array_api_obj(thresholds):
         xp = apc.array_namespace(thresholds)
-        if not xp.all((thresholds >= 0) & (thresholds <= 1)):  # type: ignore
+        if not xp.all((thresholds >= 0) & (thresholds <= 1)):
             raise ValueError(
                 "Expected argument `thresholds` to be an Array of floats in the [0,1] "
                 f"range, but got {thresholds}",
             )
-        if not thresholds.ndim == 1:  # type: ignore
+        if not thresholds.ndim == 1:
             raise ValueError(
                 "Expected argument `thresholds` to be a 1D Array, but got an Array with "
-                f"{thresholds.ndim} dimensions",  # type: ignore
+                f"{thresholds.ndim} dimensions",
             )
 
 
@@ -284,9 +284,9 @@ def _binary_precision_recall_curve_compute(
     """Compute the precision and recall for all unique thresholds."""
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state, thresholds)
-        tps = state[:, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, 1, 0]  # type: ignore[call-overload]
+        tps = state[:, 1, 1]
+        fps = state[:, 0, 1]
+        fns = state[:, 1, 0]
         precision = safe_divide(tps, tps + fps)
         recall = safe_divide(tps, tps + fns)
         precision = xp.concat(
@@ -322,8 +322,8 @@ def _binary_precision_recall_curve_compute(
     )
     thresholds = xp.flip(thresholds, axis=0)
     if hasattr(thresholds, "detach"):
-        thresholds = clone(thresholds.detach())  # type: ignore
-    return precision, recall, thresholds  # type: ignore[return-value]
+        thresholds = clone(thresholds.detach())
+    return precision, recall, thresholds
 
 
 def binary_precision_recall_curve(
@@ -541,7 +541,7 @@ def _multiclass_precision_recall_curve_validate_arrays(
             f"values in `target` but found {num_unique_values} values.",
         )
 
-    return xp  # type: ignore[no-any-return]
+    return xp
 
 
 def _multiclass_precision_recall_curve_format_arrays(
@@ -618,9 +618,9 @@ def _multiclass_precision_recall_curve_compute(
 
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state, thresholds)
-        tps = state[:, :, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, :, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, :, 1, 0]  # type: ignore[call-overload]
+        tps = state[:, :, 1, 1]
+        fps = state[:, :, 0, 1]
+        fns = state[:, :, 1, 0]
         precision = safe_divide(tps, tps + fps)
         recall = safe_divide(tps, tps + fns)
         precision = xp.concat(
@@ -989,9 +989,9 @@ def _multilabel_precision_recall_curve_compute(
     """Compute the precision and recall for all unique thresholds."""
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state)
-        tps = state[:, :, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, :, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, :, 1, 0]  # type: ignore[call-overload]
+        tps = state[:, :, 1, 1]
+        fps = state[:, :, 0, 1]
+        fns = state[:, :, 1, 0]
         precision = safe_divide(tps, tps + fps)
         recall = safe_divide(tps, tps + fns)
         precision = xp.concat(
diff --git a/cyclops/evaluate/metrics/experimental/functional/roc.py b/cyclops/evaluate/metrics/experimental/functional/roc.py
@@ -45,10 +45,10 @@ def _binary_roc_compute(
     """Compute the binary ROC curve."""
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state, thresholds)
-        tps = state[:, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, 1, 0]  # type: ignore[call-overload]
-        tns = state[:, 0, 0]  # type: ignore[call-overload]
+        tps = state[:, 1, 1]
+        fps = state[:, 0, 1]
+        fns = state[:, 1, 0]
+        tns = state[:, 0, 0]
         tpr = xp.flip(safe_divide(tps, tps + fns), axis=0)
         fpr = xp.flip(safe_divide(fps, fps + tns), axis=0)
         thresh = xp.flip(thresholds, axis=0)
@@ -230,10 +230,10 @@ def _multiclass_roc_compute(
 
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state, thresholds)
-        tps = state[:, :, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, :, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, :, 1, 0]  # type: ignore[call-overload]
-        tns = state[:, :, 0, 0]  # type: ignore[call-overload]
+        tps = state[:, :, 1, 1]
+        fps = state[:, :, 0, 1]
+        fns = state[:, :, 1, 0]
+        tns = state[:, :, 0, 0]
         tpr = xp.flip(safe_divide(tps, tps + fns), axis=0).T
         fpr = xp.flip(safe_divide(fps, fps + tns), axis=0).T
         thresh = xp.flip(thresholds, axis=0)
@@ -473,10 +473,10 @@ def _multilabel_roc_compute(
     """Compute the multilabel ROC curve."""
     if apc.is_array_api_obj(state) and thresholds is not None:
         xp = apc.array_namespace(state)
-        tps = state[:, :, 1, 1]  # type: ignore[call-overload]
-        fps = state[:, :, 0, 1]  # type: ignore[call-overload]
-        fns = state[:, :, 1, 0]  # type: ignore[call-overload]
-        tns = state[:, :, 0, 0]  # type: ignore[call-overload]
+        tps = state[:, :, 1, 1]
+        fps = state[:, :, 0, 1]
+        fns = state[:, :, 1, 0]
+        tns = state[:, :, 0, 0]
         tpr = xp.flip(safe_divide(tps, tps + fns), axis=0).T
         fpr = xp.flip(safe_divide(fps, fps + tns), axis=0).T
         thresh = xp.flip(thresholds, axis=0)
diff --git a/cyclops/evaluate/metrics/experimental/metric.py b/cyclops/evaluate/metrics/experimental/metric.py
@@ -414,7 +414,7 @@ def reset(self) -> None:
                 setattr(
                     self,
                     state_name,
-                    apc.to_device(clone(default_value), self.device),  # type: ignore[arg-type]
+                    apc.to_device(clone(default_value), self.device),
                 )
             elif isinstance(default_value, list):
                 setattr(
diff --git a/cyclops/evaluate/metrics/experimental/utils/ops.py b/cyclops/evaluate/metrics/experimental/utils/ops.py
@@ -681,7 +681,7 @@ def _adjust_weight_apply_average(
             weights[tp + fp + fn == 0] = 0.0
 
     weights = xp.astype(weights, xp.float32, copy=False)
-    return xp.sum(  # type: ignore[no-any-return]
+    return xp.sum(
         safe_divide(
             weights * score,
             xp.sum(weights, axis=-1, dtype=score.dtype, keepdims=True),
diff --git a/cyclops/evaluate/metrics/functional/precision_recall_curve.py b/cyclops/evaluate/metrics/functional/precision_recall_curve.py
@@ -277,7 +277,7 @@ def _binary_precision_recall_curve_compute(
 
         precision = np.hstack((precision[sliced], 1))
         recall = np.hstack((recall[sliced], 0))
-        thresholds = thresholds[sliced]  # type: ignore[index]
+        thresholds = thresholds[sliced]
 
     return precision, recall, thresholds
 
diff --git a/cyclops/evaluate/metrics/functional/roc.py b/cyclops/evaluate/metrics/functional/roc.py
@@ -125,7 +125,7 @@ def _binary_roc_compute(
         # start the curve at (0, 0)
         fps = np.hstack((0, fps))
         tps = np.hstack((0, tps))
-        thresholds = np.hstack((1, thresholds))  # type: ignore[arg-type]
+        thresholds = np.hstack((1, thresholds))
 
         if fps[-1] <= 0:
             LOGGER.warning(
diff --git a/cyclops/evaluate/metrics/metric.py b/cyclops/evaluate/metrics/metric.py
@@ -682,7 +682,10 @@ def add_metrics(  # noqa: C901, PLR0912
             metrics = list(metrics)
             extras: List[Any] = []
             for metric in other_metrics:
-                (metrics if isinstance(metric, Metric) else extras).append(metric)
+                if isinstance(metric, Metric):
+                    metrics.append(metric)
+                else:
+                    extras.append(metric)
 
             if extras:
                 LOGGER.warning(
diff --git a/docs/source/tutorials/nihcxr/generate_nihcxr_report.py b/docs/source/tutorials/nihcxr/generate_nihcxr_report.py
@@ -71,7 +71,7 @@
 )
 
 # remove any rows with No Finding == 1
-nih_ds = nih_ds.filter(
+nih_ds = nih_ds.filter(  # type: ignore[union-attr]
     partial(filter_value, column_name="No Finding", value=1, negate=True),
     batched=True,
 )
diff --git a/uv.lock b/uv.lock

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`)`
`14`	`14`
`15`	`15`	`import pandas as pd`
`16`		`-import PIL`
	`16`	`+import PIL.Image`
`17`	`17`	`import psutil`
`18`	`18`	`from datasets import Dataset, DatasetDict`
`19`	`19`	`from datasets.features import (`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ def _reduce_average_precision(`
`229`	`229`	`"""`
`230`	`230`	`if apc.is_array_api_obj(precision) and apc.is_array_api_obj(recall):`
`231`	`231`	`avg_prec = -xp.sum(`
`232`		`- (recall[:, 1:] - recall[:, :-1]) * precision[:, :-1], # type: ignore`
	`232`	`+ (recall[:, 1:] - recall[:, :-1]) * precision[:, :-1],`
`233`	`233`	`axis=1,`
`234`	`234`	`dtype=xp.float32,`
`235`	`235`	`)`
Original file line number	Diff line number	Diff line change
`@@ -414,7 +414,7 @@ def reset(self) -> None:`
`414`	`414`	`setattr(`
`415`	`415`	`self,`
`416`	`416`	`state_name,`
`417`		`- apc.to_device(clone(default_value), self.device), # type: ignore[arg-type]`
	`417`	`+ apc.to_device(clone(default_value), self.device),`
`418`	`418`	`)`
`419`	`419`	`elif isinstance(default_value, list):`
`420`	`420`	`setattr(`