pyobs-fli 2.0.0.dev11__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.dev11 → pyobs_fli-2.0.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-fli
-Version: 2.0.0.dev11
+Version: 2.0.0.dev12
 Summary: pyobs module for FLI cameras
 Author-Email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_fli-2.0.0.dev11 → 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,6 +48,7 @@ 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
 
@@ -57,24 +60,35 @@ class FliBaseMixin:
         # 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:
+    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:
@@ -83,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:

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

@@ -16,17 +16,28 @@ 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(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.
         """
         super().__init__(dev_type=DeviceType.FILTERWHEEL, motion_status_interfaces=["IFilters"], **kwargs)
 
@@ -34,6 +45,7 @@ class FliFilterWheel(Module, FliBaseMixin, MotionStatusMixin, IFilters, IFitsHea
             [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:
@@ -95,7 +107,23 @@ class FliFilterWheel(Module, FliBaseMixin, 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.dev11 → pyobs_fli-2.0.0.dev12}/pyproject.toml

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

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

@@ -73,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]
 
 
@@ -84,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.dev11 → pyobs_fli-2.0.0.dev12}/tests/test_flifilterwheel.py

@@ -61,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"
 
 
@@ -77,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"
 
 

{pyobs_fli-2.0.0.dev11 → pyobs_fli-2.0.0.dev12}/uv.lock

@@ -2366,7 +2366,7 @@ gui = [
 
 [[package]]
 name = "pyobs-fli"
-version = "2.0.0.dev11"
+version = "2.0.0.dev12"
 source = { editable = "." }
 dependencies = [
     { name = "astropy" },