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

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

@@ -1,11 +1,14 @@
 Metadata-Version: 2.4
 Name: pyobs-fli
-Version: 2.0.0.dev10
+Version: 2.0.0.dev11
 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.dev11}/pyobs_fli/flibase.py

@@ -52,6 +52,11 @@ class FliBaseMixin:
         # keep alive
         self.add_background_task(self._keep_alive)  # type: ignore[attr-defined]
 
+        # 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]
+
     @staticmethod
     async def _run_blocking(func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT) -> bool:
         """Run a blocking FLI SDK call in a daemon thread, so a hung call can't freeze the module.
@@ -156,13 +161,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.dev11}/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.dev11}/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.dev11}/pyobs_fli/flifilterwheel.py

@@ -17,7 +17,7 @@ from pyobs_fli.flidriver import DeviceType
 log = logging.getLogger(__name__)
 
 
-class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHeaderBefore):
+class FliFilterWheel(Module, FliBaseMixin, MotionStatusMixin, IFilters, IFitsHeaderBefore):
     """A pyobs module for FLI filter wheels."""
 
     __module__ = "pyobs_fli"
@@ -28,9 +28,7 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
         Args:
             filter_names: Names of filters.
         """
-        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]

pyobs_fli-2.0.0.dev11/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.dev11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-fli"
-version = "2.0.0.dev10"
+version = "2.0.0.dev11"
 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.dev11}/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()

{pyobs_fli-2.0.0.dev10 → pyobs_fli-2.0.0.dev11}/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