pyobs-fli 2.0.0.dev4__tar.gz → 2.0.0.dev6__tar.gz

pyobs_fli-2.0.0.dev6/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "tuesday"
+    target-branch: "develop"
+    labels:
+      - "dependencies"

{pyobs_fli-2.0.0.dev4 → pyobs_fli-2.0.0.dev6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: pyobs-fli
-Version: 2.0.0.dev4
+Version: 2.0.0.dev6
 Summary: pyobs module for FLI cameras
 Author-Email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
 Requires-Python: <3.14,>=3.11
-Requires-Dist: astropy<8,>=7.0.1
+Requires-Dist: astropy<9,>=7.0.1
 Requires-Dist: numpy<3,>=2.2.5
-Requires-Dist: pyobs-core<3,>=2.0.0.dev6
+Requires-Dist: pyobs-core<3,>=2.0.0.dev48
 

pyobs_fli-2.0.0.dev6/pyobs_fli/flibase.py

@@ -0,0 +1,172 @@
+import asyncio
+import logging
+import threading
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
+
+from pyobs_fli.flidriver import DeviceType
+
+log = logging.getLogger(__name__)
+
+_T = TypeVar("_T")
+
+# FLI SDK calls are blocking and are made directly on the event loop thread (see _run_blocking).
+# If the device has gone unresponsive, they can hang indefinitely, so they're bounded with a
+# timeout rather than let a single dead device freeze the whole module.
+_SDK_CALL_TIMEOUT = 5.0
+
+
+class FliBaseMixin:
+    """A base class for pyobs module for FLI devices."""
+
+    __module__ = "pyobs_fli"
+
+    def __init__(
+        self,
+        dev_type: DeviceType,
+        dev_name: str | None = None,
+        dev_path: str | None = None,
+        keep_alive_ping: int = 10,
+        **kwargs: Any,
+    ):
+        """Initializes a new FliCamera.
+
+        If neither dev_name nor dev_path are given, the first found device is used.
+
+        Args:
+            dev_type: Device type.
+            dev_name: Optional name for device.
+            dev_path: Optional path to device.
+            keep_alive_ping: Interval for keep alive ping.
+        """
+        from .flidriver import FliDriver  # type: ignore
+
+        # variables
+        self._dev_type = dev_type
+        self._dev_name = dev_name
+        self._dev_path = dev_path
+        self._keep_alive_ping = keep_alive_ping
+        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:
+        """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.
+
+        Returns:
+            True if func completed within timeout, False if it's still running in the background.
+        """
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[None] = loop.create_future()
+
+        def _wrapper() -> None:
+            try:
+                func()
+            finally:
+                loop.call_soon_threadsafe(future.set_result, None)
+
+        threading.Thread(target=_wrapper, daemon=True).start()
+        try:
+            await asyncio.wait_for(future, timeout=timeout)
+            return True
+        except TimeoutError:
+            return False
+
+    async def _run_blocking_or_raise(self, func: Callable[[], _T], timeout: float = _SDK_CALL_TIMEOUT) -> _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.
+        """
+        outcome: list[Any] = []
+
+        def _wrapper() -> None:
+            try:
+                outcome.append(func())
+            except BaseException as e:
+                outcome.append(e)
+
+        if not await self._run_blocking(_wrapper, timeout=timeout):
+            raise TimeoutError(f"Timed out waiting for FLI SDK call after {timeout}s.")
+        value = outcome[0]
+        if isinstance(value, BaseException):
+            raise value
+        return cast(_T, value)
+
+    async def open(self) -> None:
+        """Open module."""
+        from .flidriver import FliDriver
+
+        def _open() -> None:
+            # list devices
+            devices = FliDriver.list_devices(self._dev_type)
+            if len(devices) == 0:
+                raise ValueError("No FLI device found.")
+
+            # do we have a device name or path given?
+            if self._dev_name is not None or self._dev_path is not None:
+                # yes, find matching device
+                for dev in devices:
+                    if dev.name.decode("utf-8") == self._dev_name or dev.filename.decode("utf-8") == self._dev_path:
+                        self._device = dev
+                        break
+                else:
+                    raise ValueError("No matching device found, check dev_name/dev_path.")
+
+            else:
+                # no, just pick first one
+                self._device = devices[0]
+
+            # open driver
+            log.info(
+                'Opening connection to "%s" at %s...',
+                self._device.name.decode("utf-8"),
+                self._device.filename.decode("utf-8"),
+            )
+            self._driver = FliDriver(self._device)
+            self._driver.open()
+
+        await self._run_blocking_or_raise(_open)
+
+    async def close(self) -> None:
+        # not open?
+        if self._driver is not None:
+            # close connection
+            driver = self._driver
+            if not await self._run_blocking(driver.close):
+                log.error("Timed out closing FLI device after %.1fs.", _SDK_CALL_TIMEOUT)
+            self._driver = None
+
+    async def _keep_alive(self) -> None:
+        """Keep connection to camera alive."""
+        from .flidriver import FliDriver
+
+        while True:
+            # is there a valid driver?
+            if self._driver is not None:
+                # then we should be able to call it
+                driver = self._driver
+                try:
+                    await self._run_blocking_or_raise(driver.get_serial_string)
+                except ValueError:
+                    # no? then reopen driver
+                    log.warning("Lost connection to camera, reopening it.")
+
+                    def _reopen() -> None:
+                        driver.close()
+                        self._driver = FliDriver(self._device)
+
+                    await self._run_blocking_or_raise(_reopen)
+
+            await asyncio.sleep(self._keep_alive_ping)
+
+
+__all__ = ["FliBaseMixin"]

{pyobs_fli-2.0.0.dev4 → pyobs_fli-2.0.0.dev6}/pyobs_fli/flicamera.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 import math
+import time
 from datetime import UTC, datetime
 from typing import Any
 
@@ -12,6 +13,7 @@ from pyobs.interfaces.ICooling import CoolingState
 from pyobs.interfaces.ITemperatures import SensorReading, TemperaturesState
 from pyobs.interfaces.IWindow import WindowCapabilities, WindowState
 from pyobs.modules.camera.basecamera import BaseCamera
+from pyobs.utils import exceptions as exc
 from pyobs.utils.enums import ExposureStatus
 
 from .flibase import FliBaseMixin
@@ -19,6 +21,8 @@ from .flidriver import DeviceType
 
 log = logging.getLogger(__name__)
 
+_READOUT_TIMEOUT = 60.0
+
 
 class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling, ITemperatures, IAbortable):
     """A pyobs module for FLI cameras."""
@@ -50,11 +54,16 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
         if self._driver is None:
             raise ValueError("No driver found.")
 
-        serial = self._driver.get_serial_string()
-        log.info("Connected to camera with serial number: %s", serial)
+        driver = self._driver
 
-        self._window, self._binning = self._driver.get_window_binning()
-        self._full_frame = self._driver.get_full_frame()
+        def _get_info() -> tuple[str, tuple[int, int, int, int], tuple[int, int], tuple[int, int, int, int]]:
+            serial = driver.get_serial_string()
+            window, binning = driver.get_window_binning()
+            full_frame = driver.get_full_frame()
+            return serial, window, binning, full_frame
+
+        serial, self._window, self._binning, self._full_frame = await self._run_blocking_or_raise(_get_info)
+        log.info("Connected to camera with serial number: %s", serial)
 
         if self._temp_setpoint is not None:
             await self.set_cooling(True, self._temp_setpoint)
@@ -106,9 +115,9 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
 
         if self._driver is None:
             raise ValueError("No camera driver.")
+        driver = self._driver
 
         log.info("Set binning to %dx%d.", self._binning[0], self._binning[1])
-        self._driver.set_binning(*self._binning)
 
         width = int(math.floor(self._window[2]) / self._binning[0])
         height = int(math.floor(self._window[3]) / self._binning[1])
@@ -121,32 +130,50 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
             self._window[0],
             self._window[1],
         )
-        self._driver.set_window(self._window[0], self._window[1], width, height)
 
-        self._driver.init_exposure(open_shutter)
-        self._driver.set_exposure_time(int(exposure_time * 1000.0))
+        def _prepare() -> None:
+            driver.set_binning(*self._binning)
+            driver.set_window(self._window[0], self._window[1], width, height)
+            driver.init_exposure(open_shutter)
+            driver.set_exposure_time(int(exposure_time * 1000.0))
+
+        await self._run_blocking_or_raise(_prepare)
 
         log.info(
             "Starting exposure with %s shutter for %.2f seconds...", "open" if open_shutter else "closed", exposure_time
         )
         date_obs = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f")
 
-        self._driver.start_exposure()
+        await self._run_blocking_or_raise(driver.start_exposure)
         await self._wait_exposure(abort_event, exposure_time, open_shutter)
 
         log.info("Exposure finished, reading out...")
         await self._change_exposure_status(ExposureStatus.READOUT)
         width = int(math.floor(self._window[2] / self._binning[0]))
         height = int(math.floor(self._window[3] / self._binning[1]))
-        img = np.zeros((height, width), dtype=np.uint16)
-        for row in range(height):
-            img[row, :] = self._driver.grab_row(width)
+
+        def _readout() -> np.ndarray:
+            img = np.zeros((height, width), dtype=np.uint16)
+            for row in range(height):
+                img[row, :] = driver.grab_row(width)
+            return img
+
+        img = await self._run_blocking_or_raise(_readout, timeout=_READOUT_TIMEOUT)
+
+        def _get_headers() -> tuple[float, float, tuple[int, int, int, int]]:
+            return (
+                driver.get_temp(FliTemperature.CCD),
+                driver.get_cooler_power(),
+                driver.get_visible_frame(),
+            )
+
+        ccd_temp, cooler_power, visible_frame = await self._run_blocking_or_raise(_get_headers)
 
         image = Image(img)  # type: ignore[arg-type]
         image.header["DATE-OBS"] = (date_obs, "Date and time of start of exposure")
         image.header["EXPTIME"] = (exposure_time, "Exposure time [s]")
-        image.header["DET-TEMP"] = (self._driver.get_temp(FliTemperature.CCD), "CCD temperature [C]")
-        image.header["DET-COOL"] = (self._driver.get_cooler_power(), "Cooler power [percent]")
+        image.header["DET-TEMP"] = (ccd_temp, "CCD temperature [C]")
+        image.header["DET-COOL"] = (cooler_power, "Cooler power [percent]")
         image.header["DET-TSET"] = (self._temp_setpoint, "Cooler setpoint [C]")
         image.header["INSTRUME"] = (self._driver.name, "Name of instrument")
         image.header["XBINNING"] = image.header["DET-BIN1"] = (self._binning[0], "Binning factor used on X axis")
@@ -157,24 +184,32 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
         image.header["DATAMAX"] = (float(np.max(img)), "Maximum data value")
         image.header["DATAMEAN"] = (float(np.mean(img)), "Mean data value")
 
-        self.set_biassec_trimsec(image.header, *self._driver.get_visible_frame())
+        self.set_biassec_trimsec(image.header, *visible_frame)
 
         log.info("Readout finished.")
         return image
 
     async def _wait_exposure(self, abort_event: asyncio.Event, exposure_time: float, open_shutter: bool) -> None:
-        while True:
-            if abort_event.is_set():
-                await self._change_exposure_status(ExposureStatus.IDLE)
-                raise InterruptedError("Aborted exposure.")
-            if self._driver.is_exposing():
-                break
-            await asyncio.sleep(0.01)
+        if self._driver is None:
+            raise ValueError("No camera driver.")
+        driver = self._driver
+
+        def _wait() -> bool:
+            while True:
+                if driver.is_exposing():
+                    return not abort_event.is_set()
+                if abort_event.is_set():
+                    return False
+                time.sleep(0.01)
+
+        if not await self._run_blocking_or_raise(_wait, timeout=exposure_time + 30):
+            await self._change_exposure_status(ExposureStatus.IDLE)
+            raise exc.AbortedError("Aborted exposure.")
 
     async def _abort_exposure(self) -> None:
         if self._driver is None:
             raise ValueError("No camera driver.")
-        self._driver.cancel_exposure()
+        await self._run_blocking_or_raise(self._driver.cancel_exposure)
 
     async def set_cooling(self, enabled: bool, setpoint: float, **kwargs: Any) -> None:
         """Enables/disables cooling and sets setpoint."""
@@ -188,7 +223,12 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
 
         self._temp_setpoint = setpoint if enabled else None
         self._cooling_enabled = enabled
-        self._driver.set_temperature(float(setpoint) if setpoint is not None else 20.0)
+        driver = self._driver
+
+        def _set() -> None:
+            driver.set_temperature(float(setpoint) if setpoint is not None else 20.0)
+
+        await self._run_blocking_or_raise(_set)
         await self.comm.set_state(
             ICooling, CoolingState(setpoint=setpoint if setpoint is not None else 20.0, power=None, enabled=enabled)
         )
@@ -200,9 +240,16 @@ class FliCamera(FliBaseMixin, BaseCamera, ICamera, IWindow, IBinning, ICooling,
         while True:
             try:
                 if self._driver is not None:
-                    t_ccd = self._driver.get_temp(FliTemperature.CCD)
-                    t_base = self._driver.get_temp(FliTemperature.BASE)
-                    power = self._driver.get_cooler_power()
+                    driver = self._driver
+
+                    def _poll() -> tuple[float, float, float]:
+                        return (
+                            driver.get_temp(FliTemperature.CCD),
+                            driver.get_temp(FliTemperature.BASE),
+                            driver.get_cooler_power(),
+                        )
+
+                    t_ccd, t_base, power = await self._run_blocking_or_raise(_poll)
                     setpoint = self._temp_setpoint if self._temp_setpoint is not None else 20.0
                     await self.comm.set_state(
                         ICooling, CoolingState(setpoint=setpoint, power=round(power), enabled=self._cooling_enabled)

{pyobs_fli-2.0.0.dev4 → pyobs_fli-2.0.0.dev6}/pyobs_fli/flifilterwheel.py

@@ -4,7 +4,7 @@ from typing import Any
 
 import pyobs.utils.exceptions as exc
 from pyobs.events import FilterChangedEvent
-from pyobs.interfaces import IFilters, IFitsHeaderBefore, IReady
+from pyobs.interfaces import FitsHeaderEntry, IFilters, IFitsHeaderBefore, IReady
 from pyobs.interfaces.IFilters import FiltersCapabilities, FilterState
 from pyobs.interfaces.IReady import ReadyState
 from pyobs.mixins import MotionStatusMixin
@@ -47,7 +47,8 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
         if self._driver is None:
             raise ValueError("No driver found.")
 
-        serial = self._driver.get_serial_string()
+        driver = self._driver
+        serial = await self._run_blocking_or_raise(driver.get_serial_string)
         log.info("Connected to filter wheel with serial number: %s", serial)
 
         await self._change_motion_status(MotionStatus.IDLE)
@@ -58,7 +59,8 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
         all_filters = list(chain.from_iterable(self._filter_names))
         await self.comm.set_capabilities(IFilters, FiltersCapabilities(filters=all_filters))
 
-        self._current_filter = self._resolve_filter_name(self._driver.get_filter_pos())
+        pos = await self._run_blocking_or_raise(driver.get_filter_pos)
+        self._current_filter = self._resolve_filter_name(pos)
         await self.comm.set_state(IFilters, FilterState(filter=self._current_filter))
         await self.comm.set_state(IReady, ReadyState(ready=True))
 
@@ -90,7 +92,12 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
 
         log.info("Setting filter to %s at position %d...", filter_name, pos)
         await self._change_motion_status(MotionStatus.SLEWING)
-        self._driver.set_filter_pos(pos)
+        driver = self._driver
+
+        def _set() -> None:
+            driver.set_filter_pos(pos)
+
+        await self._run_blocking_or_raise(_set)
         self._current_filter = filter_name
         await self._change_motion_status(MotionStatus.POSITIONED)
         await self.comm.send_event(FilterChangedEvent(filter_name))
@@ -107,9 +114,9 @@ class FliFilterWheel(FliBaseMixin, Module, MotionStatusMixin, IFilters, IFitsHea
 
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
-    ) -> dict[str, tuple[Any, str]]:
+    ) -> dict[str, FitsHeaderEntry]:
         """Returns FITS header for the current status of this module."""
-        return {"FILTER": (self._current_filter, "Current filter")}
+        return {"FILTER": FitsHeaderEntry(self._current_filter, "Current filter")}
 
 
 __all__ = ["FliFilterWheel"]

{pyobs_fli-2.0.0.dev4 → pyobs_fli-2.0.0.dev6}/pyproject.toml

@@ -1,19 +1,19 @@
 [project]
 name = "pyobs-fli"
-version = "2.0.0.dev4"
+version = "2.0.0.dev6"
 description = "pyobs module for FLI cameras"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11,<3.14"
 license = "MIT"
 dependencies = [
-    "astropy>=7.0.1,<8",
+    "astropy>=7.0.1,<9",
     "numpy>=2.2.5,<3",
-    "pyobs-core>=2.0.0.dev6,<3",
+    "pyobs-core>=2.0.0.dev48,<3",
 ]
 
 [dependency-groups]
 dev = [
-    "black>=25.1.0,<26",
+    "black>=25.1.0,<27",
     "pre-commit>=4.2.0,<5",
     "ruff>=0.9.0",
     "pyrefly>=1.1.1",