pyobs-core 1.53.0__tar.gz → 2.0.0.dev1__tar.gz

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-core
-Version: 1.53.0
+Version: 2.0.0.dev1
 Summary: robotic telescope software
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/application.py

@@ -98,7 +98,7 @@ class Application:
                     super().__init__(identifier="pyobs", **kw)
 
                 def _format_record(self, record: logging.LogRecord) -> list[tuple[str, Any]]:
-                    pairs = super()._format_record(record)
+                    pairs: list[tuple[str, Any]] = super()._format_record(record)
                     pairs.append(("PYOBS_MODULE", getattr(record, "pyobs_module", "")))
                     return pairs
 

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/comm/comm.py

@@ -1,25 +1,25 @@
 from __future__ import annotations
 
 import asyncio
+import functools
 import inspect
 import logging
 from collections.abc import Callable, Coroutine
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, overload
 
 import pyobs.interfaces
 from pyobs.events import Event, LogEvent, ModuleClosedEvent
 from pyobs.interfaces import Interface
 
 from .commlogging import CommLoggingHandler
-from .proxy import Proxy
+from .proxy import Proxy, ProxyType, _ProxyContext
 
 if TYPE_CHECKING:
     from pyobs.modules import Module
 
-log = logging.getLogger(__name__)
-
+StateCallback = Callable[[Any], None]
 
-ProxyType = TypeVar("ProxyType")
+log = logging.getLogger(__name__)
 
 
 class Comm:
@@ -27,13 +27,13 @@ class Comm:
 
     __module__ = "pyobs.comm"
 
-    def __init__(self, cache_proxies: bool = True):
+    def __init__(self) -> None:
         """Creates a comm module."""
 
         self._proxies: dict[str, Proxy] = {}
+        self._state_subscriptions: dict[str, list[tuple[type[Interface], StateCallback]]] = {}
         self._module: Module | None = None
         self._log_queue: asyncio.Queue[LogEvent] = asyncio.Queue()
-        self._cache_proxies = cache_proxies
         self._logging_task: asyncio.Task[Any] | None = None
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
         self._closing = asyncio.Event()
@@ -117,7 +117,7 @@ class Comm:
             return None
 
         # if client doesn't exist or we disabled caching, fetch a new proxy
-        if client not in self._proxies or not self._cache_proxies:
+        if client not in self._proxies:
             # get interfaces
             try:
                 interfaces = await self.get_interfaces(client)
@@ -126,18 +126,20 @@ class Comm:
 
             # create new proxy
             proxy = Proxy(self, client, interfaces)
+
+            # subscribe to state
+            for interface in interfaces:
+                if getattr(interface, "state", None) is not None:
+                    await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
+
             self._proxies[client] = proxy
 
         # return proxy
         return self._proxies[client]
 
-    @overload
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType]) -> ProxyType: ...
-
-    @overload
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> Any: ...
-
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> Any | ProxyType:
+    async def _resolve_proxy(
+        self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
+    ) -> Any | ProxyType:
         """Returns object directly if it is of given type. Otherwise get proxy of client with given name and check type.
 
         If name_or_object is an object:
@@ -184,16 +186,41 @@ class Comm:
             # completely wrong...
             raise ValueError(f'Given parameter is neither a name nor an object of requested type "{obj_type}".')
 
-    async def safe_proxy(
+    async def _safe_resolve_proxy(
         self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
     ) -> Any | ProxyType | None:
         """Calls proxy() in a safe way and returns None instead of raising an exception."""
 
         try:
-            return await self.proxy(name_or_object, obj_type)
+            return await self._resolve_proxy(name_or_object, obj_type)
         except ValueError:
             return None
 
+    @overload
+    def proxy(self, name_or_object: str | object, obj_type: type[ProxyType]) -> _ProxyContext[ProxyType]: ...
+    @overload
+    def proxy(self, name_or_object: str | object, obj_type: None = None) -> _ProxyContext[Any]: ...
+
+    def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> _ProxyContext[Any]:
+        """Returns a context manager; use as `async with self.proxy(...) as x:`."""
+        return _ProxyContext(self._resolve_proxy(name_or_object, obj_type))
+
+    @overload
+    def safe_proxy(
+        self, name_or_object: str | object, obj_type: type[ProxyType]
+    ) -> _ProxyContext[ProxyType | None]: ...
+    @overload
+    def safe_proxy(self, name_or_object: str | object, obj_type: None = None) -> _ProxyContext[Any]: ...
+
+    def safe_proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> _ProxyContext[Any]:
+        """Same as proxy(), but yields None inside the block instead of raising."""
+        return _ProxyContext(self._safe_resolve_proxy(name_or_object, obj_type))
+
+    async def has_proxy(self, name_or_object: str | object, obj_type: type[Any] | None = None) -> bool:
+        """True if a proxy of the given type can currently be resolved. Doesn't keep a reference
+        to it, so doesn't need async with the way proxy()/safe_proxy() do."""
+        return await self._safe_resolve_proxy(name_or_object, obj_type) is not None
+
     async def _client_disconnected(self, event: Event, sender: str) -> bool:
         """Called when a client disconnects.
 
@@ -203,9 +230,15 @@ class Comm:
 
         """
 
-        # if a client disconnects, we remove its proxy
+        # if a client disconnects, clear its proxy state then evict it
         if sender in self._proxies:
+            self._proxies[sender].clear_state()
             del self._proxies[sender]
+
+        # tear down any state subscriptions held for that client
+        for interface, callback in self._state_subscriptions.pop(sender, []):
+            await self.unsubscribe_state(sender, interface, callback)
+
         return True
 
     @property
@@ -397,6 +430,67 @@ class Comm:
     ) -> None:
         pass
 
+    async def set_state(self, interface: type[Interface], state: Any) -> None:
+        """Publish state for this module.
+
+        Args:
+            interface: Interface type for the state.
+            state: State object to publish.
+        """
+        await self._set_state(interface, state)
+
+    async def _set_state(self, interface: type[Interface], state: Any) -> None:
+        pass
+
+    async def subscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        """Subscribe to state updates for a given module and interface.
+
+        Delivers the current value immediately on subscribe.
+
+        Args:
+            module: Name of remote module.
+            interface: Interface type to subscribe to.
+            callback: Called with state object on each update.
+        """
+        self._state_subscriptions.setdefault(module, []).append((interface, callback))
+        await self._subscribe_state(module, interface, callback)
+
+    async def _subscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        pass
+
+    async def unsubscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        """Unsubscribe from state updates.
+
+        Args:
+            module: Name of remote module.
+            interface: Interface type to unsubscribe from.
+            callback: Callback that was registered.
+        """
+        await self._unsubscribe_state(module, interface, callback)
+
+    async def _unsubscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        pass
+
     def _send_event_to_module(self, event: Event, from_client: str) -> None:
         """Send an event to all connected modules.
 

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/comm/proxy.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import inspect
 import types
-from typing import TYPE_CHECKING, Any, get_type_hints
+from collections.abc import Coroutine
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, get_type_hints
 
 from pyobs.interfaces import Interface
 from pyobs.utils.types import cast_bound_arguments_to_simple
@@ -10,6 +11,9 @@ from pyobs.utils.types import cast_bound_arguments_to_simple
 if TYPE_CHECKING:
     from pyobs.comm import Comm
 
+"""Class of a proxy."""
+ProxyType = TypeVar("ProxyType")
+
 
 class Proxy:
     """A proxy for remote pyobs modules."""
@@ -48,6 +52,9 @@ class Proxy:
         # create methods
         self._methods = self._create_methods()
 
+        # store state
+        self._state: dict[type[Interface], Any] = {}
+
     @property
     def name(self) -> str:
         """Name of the client."""
@@ -150,5 +157,35 @@ class Proxy:
 
         return inner
 
+    def update_state(self, interface: type[Interface], state: Any) -> None:
+        """Called by Comm whenever a new state arrives. Not intended to be called directly by module code."""
+        self._state[interface] = state
+
+    def clear_state(self) -> None:
+        """Clear all cached state. Called by Comm when the remote module disconnects."""
+        self._state.clear()
+
+    def state(self, interface: type[Interface]) -> Any | None:
+        """Latest known state for the given interface, or None if nothing has arrived yet."""
+        return self._state.get(interface)
+
+
+class _ProxyContext(Generic[ProxyType]):
+    """Returned by Comm.proxy() / Object.proxy() / Comm.safe_proxy(). Must be used as:
+    async with self.proxy("camera", ICooling) as camera:
+        ...
+    """
+
+    def __init__(self, coro: Coroutine[Any, Any, ProxyType]) -> None:
+        self._coro = coro
+
+    async def __aenter__(self) -> ProxyType:
+        return await self._coro
+
+    async def __aexit__(self, *exc_info: Any) -> None:
+        # intentionally a no-op: the underlying Proxy is owned and cached
+        # by Comm, not by this block, and stays alive for other callers.
+        pass
+
 
 __all__ = ["Proxy"]

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/comm/xmpp/xmppclient.py

@@ -29,7 +29,6 @@ class XmppClient(slixmpp.ClientXMPP):
 
         # stuff
         self._connect_event = asyncio.Event()
-        self._logs_node = "logs"
         self._auth_event = asyncio.Event()
         self._auth_success = False
         self._jid_conflict = False

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/comm/xmpp/xmppcomm.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import functools
 import json
 import logging
@@ -9,12 +10,15 @@ import ssl
 import time
 import xml.sax.saxutils
 from collections.abc import Callable, Coroutine
-from typing import TYPE_CHECKING, Any
+from enum import StrEnum
+from typing import TYPE_CHECKING, Annotated, Any, get_args, get_origin, get_type_hints
 
 import slixmpp
 import slixmpp.exceptions
 from slixmpp import ElementBase
 from slixmpp.xmlstream import ET
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import MatchXMLMask
 
 from pyobs.comm import Comm
 from pyobs.events import Event, LogEvent, ModuleClosedEvent, ModuleOpenedEvent
@@ -36,6 +40,11 @@ class EventStanza(ElementBase):
     namespace = "pyobs:event"
 
 
+class StateStanza(ElementBase):
+    name = "state"
+    namespace = "pyobs:state"
+
+
 class XmppComm(Comm):
     """A Comm class using XMPP.
 
@@ -157,6 +166,10 @@ class XmppComm(Comm):
         self._xmpp: XmppClient | None = None
         self._rpc: RPC | None = None
 
+        # pubsub for states
+        self._pubsub_service = f"pubsub.{self._domain}"
+        self._state_node_handlers: dict[str, tuple[type[Interface], list[Callable[[Any], None]]]] = {}
+
     def _set_module(self, module: Module) -> None:
         """Called, when the module connected to this Comm changes.
 
@@ -186,7 +199,22 @@ class XmppComm(Comm):
         self._xmpp = XmppClient(self._jid, self._password)
 
         # self._xmpp = slixmpp.ClientXMPP(self._jid, password)
-        self._xmpp.add_event_handler("pubsub_publish", self._handle_event)
+        # Register directly with an XML mask rather than via pubsub_publish.
+        # slixmpp's StanzaPath matcher requires plugins to be lazily loaded
+        # before matching — for live notifications (not triggered by an IQ)
+        # this never happens, so pubsub_publish is never fired. MatchXMLMask
+        # works on raw XML and fires reliably for every pubsub notification.
+        self._xmpp.register_handler(
+            Callback(
+                "pyobs pubsub event",
+                MatchXMLMask(
+                    '<message xmlns="jabber:client">'
+                    '<event xmlns="http://jabber.org/protocol/pubsub#event">'
+                    "<items /></event></message>"
+                ),
+                self._handle_event_sync,
+            )
+        )
         self._xmpp.add_event_handler("got_online", self._got_online)
         self._xmpp.add_event_handler("got_offline", self._got_offline)
         self._xmpp.add_event_handler("disconnected", self._disconnected)
@@ -421,8 +449,11 @@ class XmppComm(Comm):
             log.debug("Module %s does not seem to implement IModule, ignoring.", module)
             return
 
-        # store interfaces
-        self._interface_cache[jid].set_result(self._interface_names_to_classes(interface_names))
+        # store interfaces — guard against a second _got_online for the same JID
+        # (ejabberd may send multiple presence stanzas) racing against the first
+        future = self._interface_cache.get(jid)
+        if future is not None and not future.done():
+            future.set_result(self._interface_names_to_classes(interface_names))
 
         # append to list
         if jid not in self._online_clients:
@@ -533,6 +564,14 @@ class XmppComm(Comm):
         await self._safe_send(self.client["xep_0115"].update_caps)
         self.client.send_presence()
 
+    def _handle_event_sync(self, msg: Any) -> None:
+        """Synchronous entry point for the MatchXMLMask Callback.
+
+        Callback handlers must be synchronous; this creates an asyncio task
+        so that _handle_event can await safely.
+        """
+        asyncio.create_task(self._handle_event(msg))
+
     async def _handle_event(self, msg: Any) -> None:
         """Handles an event.
 
@@ -540,6 +579,26 @@ class XmppComm(Comm):
             msg: Received XMPP message.
         """
 
+        node = msg["pubsub_event"]["items"]["node"]
+
+        # State-node notifications: dispatch to handler if registered, then return.
+        # map_node_event() cannot be used here because the XEP-0060 plugin iterates
+        # Items.iterables (empty) to fire mapped events, so live notifications are
+        # silently dropped. _handle_event (pubsub_publish) fires reliably for all nodes.
+        if node.startswith("pyobs:state:"):
+            if node in self._state_node_handlers:
+                if len(msg.xml.findall("{urn:sleekxmpp:delay}delay")) == 0:
+                    interface, callbacks = self._state_node_handlers[node]
+                    payload = msg["pubsub_event"]["items"]["item"]["payload"]
+                    if payload is not None:
+                        state_obj = self._xml_to_dataclass(payload, interface.state)
+                        for callback in callbacks:
+                            callback(state_obj)
+                    # If payload is None it's a retract notification for the old
+                    # max_items:1 slot — the matching publish notification (with
+                    # payload) arrives in the next pubsub_publish event.
+            return
+
         # get body, unescape it, parse it
         # node = msg['pubsub_event'][items']['node']
         body = json.loads(xml.sax.saxutils.unescape(msg["pubsub_event"]["items"]["item"]["payload"].text))
@@ -629,5 +688,127 @@ class XmppComm(Comm):
         else:
             return False, value
 
+    @staticmethod
+    def _state_namespace(interface: type[Interface]) -> str:
+        return f"urn:pyobs:state:{interface.__name__}:{interface.version}"
+
+    @staticmethod
+    def _state_node(module: str, interface: type[Interface]) -> str:
+        return f"pyobs:state:{module}:{interface.__name__}:{interface.version}"
+
+    @staticmethod
+    def _dataclass_to_xml(state: Any, namespace: str) -> ET.Element:
+        root = ET.Element(f"{{{namespace}}}state")
+        for f in dataclasses.fields(state):
+            value = getattr(state, f.name)
+            # Use ET.Element + append (not SubElement) so children stay in the
+            # empty namespace and elem.find("fieldname") works on the receiving side.
+            child = ET.Element(f.name)
+            if isinstance(value, bool):
+                child.text = "true" if value else "false"
+            elif isinstance(value, StrEnum):
+                child.text = value.value
+            else:
+                child.text = str(value)
+            root.append(child)
+        return root
+
+    @staticmethod
+    def _xml_to_dataclass(elem: ET.Element, state_cls: type) -> Any:
+        hints = get_type_hints(state_cls, include_extras=True)
+        # Extract namespace from root element tag, e.g. "{urn:pyobs:state:ICooling:1}state"
+        # Children may arrive namespaced (after ejabberd round-trip) or plain (locally),
+        # so try both forms.
+        ns = ""
+        if elem.tag.startswith("{"):
+            ns = elem.tag[1 : elem.tag.index("}")]
+        kwargs = {}
+        for f in dataclasses.fields(state_cls):
+            # Try namespaced lookup first, then plain
+            child = elem.find(f"{{{ns}}}{f.name}") if ns else None
+            if child is None:
+                child = elem.find(f.name)
+            if child is None or child.text is None:
+                continue
+            field_type = hints[f.name]
+            # unwrap Annotated[T, ...] → T for type dispatch
+            if get_origin(field_type) is Annotated:
+                field_type = get_args(field_type)[0]
+            if field_type is bool:
+                kwargs[f.name] = child.text == "true"
+            elif field_type is float:
+                kwargs[f.name] = float(child.text)
+            elif field_type is int:
+                kwargs[f.name] = int(child.text)
+            elif isinstance(field_type, type) and issubclass(field_type, StrEnum):
+                kwargs[f.name] = field_type(child.text)
+            else:
+                kwargs[f.name] = child.text
+        return state_cls(**kwargs)
+
+    async def _fetch_and_dispatch_state(
+        self, node: str, interface: type[Interface], callback: Callable[[Any], None]
+    ) -> None:
+        """Fetch the current item for *node* and dispatch it to *callback*.
+
+        Called when a live notification arrives without a payload — either a
+        retract stanza or a node whose deliver_payloads flag is off.
+        """
+        try:
+            result = await self._safe_send(self.client["xep_0060"].get_items, self._pubsub_service, node, max_items=1)
+            item_list = result["pubsub"]["items"]["items"]
+            if item_list:
+                callback(self._xml_to_dataclass(item_list[0]["payload"], interface.state))
+        except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+            pass
+
+    async def _set_state(self, interface: type[Interface], state: Any) -> None:
+        node = self._state_node(self._module.name, interface)
+        stanza = StateStanza()
+        stanza.xml = self._dataclass_to_xml(state, self._state_namespace(interface))
+        await self._safe_send(self.client["xep_0060"].publish, self._pubsub_service, node, payload=stanza)
+
+    async def _subscribe_state(self, module: str, interface: type[Interface], callback: Callable[[Any], None]) -> None:
+        node = self._state_node(module, interface)
+        if node in self._state_node_handlers:
+            # Node already subscribed — just add the callback
+            self._state_node_handlers[node][1].append(callback)
+        else:
+            self._state_node_handlers[node] = (interface, [callback])
+            await self._safe_send(self.client["xep_0060"].subscribe, self._pubsub_service, node)
+
+        # "deliver the current value immediately on subscribe" -- hard requirement above
+        try:
+            result = await self._safe_send(self.client["xep_0060"].get_items, self._pubsub_service, node, max_items=1)
+            # result["pubsub"]["items"]["items"] uses plugin_multi_attrib to get
+            # the list of Item stanzas; item["payload"] returns the XML element
+            # via Item.get_payload(). Integer indexing items[0] is wrong here —
+            # it calls ElementBase.__getitem__("0") which returns a string.
+            item_list = result["pubsub"]["items"]["items"]
+            if item_list:
+                state_obj = self._xml_to_dataclass(item_list[0]["payload"], interface.state)
+                for cb in self._state_node_handlers.get(node, (None, []))[1]:
+                    cb(state_obj)
+        except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+            pass  # node exists but nothing published yet
+
+    async def _unsubscribe_state(
+        self, module: str, interface: type[Interface], callback: Callable[[Any], None]
+    ) -> None:
+        node = self._state_node(module, interface)
+        if node in self._state_node_handlers:
+            _, callbacks = self._state_node_handlers[node]
+            try:
+                callbacks.remove(callback)
+            except ValueError:
+                pass
+            if not callbacks:
+                # Last subscriber — unsubscribe from ejabberd and remove handler
+                del self._state_node_handlers[node]
+                try:
+                    await self._safe_send(self.client["xep_0060"].unsubscribe, self._pubsub_service, node)
+                except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+                    pass  # already gone server-side
+
 
 __all__ = ["XmppComm"]

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/events/event.py

@@ -13,7 +13,8 @@ class Event:
     """Base class for all events."""
 
     __module__ = "pyobs.events"
-    local = False
+    local: bool = False
+    version: int = 1
 
     def __init__(self, **kwargs: Any):
         self.uuid = str(uuid.uuid4())

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/images/processors/modules/getfitsheaders.py

@@ -101,11 +101,9 @@ class GetFitsHeaders(ImageProcessor):
         # loop all modules
         requests: list[Task[Any]] = []
         for sender in self._senders:
-            # get proxy
-            proxy = await self.proxy(sender, IFitsHeaderBefore)
-
             # request headers
-            requests.append(asyncio.create_task(proxy.get_fits_header_before(self._namespace)))
+            async with self.proxy(sender, IFitsHeaderBefore) as proxy:
+                requests.append(asyncio.create_task(proxy.get_fits_header_before(self._namespace)))
 
         # copy image
         out = image.copy()

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/images/processors/offsets/spilled_light.py

@@ -299,9 +299,9 @@ class SpilledLightGuiding(Offsets):
         return image
 
     async def _load_fibre_information(self) -> None:
-        fibers = await self.comm.proxy(self._fibers, IMultiFiber)
-        self._fibre_position = await fibers.get_pixel_position()
-        self._inner_radius = await fibers.get_radius()
+        async with self.comm.proxy(self._fibers, IMultiFiber) as proxy:
+            self._fibre_position = await proxy.get_pixel_position()
+            self._inner_radius = await proxy.get_radius()
 
     async def _correct_for_binning(self, binning: int) -> None:
         self._fibre_position = (self._fibre_position[0] / binning, self._fibre_position[1] / binning)

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/interfaces/IAutoFocus.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
-from typing import Any
+from typing import Annotated, Any
 
+from ..utils.enums import Unit
 from .IAbortable import IAbortable
 
 
@@ -12,7 +13,9 @@ class IAutoFocus(IAbortable, metaclass=ABCMeta):
     __module__ = "pyobs.interfaces"
 
     @abstractmethod
-    async def auto_focus(self, count: int, step: float, exposure_time: float, **kwargs: Any) -> tuple[float, float]:
+    async def auto_focus(
+        self, count: int, step: float, exposure_time: Annotated[float, Unit.SECONDS], **kwargs: Any
+    ) -> tuple[float, float]:
         """Perform an auto-focus series.
 
         This method performs an auto-focus series with "count" images on each side of the initial guess and the given

{pyobs_core-1.53.0 → pyobs_core-2.0.0.dev1}/pyobs/interfaces/ICooling.py

@@ -1,15 +1,25 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
-from typing import Any
+from dataclasses import dataclass
+from typing import Annotated, Any
 
+from ..utils.enums import Unit
 from .ITemperatures import ITemperatures
 
 
+@dataclass
+class CoolingState:
+    setpoint: Annotated[float, Unit.CELSIUS] | None
+    power: Annotated[int, Unit.PERCENT] | None
+    enabled: bool
+
+
 class ICooling(ITemperatures, metaclass=ABCMeta):
     """The module can control the cooling of a device."""
 
     __module__ = "pyobs.interfaces"
+    state = CoolingState
 
     @abstractmethod
     async def get_cooling(self, **kwargs: Any) -> tuple[bool, float, float]:
@@ -24,7 +34,7 @@ class ICooling(ITemperatures, metaclass=ABCMeta):
         ...
 
     @abstractmethod
-    async def set_cooling(self, enabled: bool, setpoint: float, **kwargs: Any) -> None:
+    async def set_cooling(self, enabled: bool, setpoint: Annotated[float, Unit.CELSIUS], **kwargs: Any) -> None:
         """Enables/disables cooling and sets setpoint.
 
         Args: