pyobs-zwoeaf 2.0.0.dev7__tar.gz → 2.0.0.dev9__tar.gz

pyobs_zwoeaf-2.0.0.dev9/.readthedocs.yml

@@ -0,0 +1,17 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.11"
+  apt_packages:
+    - libudev-dev
+
+sphinx:
+  configuration: docs/source/conf.py
+
+python:
+  install:
+    - method: pip
+      path: .
+    - requirements: docs/requirements.txt

{pyobs_zwoeaf-2.0.0.dev7 → pyobs_zwoeaf-2.0.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-zwoeaf
-Version: 2.0.0.dev7
+Version: 2.0.0.dev9
 Summary: pyobs model for ZWO EAF focus motors
 Author-Email: Lennart Jonas Buhrke <l.buhrke@stud.uni-goettingen.de>, Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

pyobs_zwoeaf-2.0.0.dev9/docs/Makefile

@@ -0,0 +1,31 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = pyobs
+SOURCEDIR     = source
+BUILDDIR      = ../.doc-build
+
+#.EXPORT_ALL_VARIABLES:
+
+#PYTHONPATH:=../pyobs-core/:../pyobs-sbig/:../pyobs-fli:../pyobs-weather:../pyobs-archive:${PYTHONPATH}
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+html:
+	@$(SPHINXBUILD) -M html "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS)
+
+livehtml:
+	sphinx-autobuild -b html --watch ../src/pyobs_zwoeaf $(ALLSPHINXOPTS) "$(SOURCEDIR)/" "$(BUILDDIR)/html/"
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+

pyobs_zwoeaf-2.0.0.dev9/docs/make.bat

@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=pyobs
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

pyobs_zwoeaf-2.0.0.dev9/docs/requirements.txt

@@ -0,0 +1 @@
+sphinx-rtd-theme

pyobs_zwoeaf-2.0.0.dev9/docs/source/conf.py

@@ -0,0 +1,117 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/stable/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../../src"))
+
+
+# -- Project information -----------------------------------------------------
+
+project = "pyobs-zwoeaf"
+copyright = "2024, Tim-Oliver Husser"
+author = "Tim-Oliver Husser"
+
+# The short X.Y version
+# version = "0.16"
+# The full version, including alpha/beta/rc tags
+# release = "0.16.0"
+
+
+# -- General configuration ---------------------------------------------------
+
+add_module_names = False
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.githubpages",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.intersphinx",
+    #'sphinx_autodoc_typehints'
+]
+
+intersphinx_mapping = {"http://docs.python.org/3": None}
+
+# napoleon settings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = False
+napoleon_use_param = False
+napoleon_use_ivar = True
+
+# typehints
+# set_type_checking_flag = True
+# autodoc_typehints = "description"
+
+# show c'tor parameters in class only
+autoclass_content = "both"
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = ".rst"
+
+# The master toctree document.
+master_doc = "index"
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = "en"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path .
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# Be a little nitpicky
+nitpicky = True
+nitpick_ignore = []
+
+# intersphinx
+intersphinx_mapping = {
+    "pyobs": ("https://pyobs-core.readthedocs.io/en/latest/", None),
+}
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "sphinx_rtd_theme"
+html_theme_options = {
+    "collapse_navigation": False,
+    "sticky_navigation": True,
+    "navigation_depth": 4,
+    "display_version": False,
+    "logo_only": False,
+    "prev_next_buttons_location": "bottom",
+    "titles_only": False,
+    "style_nav_header_background": "#cccccc",
+}
+html_logo = "_static/pyobs.gif"

pyobs_zwoeaf-2.0.0.dev9/docs/source/index.rst

@@ -0,0 +1,35 @@
+pyobs-zwoeaf
+############
+
+This is a `pyobs <https://www.pyobs.org>`_ (`documentation <https://docs.pyobs.org>`_) module for the
+`ZWO Electronic Auto Focuser (EAF) <https://astronomy-imaging-camera.com/product/zwo-eaf>`_.
+
+
+Example configuration
+*********************
+
+This is an example configuration::
+
+    class: pyobs_zwoeaf.EAFFocuser
+    device_number: 0
+    max_steps: 60000
+    backlash: 0
+    direction: true
+    sound: true
+
+    # communication
+    comm:
+      jid: test@example.com
+      password: ***
+
+
+Available classes
+*****************
+
+There is one single class for the ZWO EAF.
+
+EAFFocuser
+==========
+.. autoclass:: pyobs_zwoeaf.EAFFocuser
+   :members:
+   :show-inheritance:

{pyobs_zwoeaf-2.0.0.dev7 → pyobs_zwoeaf-2.0.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-zwoeaf"
-version = "2.0.0.dev7"
+version = "2.0.0.dev9"
 description = "pyobs model for ZWO EAF focus motors"
 authors = [
     { name = "Lennart Jonas Buhrke", email = "l.buhrke@stud.uni-goettingen.de" },

pyobs_zwoeaf-2.0.0.dev9/src/pyobs_zwoeaf/eaffocuser.py

@@ -0,0 +1,246 @@
+import asyncio
+import logging
+import threading
+import time
+from collections.abc import Callable
+from typing import Any
+
+import pyobs.utils.exceptions as exc
+from pyobs.interfaces import IFocuser, IReady, ITemperatures
+from pyobs.interfaces.IFocuser import FocuserState
+from pyobs.interfaces.IReady import ReadyState
+from pyobs.interfaces.ITemperatures import SensorReading, TemperaturesState
+from pyobs.mixins import MotionStatusMixin
+from pyobs.modules import Module
+from pyobs.utils.enums import MotionStatus
+
+log = logging.getLogger(__name__)
+
+_STEP_TO_MM = 0.00242105263
+
+# the ZWO EAF SDK's calls are blocking and are made directly on the event loop thread (see
+# _run_blocking). If the focuser has gone unresponsive, they can hang indefinitely, so they're
+# bounded with a timeout rather than let a single dead connection freeze the whole module.
+_SDK_CALL_TIMEOUT = 5.0
+
+# set_focus()'s move-and-wait-until-done sequence legitimately takes longer than the other SDK
+# calls above, so it gets its own, more generous timeout.
+_MOVE_TIMEOUT = 60.0
+
+
+class EAFFocuser(Module, MotionStatusMixin, IFocuser, ITemperatures):
+    """A pyobs module for the ZWO EAF electronic auto focuser."""
+
+    __module__ = "pyobs_zwoeaf"
+
+    def __init__(
+        self,
+        device_number: int = 0,
+        max_steps: int = 60000,
+        backlash: int = 0,
+        direction: bool = True,
+        sound: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        Module.__init__(self, **kwargs)
+        MotionStatusMixin.__init__(self)
+
+        self._device_number = device_number
+        self._max_steps = max_steps
+        self._backlash = backlash
+        self._direction = direction
+        self._sound = sound
+        self._eaf: Any | None = None
+        self._focus_setpoint = 0.0
+        self._focus_offset = 0.0
+
+        self.add_background_task(self._poll_temperature)
+
+    @staticmethod
+    async def _run_blocking(
+        func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT
+    ) -> bool:
+        """Run a blocking EAF 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 open(self) -> None:
+        """Open module."""
+        await Module.open(self)
+
+        from .EAF_focuser import EAF  # type: ignore[import-untyped]
+
+        self._eaf = EAF()
+        eaf = self._eaf
+
+        result: list[tuple[bool, float, float]] = []
+
+        def _connect() -> None:
+            if not eaf.connect(self._device_number):
+                result.append((False, 0.0, 0.0))
+                return
+            eaf.setMaximalStep(self._max_steps)
+            eaf.setBacklash(self._backlash)
+            eaf.setDirection(self._direction)
+            eaf.setSound(self._sound)
+            result.append((True, eaf.getTemperature(), eaf.getPosition()))
+
+        if not await self._run_blocking(_connect):
+            raise TimeoutError(
+                f"Timed out connecting to EAF focuser after {_SDK_CALL_TIMEOUT}s."
+            )
+        connected, temperature, position = result[0]
+        if not connected:
+            raise ValueError(
+                "EAF focuser failed to connect. Is the device connected via USB? Correct device_number?"
+            )
+
+        log.info("Connected to EAF focuser, temperature: %.2f°C", temperature)
+
+        await MotionStatusMixin.open(self)
+        await self._change_motion_status(MotionStatus.IDLE)
+
+        self._focus_setpoint = position * _STEP_TO_MM
+        await self.comm.set_state(
+            IFocuser,
+            FocuserState(focus=self._focus_setpoint, focus_offset=self._focus_offset),
+        )
+        await self.comm.set_state(IReady, ReadyState(ready=True))
+
+    async def close(self) -> None:
+        """Close module."""
+        if self._eaf is not None:
+            eaf = self._eaf
+            self._eaf = None
+            if not await self._run_blocking(eaf.disconnect):
+                log.error(
+                    "Timed out disconnecting EAF focuser after %.1fs.",
+                    _SDK_CALL_TIMEOUT,
+                )
+        await Module.close(self)
+
+    async def init(self, **kwargs: Any) -> None:
+        pass
+
+    async def park(self, **kwargs: Any) -> None:
+        """Park focuser at position zero."""
+        await self.stop_motion()
+        await self.set_focus(0.0)
+
+    async def stop_motion(self, device: str | None = None, **kwargs: Any) -> None:
+        """Stop focuser motion."""
+        if self._eaf is not None:
+            if not await self._run_blocking(self._eaf.stop):
+                log.error(
+                    "Timed out stopping EAF focuser motion after %.1fs.",
+                    _SDK_CALL_TIMEOUT,
+                )
+        await self._change_motion_status(MotionStatus.IDLE)
+
+    async def set_focus(self, focus: float, **kwargs: Any) -> None:
+        """Move focuser to given position.
+
+        Args:
+            focus: New focus position in mm.
+
+        Raises:
+            MoveError: If focuser cannot be moved.
+        """
+        if self._eaf is None:
+            raise ValueError("Not connected.")
+        eaf = self._eaf
+
+        total_mm = focus + self._focus_offset
+        step = int(total_mm / _STEP_TO_MM)
+        log.info(
+            "Moving EAF to %.4f mm (offset %.4f mm, step %d)...",
+            focus,
+            self._focus_offset,
+            step,
+        )
+
+        await self._change_motion_status(MotionStatus.SLEWING)
+
+        result: list[bool] = []
+
+        def _move() -> None:
+            if not eaf.move(step):
+                result.append(False)
+                return
+            # run the whole "move, then poll until done" sequence as a single blocking call, so
+            # only one thread gets spawned per move rather than one per 0.5s poll (see _run_blocking)
+            while eaf.isMoving():
+                time.sleep(0.1)
+            result.append(True)
+
+        if not await self._run_blocking(_move, timeout=_MOVE_TIMEOUT):
+            await self._change_motion_status(MotionStatus.ERROR)
+            raise exc.MoveError(f"Timed out moving EAF motor after {_MOVE_TIMEOUT}s.")
+        if not result[0]:
+            await self._change_motion_status(MotionStatus.ERROR)
+            raise exc.MoveError("Could not move EAF motor.")
+
+        self._focus_setpoint = focus
+        await self._change_motion_status(MotionStatus.POSITIONED)
+        await self.comm.set_state(
+            IFocuser,
+            FocuserState(focus=self._focus_setpoint, focus_offset=self._focus_offset),
+        )
+
+    async def set_focus_offset(self, offset: float, **kwargs: Any) -> None:
+        """Set focus offset and re-apply.
+
+        Args:
+            offset: New focus offset in mm.
+
+        Raises:
+            MoveError: If focuser cannot be moved.
+        """
+        log.info("Setting focus offset to %.4f mm.", offset)
+        self._focus_offset = offset
+        await self.set_focus(self._focus_setpoint)
+
+    async def _poll_temperature(self) -> None:
+        """Background task: periodically reads EAF temperature."""
+        while True:
+            try:
+                if self._eaf is not None:
+                    eaf = self._eaf
+                    result: list[float] = []
+
+                    def _get_temp() -> None:
+                        result.append(eaf.getTemperature())
+
+                    if await self._run_blocking(_get_temp):
+                        await self.comm.set_state(
+                            ITemperatures,
+                            TemperaturesState(
+                                readings=[SensorReading(name="EAF", value=result[0])]
+                            ),
+                        )
+            except Exception:
+                pass
+            await asyncio.sleep(10)
+
+
+__all__ = ["EAFFocuser"]

{pyobs_zwoeaf-2.0.0.dev7 → pyobs_zwoeaf-2.0.0.dev9}/uv.lock

@@ -1357,7 +1357,7 @@ wheels = [
 
 [[package]]
 name = "pyobs-zwoeaf"
-version = "2.0.0.dev7"
+version = "2.0.0.dev9"
 source = { editable = "." }
 dependencies = [
     { name = "pyobs-core" },

pyobs_zwoeaf-2.0.0.dev7/DEVELOPMENT.md

@@ -1,337 +0,0 @@
-# pyobs 2.0 — Phase 5: External Hardware Modules
-
-This document covers the migration of this pyobs hardware module to the
-pyobs 2.0 API.
-
----
-
-## Step 0 — Branch main/master into 1.x for legacy support
-
-Before making any changes, preserve the current state as a legacy branch.
-First check which branch is the default — it may be `main` or `master`:
-
-```bash
-git remote show origin | grep "HEAD branch"
-```
-
-**If the default branch is `master`, rename it to `main` first:**
-
-```bash
-git checkout master
-git branch -m master main
-git push origin main
-git push origin --delete master
-# Update the default branch in GitHub repository settings to main
-```
-
-Then branch off for legacy support:
-
-```bash
-git checkout main
-git checkout -b 1.x
-git push origin 1.x
-```
-
-Create `develop` for all 2.0 work:
-
-```bash
-git checkout main
-git checkout -b develop
-git push origin develop
-```
-
-Set `develop` as the default branch in GitHub repository settings.
-
----
-
-## Step 1 — Add ruff, update tooling
-
-### pyproject.toml changes
-
-1. Bump `pyobs-core` to `>=2.0.0.dev1`.
-
-2. In `[dependency-groups] dev`: add `ruff>=0.9.0`, remove `flake8` and any
-   mypy stub packages (`pandas-stubs`, `pyside6-stubs`, etc.) — pyrefly
-   doesn't use `.pyi` stubs from PyPI.
-
-3. Add config sections (match pyobs-core develop exactly):
-
-```toml
-[tool.ruff]
-target-version = "py311"
-line-length = 120
-
-[tool.ruff.lint]
-select = ["E", "F", "W", "I", "UP", "G"]
-
-[tool.pyrefly]
-python-version = "3.11"
-```
-
-> **Note on the `G` rule**: it flags `log.info(f"...")` — all logging calls
-> must use `%`-style formatting: `log.info("value: %s", val)`.
-
-### .pre-commit-config.yaml
-
-Replace the flake8 hook with ruff:
-
-```yaml
-repos:
-  - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 25.1.0
-    hooks:
-      - id: black
-        language_version: python3.11
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.0
-    hooks:
-      - id: ruff
-```
-
-### Delete .flake8
-
-```bash
-rm .flake8
-```
-
-### Run once to fix existing issues
-
-```bash
-uv run ruff check --fix .
-```
-
----
-
-## Step 2 — Replace get_* with state and capabilities
-
-### Remove getter methods
-
-```python
-# BEFORE (pyobs 1.x)
-async def get_binning(self) -> tuple[int, int]:
-    return self._binning
-
-async def list_binnings(self) -> list[IBinning.State]:
-    return [IBinning.State(x=1, y=1), IBinning.State(x=2, y=2)]
-
-async def get_full_frame(self) -> IWindow.State:
-    return IWindow.State(x=0, y=0, width=self._width, height=self._height)
-```
-
-```python
-# AFTER (pyobs 2.0)
-# In open():
-await self.comm.set_capabilities(IWindow.Capabilities(
-    full_frame=IWindow.State(x=0, y=0, width=self._width, height=self._height)
-))
-await self.comm.set_capabilities(IBinning.Capabilities(
-    binnings=[IBinning.State(x=1, y=1), IBinning.State(x=2, y=2)]
-))
-# Initial states also in open():
-await self.comm.set_state(IWindow.State(x=0, y=0, width=self._width, height=self._height))
-await self.comm.set_state(IBinning.State(x=self._binning[0], y=self._binning[1]))
-# In set_binning():
-await self.comm.set_state(IBinning.State(x=x, y=y))
-```
-
-### Interface → change pattern
-
-| Old getter | New pattern |
-|---|---|
-| `get_full_frame()` | `set_capabilities(IWindow.Capabilities(full_frame=...))` in `open()` |
-| `get_window()` | remove — no equivalent; current window tracked in `_window` and published via `set_state(IWindow.State(...))` |
-| `list_binnings()` | `set_capabilities(IBinning.Capabilities(binnings=[...]))` in `open()` |
-| `list_image_formats()` | `set_capabilities(IImageFormat.Capabilities(image_formats=[...]))` in `open()` |
-| `get_binning()` | `set_state(IBinning.State(...))` in `set_binning()` + `open()` |
-| `get_exposure_status()` | `set_state(IExposure.State(...))` in `_change_exposure_status()` |
-| `get_exposure_time()` | `set_state(IExposureTime.State(...))` in `set_exposure_time()` + `open()` |
-| `get_image_type()` | `set_state(IImageType.State(...))` in `set_image_type()` + `open()` |
-| `get_filter()` | `set_state(IFilters.State(...))` in `set_filter()` + `open()` |
-| `list_filters()` | `set_capabilities(IFilters.Capabilities(filters=[...]))` in `open()` |
-| `get_focus()` | `set_state(IFocuser.State(...))` in `set_focus()` + `open()` |
-| `get_motion_status()` | handled by `MotionStatusMixin` — just call `_change_motion_status()` |
-| `is_ready()` | `set_state(IReady.State(ready=...))` in `open()` and when it changes |
-| `get_cooling()` | `set_state(ICooling.State(setpoint=..., power=..., enabled=...))` in `set_cooling()` and background task |
-| `get_temperatures()` | `set_state(ITemperatures.State(readings=[ITemperatures.Temperature(name=..., value=...)]))` in background polling task |
-| `get_gain()` / `get_offset()` | `set_state(IGain.State(gain=..., offset=...))` in `set_gain()`, `set_offset()` + `open()` |
-| `get_video()` | `set_capabilities(IVideo.Capabilities(url=...))` in `open()` |
-
-### ICooling and ITemperatures
-
-`ICooling` extends `ITemperatures` but they have separate `State` dataclasses.
-Both must be published independently:
-
-```python
-# temperatures (from background polling loop)
-await self.comm.set_state(
-    ITemperatures.State(readings=[ITemperatures.Temperature(name="CCD", value=temp)])
-)
-# cooling control state
-await self.comm.set_state(
-    ICooling.State(setpoint=self._setpoint, power=round(power_pct), enabled=True)
-)
-```
-
-`ICooling.State.power` is typed `int | None` — convert the raw PWM fraction
-(`raw / 255 * 100`) with `round()` before passing it.
-
-### __init__.py re-exports
-
-Ruff's `F401` rule requires explicit re-exports. Change:
-
-```python
-# before
-from .mymodule import MyClass
-```
-
-```python
-# after
-from .mymodule import MyClass as MyClass
-```
-
----
-
-## Step 3 — Add pyobs-independent GUI
-
-Each hardware module should have a standalone Qt GUI that works without pyobs
-running — useful for testing hardware directly (e.g. during commissioning).
-
-The pattern from **pyobs-qhyccd** (`pyobs_qhyccd/gui.py`) is the reference.
-It uses reusable widgets from `pyobs.utils.gui.*` and talks directly to the
-hardware driver without going through pyobs Comm.
-
-### Typical structure
-
-```python
-# mymodule/gui.py
-import asyncio
-import sys
-import qasync
-from PySide6 import QtWidgets
-from pyobs.utils.gui.camera import (
-    DataDisplayWidget, BinningWidget, ImageFormatWidget,
-    ExposureTimeWidget, ExposeWidget,
-)
-from .driver import MyDriver
-
-
-class MainWindow(QtWidgets.QMainWindow):
-    def __init__(self) -> None:
-        super().__init__()
-        self.driver = MyDriver()
-        self.driver.open()
-        # ... build UI from pyobs.utils.gui widgets ...
-
-    @qasync.asyncSlot()
-    async def _expose_clicked(self) -> None:
-        # ... call driver directly ...
-
-
-def main() -> None:
-    app = QtWidgets.QApplication(sys.argv)
-    asyncio.run(async_main(app), loop_factory=qasync.QEventLoop)
-
-
-if __name__ == "__main__":
-    main()
-```
-
-Register as a console script in `pyproject.toml`:
-
-```toml
-[project.scripts]
-mymodule-gui = "mymodule.gui:main"
-```
-
-### Available pyobs GUI widgets (`pyobs.utils.gui`)
-
-- `camera.DataDisplayWidget` — displays FITS images
-- `camera.BinningWidget` — binning selector
-- `camera.ImageFormatWidget` — INT8/INT16 selector
-- `camera.ExposureTimeWidget` — exposure time spinner
-- `camera.ExposeWidget` — expose/abort buttons with progress
-- `camera.windowingwidget.WindowingWidget` — ROI selector
-
----
-
-## Step 4 — Testing
-
-Each module should have a `test/` directory with a `local.yaml` config that
-uses `LocalComm` so it can be tested without an XMPP server:
-
-```yaml
-# test/local.yaml
-class: pyobs.modules.MultiModule
-
-vfs: &vfs
-  class: pyobs.vfs.VirtualFileSystem
-  roots:
-    cache:
-      class: pyobs.vfs.LocalFile
-      root: /tmp/pyobs-test/
-
-modules:
-  camera:  # or telescope, focuser, etc.
-    class: mymodule.MyCamera
-    name: camera
-    vfs: *vfs
-    comm:
-      class: pyobs.comm.local.LocalComm
-      name: camera
-
-  gui:
-    class: pyobs_gui.GUI
-    name: gui
-    vfs: *vfs
-    comm:
-      class: pyobs.comm.local.LocalComm
-      name: gui
-```
-
-Run with:
-```bash
-pyobs test/local.yaml
-```
-
----
-
-## Repo checklist
-
-For each external module repo, in order:
-
-- [ ] Branch `main` → `1.x` (legacy)
-- [ ] Create `develop` branch
-- [ ] Bump `pyobs-core` to `>=2.0.0.dev1` in `pyproject.toml`
-- [ ] Add `ruff>=0.9.0` to dev deps; remove `flake8` and mypy stub packages
-- [ ] Add `[tool.ruff]`, `[tool.ruff.lint]`, `[tool.pyrefly]` sections to `pyproject.toml`
-- [ ] Update `.pre-commit-config.yaml`: replace flake8 hook with ruff
-- [ ] Delete `.flake8`
-- [ ] Run `ruff check --fix .`
-- [ ] Fix re-exports in `__init__.py` (`Foo as Foo`)
-- [ ] Convert f-string log calls to `%`-style (`log.info("x: %s", x)`)
-- [ ] Remove all `get_*` / `list_*` / `is_ready` methods
-- [ ] Add `set_capabilities(...)` calls in `open()`
-- [ ] Add `set_state(...)` calls in `open()` (initial values) and wherever values change
-- [ ] Add standalone GUI in `<package>/gui.py`
-- [ ] Add `test/local.yaml`
-- [ ] Update `README.md` to mention pyobs 2.0 requirement
-
----
-
-## Key pyobs-core 2.0 APIs
-
-```python
-# In open() — publish static hardware info
-await self.comm.set_capabilities(IWindow.Capabilities(...))
-await self.comm.set_capabilities(IBinning.Capabilities(...))
-
-# In open() and wherever values change — publish live state
-await self.comm.set_state(IBinning.State(x=2, y=2))
-await self.comm.set_state(ICooling.State(setpoint=-20, power=80, enabled=True))
-
-# Presence — set by Module.set_state() automatically
-# No manual action needed
-
-# Reading remote state (e.g. telescope pointing for camera WCS)
-await self.comm.subscribe_state("telescope", IPointingRaDec, self._on_pointing)
-```

pyobs_zwoeaf-2.0.0.dev7/lib/lib/mac/libEAFFocuser.dylib

@@ -1 +0,0 @@
-libEAFFocuser.dylib.1.6

pyobs_zwoeaf-2.0.0.dev7/src/pyobs_zwoeaf/eaffocuser.py

@@ -1,148 +0,0 @@
-import asyncio
-import logging
-from typing import Any
-
-import pyobs.utils.exceptions as exc
-from pyobs.interfaces import IFocuser, IReady, ITemperatures
-from pyobs.interfaces.IFocuser import FocuserState
-from pyobs.interfaces.IReady import ReadyState
-from pyobs.interfaces.ITemperatures import SensorReading, TemperaturesState
-from pyobs.mixins import MotionStatusMixin
-from pyobs.modules import Module
-from pyobs.utils.enums import MotionStatus
-
-log = logging.getLogger(__name__)
-
-_STEP_TO_MM = 0.00242105263
-
-
-class EAFFocuser(Module, MotionStatusMixin, IFocuser, ITemperatures):
-    """A pyobs module for the ZWO EAF electronic auto focuser."""
-
-    __module__ = "pyobs_zwoeaf"
-
-    def __init__(
-        self,
-        device_number: int = 0,
-        max_steps: int = 60000,
-        backlash: int = 0,
-        direction: bool = True,
-        sound: bool = True,
-        **kwargs: Any,
-    ) -> None:
-        Module.__init__(self, **kwargs)
-        MotionStatusMixin.__init__(self)
-
-        self._device_number = device_number
-        self._max_steps = max_steps
-        self._backlash = backlash
-        self._direction = direction
-        self._sound = sound
-        self._eaf: Any | None = None
-        self._focus_setpoint = 0.0
-        self._focus_offset = 0.0
-
-        self.add_background_task(self._poll_temperature)
-
-    async def open(self) -> None:
-        """Open module."""
-        await Module.open(self)
-
-        from .EAF_focuser import EAF  # type: ignore[import-untyped]
-
-        self._eaf = EAF()
-        if not self._eaf.connect(self._device_number):
-            raise ValueError("EAF focuser failed to connect. Is the device connected via USB? Correct device_number?")
-
-        self._eaf.setMaximalStep(self._max_steps)
-        self._eaf.setBacklash(self._backlash)
-        self._eaf.setDirection(self._direction)
-        self._eaf.setSound(self._sound)
-
-        log.info("Connected to EAF focuser, temperature: %.2f°C", self._eaf.getTemperature())
-
-        await MotionStatusMixin.open(self)
-        await self._change_motion_status(MotionStatus.IDLE)
-
-        self._focus_setpoint = self._eaf.getPosition() * _STEP_TO_MM
-        await self.comm.set_state(IFocuser, FocuserState(focus=self._focus_setpoint, focus_offset=self._focus_offset))
-        await self.comm.set_state(IReady, ReadyState(ready=True))
-
-    async def close(self) -> None:
-        """Close module."""
-        if self._eaf is not None:
-            self._eaf.disconnect()
-            self._eaf = None
-        await Module.close(self)
-
-    async def init(self, **kwargs: Any) -> None:
-        pass
-
-    async def park(self, **kwargs: Any) -> None:
-        """Park focuser at position zero."""
-        await self.stop_motion()
-        await self.set_focus(0.0)
-
-    async def stop_motion(self, device: str | None = None, **kwargs: Any) -> None:
-        """Stop focuser motion."""
-        if self._eaf is not None:
-            self._eaf.stop()
-        await self._change_motion_status(MotionStatus.IDLE)
-
-    async def set_focus(self, focus: float, **kwargs: Any) -> None:
-        """Move focuser to given position.
-
-        Args:
-            focus: New focus position in mm.
-
-        Raises:
-            MoveError: If focuser cannot be moved.
-        """
-        if self._eaf is None:
-            raise ValueError("Not connected.")
-
-        total_mm = focus + self._focus_offset
-        step = int(total_mm / _STEP_TO_MM)
-        log.info("Moving EAF to %.4f mm (offset %.4f mm, step %d)...", focus, self._focus_offset, step)
-
-        await self._change_motion_status(MotionStatus.SLEWING)
-        if not self._eaf.move(step):
-            await self._change_motion_status(MotionStatus.ERROR)
-            raise exc.MoveError("Could not move EAF motor.")
-
-        while self._eaf.isMoving():
-            await asyncio.sleep(0.5)
-
-        self._focus_setpoint = focus
-        await self._change_motion_status(MotionStatus.POSITIONED)
-        await self.comm.set_state(IFocuser, FocuserState(focus=self._focus_setpoint, focus_offset=self._focus_offset))
-
-    async def set_focus_offset(self, offset: float, **kwargs: Any) -> None:
-        """Set focus offset and re-apply.
-
-        Args:
-            offset: New focus offset in mm.
-
-        Raises:
-            MoveError: If focuser cannot be moved.
-        """
-        log.info("Setting focus offset to %.4f mm.", offset)
-        self._focus_offset = offset
-        await self.set_focus(self._focus_setpoint)
-
-    async def _poll_temperature(self) -> None:
-        """Background task: periodically reads EAF temperature."""
-        while True:
-            try:
-                if self._eaf is not None:
-                    temp = self._eaf.getTemperature()
-                    await self.comm.set_state(
-                        ITemperatures,
-                        TemperaturesState(readings=[SensorReading(name="EAF", value=temp)]),
-                    )
-            except Exception:
-                pass
-            await asyncio.sleep(10)
-
-
-__all__ = ["EAFFocuser"]