Restructure Axis and Axis testing

Author: GuyPuts

opensquirrel/ir.py

@@ -214,28 +214,8 @@ def __init__(self, *axis: AxisLike) -> None:
         axis: An ``AxisLike`` to create the axis from.
         """
         axis_to_parse = axis[0] if len(axis) == 1 else cast(AxisLike, axis)
-        if not self.has_valid_value(axis_to_parse):
-            raise ValueError
-        self._value = self._parse_and_validate_axislike(axis_to_parse)
-
-    @staticmethod
-    def has_valid_value(*axis: AxisLike) -> bool:
-        """Check if the axis has a valid value.
-
-        Args:
-            axis: An ``AxisLike`` to validate.
-
-        Returns:
-            True if the axis is valid, False otherwise.
-        """
-        try:
-            axis_to_check = axis[0] if len(axis) == 1 else cast(AxisLike, axis)
-            axis_array = np.asarray(axis_to_check, dtype=float).flatten()
-            if len(axis_array) != 3:
-                return False
-            return not np.all(axis_array == 0)
-        except (ValueError, TypeError):
-            return False
+        self._value = self.parse(axis_to_parse)
+        self._value = self.normalize(self._value)
 
     @property
     def value(self) -> NDArray[np.float64]:
@@ -249,10 +229,11 @@ def value(self, axis: AxisLike) -> None:
         Args:
             axis: An ``AxisLike`` to create the axis from.
         """
-        self._value = self._parse_and_validate_axislike(axis)
+        self._value = self.parse(axis)
+        self._value = self.normalize(self._value)
 
     @classmethod
-    def _parse_and_validate_axislike(cls, axis: AxisLike) -> NDArray[np.float64]:
+    def parse(cls, axis: AxisLike) -> NDArray[np.float64]:
         """Parse and validate an ``AxisLike``.
 
         Check if the `axis` can be cast to a 1DArray of length 3, raise an error otherwise.
@@ -276,10 +257,13 @@ def _parse_and_validate_axislike(cls, axis: AxisLike) -> NDArray[np.float64]:
         if len(axis) != 3:
             msg = f"axis requires an ArrayLike of length 3, but received an ArrayLike of length {len(axis)}"
             raise ValueError(msg)
-        return cls._normalize_axis(axis)
+        if np.any(axis != 0).item():
+            return axis
+        msg = "axis requires at least one element to be non-zero"
+        raise ValueError(msg)
 
     @staticmethod
-    def _normalize_axis(axis: NDArray[np.float64]) -> NDArray[np.float64]:
+    def normalize(axis: NDArray[np.float64]) -> NDArray[np.float64]:
         """Normalize a NDArray.
 
         Args:

test/test_ir.py

@@ -6,7 +6,7 @@
 
 import numpy as np
 import pytest
-from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 from opensquirrel.common import ATOL
 from opensquirrel.ir import (
@@ -44,7 +44,7 @@ def test_axis_getter(self, axis: Axis) -> None:
             (Axis(0, 1, 0), [0, 1, 0]),
         ],
     )
-    def test_axis_setter_no_error(self, axis: Axis, new_axis: ArrayLike, expected_axis: ArrayLike) -> None:
+    def test_axis_setter_no_error(self, axis: Axis, new_axis: AxisLike, expected_axis: list[float]) -> None:
         axis.value = new_axis  # type: ignore[assignment]
         np.testing.assert_array_equal(axis, expected_axis)
 
@@ -96,27 +96,59 @@ def test_eq_false(self, axis: Axis, other: Any) -> None:
     @pytest.mark.parametrize(
         ("axis", "expected"),
         [
-            ([1, 0, 0], True),
-            ([0, 0, 0], False),
-            ([1, 2], False),
-            ([1, 2, 3, 4], False),
-            ([0, 1, 0], True),
+            ([1, 0, 0], np.array([1, 0, 0], dtype=np.float64)),
+            ([0, 0, 0], ValueError),
+            ([1, 2], ValueError),
+            ([1, 2, 3, 4], ValueError),
+            ([0, 1, 0], np.array([0, 1, 0], dtype=np.float64)),
+            (["a", "b", "c"], TypeError),
         ],
     )
-    def test_has_valid_value(self, axis: AxisLike, expected: bool) -> None:
-        assert Axis.has_valid_value(axis) == expected
+    def test_constructor(self, axis: AxisLike, expected: Any) -> None:
+        if isinstance(expected, type) and issubclass(expected, Exception):
+            with pytest.raises(expected):
+                Axis(axis)
+        else:
+            assert isinstance(expected, np.ndarray)
+            obj = Axis(axis)
+            np.testing.assert_array_equal(obj.value, expected)
 
     @pytest.mark.parametrize(
-        ("axis", "expected_error"),
+        ("axis", "expected"),
         [
+            ([1, 0, 0], np.array([1, 0, 0], dtype=np.float64)),
             ([0, 0, 0], ValueError),
             ([1, 2], ValueError),
             ([1, 2, 3, 4], ValueError),
+            ([0, 1, 0], np.array([0, 1, 0], dtype=np.float64)),
+            (["a", "b", "c"], TypeError),
+        ],
+    )
+    def test_parser(self, axis: AxisLike, expected: Any) -> None:
+        if isinstance(expected, type) and issubclass(expected, Exception):
+            with pytest.raises(expected):
+                Axis.parse(axis)
+        else:
+            assert isinstance(expected, np.ndarray)
+            obj = Axis.parse(axis)
+            np.testing.assert_array_equal(obj, expected)
+
+    @pytest.mark.parametrize(
+        ("axis", "expected"),
+        [
+            (np.array([1, 0, 0], dtype=np.float64), np.array([1, 0, 0], dtype=np.float64)),
+            (np.array([0, 1, 0], dtype=np.float64), np.array([0, 1, 0], dtype=np.float64)),
+            (np.array([0, 0, 1], dtype=np.float64), np.array([0, 0, 1], dtype=np.float64)),
+            (
+                np.array([1, 1, 1], dtype=np.float64),
+                np.array([1 / np.sqrt(3), 1 / np.sqrt(3), 1 / np.sqrt(3)], dtype=np.float64),
+            ),
         ],
     )
-    def test_init_with_invalid_value(self, axis: AxisLike, expected_error: type[Exception]) -> None:
-        with pytest.raises(expected_error):
-            Axis(axis)
+    def test_normalize(self, axis: AxisLike, expected: NDArray[np.float64]) -> None:
+        obj = Axis.normalize(np.array(axis, dtype=np.float64))
+        assert isinstance(expected, np.ndarray)
+        np.testing.assert_array_almost_equal(obj, expected)
 
 
 class TestIR: