pyobs-fli 2.0.0.dev10__tar.gz → 2.0.0.dev12__tar.gz

pyobs_fli-2.0.0.dev12/.github/workflows/dependabot-automerge.yml

@@ -0,0 +1,24 @@
+name: Dependabot auto-merge
+
+on: pull_request
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.user.login == 'dependabot[bot]' }}
+    steps:
+      - name: Fetch Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2
+        with:
+          compat-lookup: true
+      - name: Enable auto-merge for patch and minor updates
+        if: ${{ steps.metadata.outputs.update-type == 'version-update:semver-patch' || steps.metadata.outputs.update-type == 'version-update:semver-minor' }}
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/PKG-INFO

@@ -1,11 +1,14 @@
 Metadata-Version: 2.4
 Name: pyobs-fli
-Version: 2.0.0.dev10
+Version: 2.0.0.dev12
 Summary: pyobs module for FLI cameras
 Author-Email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
 Requires-Python: >=3.11
 Requires-Dist: astropy<9,>=7.0.1
 Requires-Dist: numpy<3,>=2.2.5
-Requires-Dist: pyobs-core<3,>=2.0.0.dev48
+Requires-Dist: pyobs-core<3,>=2.0.0.dev82
+Provides-Extra: gui
+Requires-Dist: pyobs-core[gui]<3,>=2.0.0.dev48; extra == "gui"
+Requires-Dist: qasync>=0.27; extra == "gui"
 

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/pyobs_fli/flibase.py

@@ -27,9 +27,10 @@ class FliBaseMixin:
         dev_name: str | None = None,
         dev_path: str | None = None,
         keep_alive_ping: int = 10,
+        sdk_call_timeout: float = _SDK_CALL_TIMEOUT,
         **kwargs: Any,
     ):
-        """Initializes a new FliCamera.
+        """Initializes a new FLI device mixin.
 
         If neither dev_name nor dev_path are given, the first found device is used.
 
@@ -38,6 +39,7 @@ class FliBaseMixin:
             dev_name: Optional name for device.
             dev_path: Optional path to device.
             keep_alive_ping: Interval for keep alive ping.
+            sdk_call_timeout: Default timeout for blocking FLI SDK calls.
         """
         from .flidriver import FliDriver  # type: ignore
 
@@ -46,30 +48,47 @@ class FliBaseMixin:
         self._dev_name = dev_name
         self._dev_path = dev_path
         self._keep_alive_ping = keep_alive_ping
+        self._sdk_call_timeout = sdk_call_timeout
         self._driver: FliDriver | None = None
         self._device: Any | None = None
 
         # keep alive
         self.add_background_task(self._keep_alive)  # type: ignore[attr-defined]
 
-    @staticmethod
-    async def _run_blocking(func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT) -> bool:
+        # forward anything left to the next class in the MRO -- lets a class combining this mixin
+        # with Module/BaseCamera (which must run first, since add_background_task above needs it)
+        # claim its own kwargs cooperatively instead of this mixin silently absorbing them
+        super().__init__(**kwargs)  # type: ignore[call-arg]
+
+    async def _run_blocking(self, func: Callable[[], None], timeout: float | None = None) -> bool:
         """Run a blocking FLI SDK call in a daemon thread, so a hung call can't freeze the module.
 
         A plain executor isn't used here, since its worker threads are non-daemon and Python joins
         them on interpreter shutdown -- a hung call would then just move the freeze to process exit.
 
+        Args:
+            func: Blocking callable to run off the event loop.
+            timeout: Seconds to wait for completion. Defaults to sdk_call_timeout.
+
         Returns:
             True if func completed within timeout, False if it's still running in the background.
         """
+        timeout = self._sdk_call_timeout if timeout is None else timeout
         loop = asyncio.get_running_loop()
         future: asyncio.Future[None] = loop.create_future()
 
+        def _complete() -> None:
+            # The worker thread may outlive the timeout (wait_for cancels the future on
+            # timeout), so guard against a late set_result on an already-completed future --
+            # otherwise the loop callback raises InvalidStateError.
+            if not future.done():
+                future.set_result(None)
+
         def _wrapper() -> None:
             try:
                 func()
             finally:
-                loop.call_soon_threadsafe(future.set_result, None)
+                loop.call_soon_threadsafe(_complete)
 
         threading.Thread(target=_wrapper, daemon=True).start()
         try:
@@ -78,14 +97,19 @@ class FliBaseMixin:
         except TimeoutError:
             return False
 
-    async def _run_blocking_or_raise(self, func: Callable[[], _T], timeout: float = _SDK_CALL_TIMEOUT) -> _T:
+    async def _run_blocking_or_raise(self, func: Callable[[], _T], timeout: float | None = None) -> _T:
         """Run a blocking FLI SDK call in a thread, returning its result or re-raising what it raised.
 
         Unlike _run_blocking(), this also carries the callable's return value/exception back to the
         caller -- several FLI calls drive control flow via their return value or a raised ValueError
         (e.g. device enumeration, readout), which a bare fire-and-forget thread call would otherwise
         silently lose.
+
+        Args:
+            func: Blocking callable to run off the event loop.
+            timeout: Seconds to wait for completion. Defaults to sdk_call_timeout.
         """
+        timeout = self._sdk_call_timeout if timeout is None else timeout
         outcome: list[Any] = []
 
         def _wrapper() -> None:
@@ -156,13 +180,14 @@ class FliBaseMixin:
                 driver = self._driver
                 try:
                     await self._run_blocking_or_raise(driver.get_serial_string)
-                except ValueError:
+                except (ValueError, OSError):
                     # no? then reopen driver
                     log.warning("Lost connection to camera, reopening it.")
 
                     def _reopen() -> None:
                         driver.close()
                         self._driver = FliDriver(self._device)
+                        self._driver.open()
 
                     await self._run_blocking_or_raise(_reopen)
 

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/pyobs_fli/flicamera.py

@@ -24,7 +24,7 @@ log = logging.getLogger(__name__)
 _READOUT_TIMEOUT = 60.0
 
 
-class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling, ITemperatures, IAbortable):
+class FliCamera(BaseCamera, FliBaseMixin, ICamera, IWindow, IBinning, ICooling, ITemperatures, IAbortable):
     """A pyobs module for FLI cameras."""
 
     __module__ = "pyobs_fli"
@@ -35,8 +35,7 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
         Args:
             setpoint: Cooling temperature setpoint.
         """
-        BaseCamera.__init__(self, **kwargs)
-        FliBaseMixin.__init__(self, dev_type=DeviceType.CAMERA, **kwargs)
+        super().__init__(dev_type=DeviceType.CAMERA, **kwargs)
 
         self._temp_setpoint: float | None = setpoint
         self._cooling_enabled = False
@@ -159,7 +158,12 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
                 img[row, :] = driver.grab_row(width)
             return img
 
-        img = await self._run_blocking_or_raise(_readout, timeout=_READOUT_TIMEOUT)
+        try:
+            img = await self._run_blocking_or_raise(_readout, timeout=_READOUT_TIMEOUT)
+        except Exception:
+            log.error("Readout failed, cancelling exposure.")
+            await self._abort_exposure()
+            raise
 
         def _get_headers() -> tuple[float, float, tuple[int, int, int, int]]:
             return (

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/pyobs_fli/flidriver.pyx

@@ -8,6 +8,8 @@ import numpy as np
 cimport numpy as np
 np.import_array()
 
+from libc.string cimport memset
+
 from .libfli cimport *
 
 
@@ -447,18 +449,22 @@ cdef class FliDriver:
         """
 
         # variables
-        cdef char *model
-        cdef size_t len
+        cdef char model[1024]
         cdef long res
 
+        # zero the buffer so FLIGetModel's NUL-terminated string is followed by known NULs, and
+        # bytes(model) (which uses the full 1024-byte static length, not the NUL) can be truncated
+        # safely below
+        memset(model, 0, sizeof(model))
+
         # get it
         with nogil:
-            res = FLIGetModel(self._device, model, len)
+            res = FLIGetModel(self._device, <char*>model, 1024)
         if res != 0:
             raise ValueError('Could not fetch model.')
 
         # return it
-        return str(model)
+        return bytes(model).split(b'\x00')[0].decode('utf-8')
 
     def get_serial_string(self) -> str:
         """Returns serial string for camera."""
@@ -467,6 +473,9 @@ cdef class FliDriver:
         cdef char serial[1024]
         cdef long res
 
+        # zero the buffer (same NUL-truncation reasoning as get_model above)
+        memset(serial, 0, sizeof(serial))
+
         # get it
         with nogil:
             res = FLIGetSerialString(self._device, <char*>serial, 1024)
@@ -474,7 +483,7 @@ cdef class FliDriver:
             raise ValueError('Could not fetch serial string.')
 
         # return it
-        return bytes(serial).decode('utf-8')
+        return bytes(serial).split(b'\x00')[0].decode('utf-8')
 
     def get_filter_pos(self) -> int:
         """Returns current filter position.

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/pyobs_fli/flifilterwheel.py

@@ -16,26 +16,36 @@ from pyobs_fli.flidriver import DeviceType
 
 log = logging.getLogger(__name__)
 
+# A physical filter move can take far longer than a typical SDK call (a long rotation
+# can be several seconds), so give it its own generous, configurable deadline instead of
+# the short SDK-call default.
+_FILTER_MOVE_TIMEOUT = 120.0
 
-class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHeaderBefore):
+
+class FliFilterWheel(Module, FliBaseMixin, MotionStatusMixin, IFilters, IFitsHeaderBefore):
     """A pyobs module for FLI filter wheels."""
 
     __module__ = "pyobs_fli"
 
-    def __init__(self, filter_names: list[str] | list[list[str]], **kwargs: Any):
+    def __init__(
+        self,
+        filter_names: list[str] | list[list[str]],
+        filter_move_timeout: float = _FILTER_MOVE_TIMEOUT,
+        **kwargs: Any,
+    ):
         """Initializes a new FliFilterWheel.
 
         Args:
             filter_names: Names of filters.
+            filter_move_timeout: Seconds to wait for a filter move to complete.
         """
-        Module.__init__(self, **kwargs)
-        FliBaseMixin.__init__(self, dev_type=DeviceType.FILTERWHEEL, **kwargs)
-        MotionStatusMixin.__init__(self, motion_status_interfaces=["IFilters"])
+        super().__init__(dev_type=DeviceType.FILTERWHEEL, motion_status_interfaces=["IFilters"], **kwargs)
 
         self._filter_names: list[list[str]] = (
             [filter_names] if isinstance(filter_names[0], str) else filter_names  # type: ignore[arg-type,list-item]
         )
 
+        self._filter_move_timeout = filter_move_timeout
         self._current_filter = ""
 
     async def open(self) -> None:
@@ -97,7 +107,23 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
         def _set() -> None:
             driver.set_filter_pos(pos)
 
-        await self._run_blocking_or_raise(_set)
+        try:
+            # A physical filter move can legitimately take far longer than a typical SDK
+            # call, so bound it with a dedicated, configurable move timeout rather than the
+            # short SDK-call default -- which cut off long rotations mid-move.
+            await self._run_blocking_or_raise(_set, timeout=self._filter_move_timeout)
+
+            # Confirm the wheel actually reports the requested position before declaring
+            # success, so an SDK call that returned without the wheel having arrived can't
+            # leave the published filter state silently wrong.
+            actual = await self._run_blocking_or_raise(driver.get_filter_pos)
+            if actual != pos:
+                raise exc.MoveError(f"Filter wheel reported position {actual} after moving to {pos}.")
+        except Exception:
+            # Don't leave the wheel stuck reporting "slewing" after a failed move.
+            await self._change_motion_status(MotionStatus.ERROR)
+            raise
+
         self._current_filter = filter_name
         await self._change_motion_status(MotionStatus.POSITIONED)
         await self.comm.send_event(FilterChangedEvent(filter_name))

pyobs_fli-2.0.0.dev12/pyobs_fli/gui.py

@@ -0,0 +1,229 @@
+"""Standalone PySide6 GUI driving FliDriver directly, for testing a FLI camera without a full
+pyobs module.
+
+Unverified against real FLI hardware.
+"""
+
+import asyncio
+import sys
+import threading
+import time
+
+import numpy as np
+import qasync  # type: ignore[import-untyped]
+from astropy.io import fits
+from pyobs.utils.enums import ImageFormat
+from pyobs.utils.gui.camera import (
+    BinningWidget,
+    DataDisplayWidget,
+    ExposeWidget,
+    ExposureTimeWidget,
+    ImageFormatWidget,
+    ListPickerDialog,
+)
+from pyobs.utils.gui.camera.windowingwidget import WindowingWidget
+from PySide6 import QtCore, QtWidgets  # type: ignore[import-untyped]
+
+from .flidriver import FliDriver, FliTemperature  # type: ignore[import-untyped]
+
+
+class MainWindow(QtWidgets.QMainWindow):
+    def __init__(self, driver: FliDriver, binning, full_frame) -> None:
+        super().__init__()
+        self.setWindowTitle("FLI Camera")
+
+        # the driver is opened by async_main() before this window is built, so __init__ stays
+        # free of blocking SDK calls
+        self._driver = driver
+        self._sdk_lock = threading.Lock()
+        self._abort_event = asyncio.Event()
+        self._exposing = False
+        self._closing = False
+
+        central = QtWidgets.QWidget()
+        self.setCentralWidget(central)
+        global_layout = QtWidgets.QHBoxLayout(central)
+
+        controls = QtWidgets.QGroupBox("Controls")
+        global_layout.addWidget(controls)
+        layout = QtWidgets.QVBoxLayout(controls)
+
+        self._window_widget = WindowingWidget(full_frame[2], full_frame[3])
+        layout.addWidget(self._window_widget)
+
+        binnings = [(1, 1), (2, 2), (3, 3), (4, 4)]
+        self._binning_widget = BinningWidget(binnings)
+        self._binning_widget.binning_changed.connect(self._window_widget.set_binning)
+        if binning in binnings:
+            self._binning_widget.combo_binnings.setCurrentIndex(binnings.index(binning))
+        layout.addWidget(self._binning_widget)
+
+        self._format_widget = ImageFormatWidget([ImageFormat.INT16])
+        layout.addWidget(self._format_widget)
+
+        self._exposure_time = ExposureTimeWidget()
+        layout.addWidget(self._exposure_time)
+
+        self._expose_widget = ExposeWidget()
+        self._expose_widget.expose_clicked.connect(self._expose_clicked)
+        self._expose_widget.abort_clicked.connect(self._abort_clicked)
+        layout.addWidget(self._expose_widget)
+
+        temp_group = QtWidgets.QGroupBox("Temperature")
+        temp_layout = QtWidgets.QFormLayout(temp_group)
+        self._label_ccd = QtWidgets.QLabel("—")
+        self._label_base = QtWidgets.QLabel("—")
+        self._label_power = QtWidgets.QLabel("—")
+        temp_layout.addRow("CCD:", self._label_ccd)
+        temp_layout.addRow("Base:", self._label_base)
+        temp_layout.addRow("Cooler:", self._label_power)
+        layout.addWidget(temp_group)
+        layout.addStretch()
+
+        self._data_display = DataDisplayWidget()
+        global_layout.addWidget(self._data_display)
+
+        self._temp_timer = QtCore.QTimer()
+        self._temp_timer.timeout.connect(self._refresh_temp)
+        self._temp_timer.start(5000)
+        asyncio.ensure_future(self._refresh_temp())
+
+    def _run_blocking(self, func):
+        """Run a blocking driver call on the default executor, serialized behind self._sdk_lock."""
+        loop = asyncio.get_running_loop()
+
+        def _wrapper():
+            with self._sdk_lock:
+                return func()
+
+        return loop.run_in_executor(None, _wrapper)
+
+    @qasync.asyncSlot()  # type: ignore[misc]
+    async def _refresh_temp(self) -> None:
+        if self._exposing or self._closing:
+            return
+        try:
+            ccd, base, power = await self._run_blocking(
+                lambda: (
+                    self._driver.get_temp(FliTemperature.CCD),
+                    self._driver.get_temp(FliTemperature.BASE),
+                    self._driver.get_cooler_power(),
+                )
+            )
+            self._label_ccd.setText(f"{ccd:.1f} °C")
+            self._label_base.setText(f"{base:.1f} °C")
+            self._label_power.setText(f"{power:.0f} %")
+        except Exception:
+            pass
+
+    @qasync.asyncSlot(int)  # type: ignore[misc]
+    async def _expose_clicked(self, count: int) -> None:
+        left, top, width, height = self._window_widget.values
+        idx = self._binning_widget.combo_binnings.currentIndex()
+        xbin, ybin = self._binning_widget._binnings[idx]  # noqa: SLF001
+        exposure_time = self._exposure_time.value
+
+        def _prepare() -> None:
+            self._driver.set_binning(xbin, ybin)
+            self._driver.set_window(left * xbin, top * ybin, width, height)
+            self._driver.init_exposure(True)
+            self._driver.set_exposure_time(int(exposure_time * 1000.0))
+
+        def _readout() -> np.ndarray:
+            img = np.zeros((height, width), dtype=np.uint16)
+            for row in range(height):
+                img[row, :] = self._driver.grab_row(width)
+            return img
+
+        self._exposing = True
+        try:
+            for i in range(count):
+                if self._abort_event.is_set():
+                    break
+
+                self._expose_widget.start_exposure(exposure_time)
+                await self._run_blocking(_prepare)
+                await self._run_blocking(self._driver.start_exposure)
+
+                if await self._wait_exposure():
+                    await self._run_blocking(self._driver.cancel_exposure)
+                    break
+
+                data = await self._run_blocking(_readout)
+
+                image = fits.PrimaryHDU(data)
+                image.header["EXPTIME"] = (exposure_time, "Exposure time [s]")
+                image.header["XBINNING"] = (xbin, "Binning factor used on X axis")
+                image.header["YBINNING"] = (ybin, "Binning factor used on Y axis")
+                self._data_display.set_data(image)
+                self._expose_widget.set_exposures_left(count - i - 1)
+
+            self._expose_widget.set_exposures_left(0)
+            self._abort_event.clear()
+        finally:
+            self._exposing = False
+
+    async def _wait_exposure(self) -> bool:
+        """Return True if the exposure was aborted, False if data is ready."""
+
+        def _wait() -> bool:
+            while True:
+                if self._abort_event.is_set():
+                    return True
+                if self._driver.is_data_ready():
+                    return False
+                time.sleep(0.01)
+
+        return await self._run_blocking(_wait)
+
+    def _abort_clicked(self) -> None:
+        self._abort_event.set()
+
+    def closeEvent(self, event) -> None:  # type: ignore[override]
+        self._temp_timer.stop()
+        # signal an in-flight exposure to stop, then wait for any SDK call in progress and close
+        self._closing = True
+        self._abort_event.set()
+        with self._sdk_lock:
+            self._driver.close()
+        super().closeEvent(event)
+
+
+async def async_main(app: QtWidgets.QApplication) -> None:
+    devices = FliDriver.list_devices()
+    if not devices:
+        QtWidgets.QMessageBox.critical(None, "Error", "No FLI camera found.")
+        return
+
+    if len(devices) > 1:
+        picker = ListPickerDialog([d.name.decode("utf-8") for d in devices])
+        if picker.exec() != QtWidgets.QDialog.DialogCode.Accepted:
+            return
+        device = devices[picker.comboBox().currentIndex()]
+    else:
+        device = devices[0]
+
+    # open the driver off the event loop before building the window, so MainWindow.__init__ stays
+    # free of blocking SDK calls
+    loop = asyncio.get_running_loop()
+    driver = await loop.run_in_executor(None, FliDriver, device)
+    await loop.run_in_executor(None, driver.open)
+    _, binning = await loop.run_in_executor(None, driver.get_window_binning)
+    full_frame = await loop.run_in_executor(None, driver.get_full_frame)
+
+    app_close_event = asyncio.Event()
+    app.aboutToQuit.connect(app_close_event.set)
+
+    window = MainWindow(driver, binning, full_frame)
+    window.show()
+
+    await app_close_event.wait()
+
+
+def main() -> None:
+    app = QtWidgets.QApplication(sys.argv)
+    asyncio.run(async_main(app), loop_factory=qasync.QEventLoop)  # type: ignore[arg-type]
+
+
+if __name__ == "__main__":
+    main()

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-fli"
-version = "2.0.0.dev10"
+version = "2.0.0.dev12"
 description = "pyobs module for FLI cameras"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"
@@ -8,7 +8,13 @@ license = "MIT"
 dependencies = [
     "astropy>=7.0.1,<9",
     "numpy>=2.2.5,<3",
-    "pyobs-core>=2.0.0.dev48,<3",
+    "pyobs-core>=2.0.0.dev82,<3",
+]
+
+[project.optional-dependencies]
+gui = [
+    "pyobs-core[gui]>=2.0.0.dev48,<3",
+    "qasync>=0.27",
 ]
 
 [dependency-groups]
@@ -21,6 +27,9 @@ dev = [
     "pytest-asyncio>=0.24.0",
 ]
 
+[project.scripts]
+fli-gui = "pyobs_fli.gui:main"
+
 [tool.scikit-build]
 wheel.packages = ["pyobs_fli"]
 
@@ -51,6 +60,7 @@ select = ["E", "F", "W", "I", "UP", "G"]
 [tool.pyrefly]
 python-version = "3.11"
 ignore-missing-imports = []
+project-excludes = ["pyobs_fli/gui.py"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "strict"

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/tests/test_flicamera.py

@@ -23,6 +23,21 @@ def test_constructor_defaults() -> None:
     assert camera._driver is None
 
 
+def test_constructor_threads_fli_kwargs_cooperatively() -> None:
+    """Regression test for the cooperative-super()-chain fix: FliCamera(BaseCamera, FliBaseMixin,
+    ...) used to call BaseCamera.__init__ and FliBaseMixin.__init__ explicitly with the same
+    unfiltered kwargs -- FliBaseMixin-only kwargs like dev_path must still reach FliBaseMixin
+    through the single super().__init__() call, not get lost or leak to object.__init__()."""
+    from pyobs_fli.flidriver import DeviceType
+
+    camera = FliCamera(dev_name="cam1", dev_path="/dev/fliusb0", keep_alive_ping=5)
+    assert camera._dev_type == DeviceType.CAMERA
+    assert camera._dev_name == "cam1"
+    assert camera._dev_path == "/dev/fliusb0"
+    assert camera._keep_alive_ping == 5
+    assert camera._driver is None
+
+
 @pytest.mark.asyncio
 async def test_set_window() -> None:
     camera = FliCamera()
@@ -58,7 +73,7 @@ async def test_run_blocking_runs_func_and_returns_true() -> None:
     def fast() -> None:
         ran.append(True)
 
-    assert await FliCamera._run_blocking(fast) is True
+    assert await FliCamera()._run_blocking(fast) is True
     assert ran == [True]
 
 
@@ -69,7 +84,7 @@ async def test_run_blocking_times_out() -> None:
     def slow() -> None:
         done.wait()
 
-    assert await FliCamera._run_blocking(slow, timeout=0.01) is False
+    assert await FliCamera()._run_blocking(slow, timeout=0.01) is False
     done.set()
     await asyncio.sleep(0.05)
 

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev12}/tests/test_flifilterwheel.py

@@ -19,6 +19,22 @@ def test_constructor_single_wheel() -> None:
     assert wheel._filter_names == [["A", "B", "C"]]
 
 
+def test_constructor_threads_fli_kwargs_cooperatively() -> None:
+    """Regression test for the cooperative-super()-chain fix: FliFilterWheel(Module, FliBaseMixin,
+    MotionStatusMixin, ...) used to call Module.__init__, FliBaseMixin.__init__ and
+    MotionStatusMixin.__init__ explicitly with the same unfiltered kwargs -- live pyobs-monet
+    configs set dev_path explicitly, which must still reach FliBaseMixin through the single
+    super().__init__() call, not get lost or leak to object.__init__()."""
+    from pyobs_fli.flidriver import DeviceType
+
+    wheel = FliFilterWheel(filter_names=["A", "B", "C"], dev_path="/dev/fliusb0", keep_alive_ping=5)
+    assert wheel._dev_type == DeviceType.FILTERWHEEL
+    assert wheel._dev_path == "/dev/fliusb0"
+    assert wheel._keep_alive_ping == 5
+    assert wheel._driver is None
+    assert getattr(wheel, "_MotionStatusMixin__motion_status_interfaces") == ["IFilters"]
+
+
 def test_constructor_two_wheels() -> None:
     wheel = FliFilterWheel(filter_names=_TWO_WHEELS)
     assert wheel._filter_names == _TWO_WHEELS
@@ -45,14 +61,16 @@ async def test_set_filter_first_wheel() -> None:
     wheel = FliFilterWheel(filter_names=_TWO_WHEELS)
     wheel._driver = MagicMock()
     wheel._driver.set_filter_pos = MagicMock()
+    wheel._driver.get_filter_pos = MagicMock(return_value=0)
 
-    async def fake_run(func, timeout: float = 5.0) -> None:
-        func()
+    async def fake_run(func, timeout: float | None = None) -> object:
+        return func()
 
     wheel._run_blocking_or_raise = fake_run  # type: ignore[method-assign]
 
     await wheel.set_filter("A")
     wheel._driver.set_filter_pos.assert_called_once_with(0)
+    wheel._driver.get_filter_pos.assert_called_once()
     assert wheel._current_filter == "A"
 
 
@@ -61,14 +79,16 @@ async def test_set_filter_second_wheel() -> None:
     wheel = FliFilterWheel(filter_names=_TWO_WHEELS)
     wheel._driver = MagicMock()
     wheel._driver.set_filter_pos = MagicMock()
+    wheel._driver.get_filter_pos = MagicMock(return_value=7)
 
-    async def fake_run(func, timeout: float = 5.0) -> None:
-        func()
+    async def fake_run(func, timeout: float | None = None) -> object:
+        return func()
 
     wheel._run_blocking_or_raise = fake_run  # type: ignore[method-assign]
 
     await wheel.set_filter("H")
     wheel._driver.set_filter_pos.assert_called_once_with(7)
+    wheel._driver.get_filter_pos.assert_called_once()
     assert wheel._current_filter == "H"