Bugfix linearsource scanspecv2

src/scanspec2/core.py

@@ -83,10 +83,19 @@ def setpoints(self, indexes: np.ndarray) -> dict[AxisT, np.ndarray]:
         """Evaluate linear positions at *indexes*."""
         result: dict[AxisT, np.ndarray] = {}
         for ax, (start, stop) in self.axis_ranges.items():
-            if self._length <= 1:
-                step = stop - start
+            # If inquired for a single index the step size is
+            # the distance normalized by the original lenght.
+            if len(indexes) <= 1:
+                step = (stop - start) / self._length
+            # If inquired for multiple indexes step size becomes
+            # the original range normalized over the number of indexes.
+            # It's also necessary to add two extra points:
+            # *One point for the first lower bound
+            # *One point for the last upper bound
+            # result[ax][N] - result[ax][N-1] -> should return the midpoint
             else:
-                step = (stop - start) / (self._length - 1)
+                step = (stop - start) / (len(indexes))
+                indexes = np.arange(0, len(indexes) + 2, 1)
             first = start - step / 2
             result[ax] = first + indexes * step
         return result

tests/scanspec2/__init__.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+import pytest
+
+
+def approx(
+    expected: Any,
+    rel: float | None = None,
+    abs: float | None = None,
+    nan_ok: bool = False,
+) -> Any:
+    """
+    Temporary loosely typed wrapper around approx.
+    To be removed pending:
+    https://github.com/pytest-dev/pytest/issues/7469
+
+    Args:
+        expected: Expected value
+        rel: Relative tolerance. Defaults to None.
+        abs: Absolute tolerance. Defaults to None.
+        nan_ok: Permit nan. Defaults to False.
+
+    Returns:
+        Any: Approximate comparator
+    """
+
+    return pytest.approx(expected, rel=rel, abs=abs, nan_ok=nan_ok)  # type: ignore

tests/scanspec2/test_compile.py

@@ -1012,3 +1012,84 @@ def test_zip_rejects_monitors():
     )
     with pytest.raises(ValueError, match="Zip does not accept.*monitors"):
         Linspace("y", 0, 1, 5).zip(a).compile()  # type: ignore[reportArgumentType]
+
+
+def test_acquire_fly_scan_window_positions():
+    # Detector with total acquisition time of 1s
+    det = DetectorGroup(1, 10, 0.9, 0.1, ["spec_det1"])
+    spec: Acquire[str, str, Never] = Acquire(
+        spec=Linspace("x", 11, 20, 10), fly=True, detectors=[det], stream_name="spec"
+    )
+    scan = spec.compile()
+    ws = windows(scan)
+    assert len(ws) == 1
+    for w in ws:
+        # Return positions spaced 1s apart
+        for p in w.positions(1, None):
+            assert len(p["x"]) == 12
+            assert p["x"] == pytest.approx(  # type: ignore[reportUnknownMemberType]
+                [
+                    10.55,
+                    11.45,
+                    12.35,
+                    13.25,
+                    14.15,
+                    15.05,
+                    15.95,
+                    16.85,
+                    17.75,
+                    18.65,
+                    19.55,
+                    20.45,
+                ]
+            )
+    det = DetectorGroup(1, 10, 1, 1, ["spec_det1"])
+    spec: Acquire[str, str, Never] = Acquire(
+        spec=Linspace("x", 11, 20, 10), fly=True, detectors=[det], stream_name="spec"
+    )
+    scan = spec.compile()
+    ws = windows(scan)
+    assert len(ws) == 1
+    for w in ws:
+        # Return positions spaced 1s apart
+        for p in w.positions(1, None):
+            assert len(p["x"]) == 22
+            assert p["x"] == pytest.approx(  # type: ignore[reportUnknownMemberType]
+                [
+                    10.775,
+                    11.225,
+                    11.675,
+                    12.125,
+                    12.575,
+                    13.025,
+                    13.475,
+                    13.925,
+                    14.375,
+                    14.825,
+                    15.275,
+                    15.725,
+                    16.175,
+                    16.625,
+                    17.075,
+                    17.525,
+                    17.975,
+                    18.425,
+                    18.875,
+                    19.325,
+                    19.775,
+                    20.225,
+                ]
+            )
+
+
+def test_acquire_step_scan_window_positions():
+    det = DetectorGroup(1, 10, 1, 1, ["spec_det1"])
+    spec: Acquire[str, str, Never] = Acquire(
+        spec=Linspace("x", 0, 10, 10), fly=False, detectors=[det], stream_name="spec"
+    )
+    scan = spec.compile()
+    ws = windows(scan)
+    pos = np.linspace(0, 10, 10, endpoint=False)
+    assert len(ws) == 10
+    for w, p in zip(ws, pos, strict=True):
+        assert w.static_axes == {"x": p}