fix ci & pyproject deps

Author: trylinka

.github/workflows/ci.yml

@@ -71,7 +71,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        python-version: ['3.9']
     steps:
     - name: Checkout
       uses: actions/checkout@v4

albucore/utils.py

@@ -247,11 +247,11 @@ def is_grayscale_image(image: np.ndarray, has_batch_dim: bool = False, has_depth
 def get_opencv_dtype_from_numpy(value: np.ndarray | int | np.dtype | object) -> int:
     if isinstance(value, np.ndarray):
         value = value.dtype
-    return NPDTYPE_TO_OPENCV_DTYPE[value]
+    return int(NPDTYPE_TO_OPENCV_DTYPE[value])
 
 
 def is_rgb_image(image: np.ndarray) -> bool:
-    return get_num_channels(image) == NUM_RGB_CHANNELS
+    return bool(get_num_channels(image) == NUM_RGB_CHANNELS)
 
 
 def is_multispectral_image(image: np.ndarray) -> bool:
@@ -278,7 +278,7 @@ def convert_value(value: np.ndarray | float, num_channels: int) -> float | np.nd
         return float(value) if isinstance(value, (float, int)) else value.item()
 
     # Handle numpy arrays
-    if isinstance(value, np.ndarray):
+    if isinstance(value, np.ndarray):  # type: ignore[unreachable]
         # Return scalars and 0-dim arrays as float
         if value.ndim == 0:
             return value.item()

benchmark/albucore_benchmark/benchmark.py

@@ -84,6 +84,17 @@ def get_package_versions() -> dict[str, str]:
 
 
 class BenchmarkTest(ABC):
+    # Direct mapping of library names to their transform method names
+    LIBRARY_ATTR_MAP: dict[str, str] = {
+        "albucore": "albucore_transform",
+        "opencv": "opencv_transform",
+        "numpy": "numpy_transform",
+        "lut": "lut_transform",
+        "kornia-rs": "kornia_transform",
+        "torchvision": "torchvision_transform",
+        "simsimd": "simsimd_transform",
+    }
+
     def __init__(self, num_channels: int) -> None:
         self.num_channels = num_channels
         self.img_type = None
@@ -131,30 +142,17 @@ def simsimd(self, img: np.ndarray) -> np.ndarray:
         return clip(self.simsimd_transform(img), img.dtype)
 
     def is_supported_by(self, library: str) -> bool:
-        library_attr_map = {
-            "albucore": "albucore_transform",
-            "opencv": "opencv_transform",
-            "numpy": "numpy_transform",
-            "lut": "lut_transform",
-            "kornia-rs": "kornia_transform",
-            "torchvision": "torchvision_transform",
-            "simsimd": "simsimd_transform",
-        }
-
-        # Check if the library is in the map
-        if library in library_attr_map:
-            attrs = library_attr_map[library]
-            # Ensure attrs is a list for uniform processing
-            if not isinstance(attrs, list):
-                attrs = [attrs]  # type: ignore[assignment]
-            # Return True if any of the specified attributes exist
-            return any(hasattr(self, attr) for attr in attrs)
-
-        # Fallback: checks if the class has an attribute with the library's name
-        return hasattr(self, library)
+        # Check if the library has a specific mapping
+        transform_attr = self.LIBRARY_ATTR_MAP.get(library, f"{library}_transform")
+
+        # Return True if the transform method exists
+        return hasattr(self, transform_attr)
 
     def run(self, library: str, imgs: list[np.ndarray]) -> list[np.ndarray] | None:
-        transform = getattr(self, library)
+        # Get the appropriate transform method
+        transform_attr = self.LIBRARY_ATTR_MAP.get(library, f"{library}_transform")
+        transform = getattr(self, transform_attr)
+
         transformed_images = []
         for img in imgs:
             result = transform(img)

benchmark/utils.py

@@ -33,7 +33,7 @@ def _highlight_best_result(self, results: list[float | str]) -> list[str]:
             elif isinstance(result, (int, float)):
                 parsed_results.append((float(result), 0))
             else:
-                parsed_results.append((np.nan, np.nan))
+                parsed_results.append((np.nan, np.nan))  # type: ignore[unreachable]
 
         if not parsed_results or all(np.isnan(mean) for mean, _ in parsed_results):
             return [str(r) for r in results]
@@ -71,21 +71,40 @@ def _make_value_matrix(self) -> list[list[str]]:
         return value_matrix
 
     def generate_markdown_table(self) -> str:
-        # Convert DataFrame to markdown
-        md_table = self.df.to_markdown()
-
-        # Add header
-        header = f"# Benchmark Results: {self.df.index[0]}\n\n"
-        header += f"Number of images: {self.num_images}\n\n"
-        header += "## CPU Information\n\n"
-        header += f"- CPU: {self.cpu_info['name']}\n"
-        header += f"- Frequency: {self.cpu_info['freq']}\n"
-        header += f"- Physical cores: {self.cpu_info['physical_cores']}\n"
-        header += f"- Total cores: {self.cpu_info['total_cores']}\n\n"
-        header += "## Package Versions\n\n"
-        header += pd.DataFrame([self.package_versions]).to_markdown(index=False) + "\n\n"
-        header += "## Performance (images/second)\n\n"
-        return header + md_table
+        # Template for the markdown report
+        REPORT_TEMPLATE = """
+            # Benchmark Results: {benchmark_name}
+
+            Number of images: {num_images}
+
+            ## CPU Information
+
+            - CPU: {cpu_name}
+            - Frequency: {cpu_freq}
+            - Physical cores: {physical_cores}
+            - Total cores: {total_cores}
+
+            ## Package Versions
+
+            {package_versions_table}
+
+            ## Performance (images/second)
+
+            {performance_table}"""
+
+        # Prepare the data for the template
+        template_data = {
+            'benchmark_name': self.df.index[0],
+            'num_images': self.num_images,
+            'cpu_name': self.cpu_info['name'],
+            'cpu_freq': self.cpu_info['freq'],
+            'physical_cores': self.cpu_info['physical_cores'],
+            'total_cores': self.cpu_info['total_cores'],
+            'package_versions_table': pd.DataFrame([self.package_versions]).to_markdown(index=False),
+            'performance_table': self.df.to_markdown()
+        }
+
+        return REPORT_TEMPLATE.format(**template_data)
 
     def _make_versions_text(self) -> str:
         libraries = ["numpy", "opencv-python-headless"]

pyproject.toml

@@ -138,3 +138,8 @@ no_implicit_reexport = true
 
 # for strict mypy: (this is the tricky one :-))
 disallow_untyped_defs = true
+
+# more strict rules
+warn_return_any = true
+strict_equality = true
+warn_unreachable = true