pyobs-core 2.0.0.dev3__py3-none-any.whl → 2.0.0.dev5__py3-none-any.whl

pyobs/comm/comm.py

@@ -4,7 +4,6 @@ import asyncio
 import functools
 import inspect
 import logging
-import sys
 from collections.abc import Callable, Coroutine
 from typing import TYPE_CHECKING, Any, overload
 
@@ -132,12 +131,20 @@ class Comm:
             except IndexError:
                 return None
 
+            # collect capabilities (fixed at proxy construction time)
+            capabilities: dict[type[Interface], Any] = {}
+            for interface in interfaces:
+                if interface.capabilities is not None:
+                    cap = await self._get_capabilities(client, interface)
+                    if cap is not None:
+                        capabilities[interface] = cap
+
             # create new proxy
-            proxy = Proxy(self, client, interfaces)
+            proxy = Proxy(self, client, interfaces, capabilities)
 
             # subscribe to state
             for interface in interfaces:
-                if getattr(interface, "State", None) is not None:
+                if interface.state is not None:
                     await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
 
             self._proxies[client] = proxy
@@ -438,40 +445,29 @@ class Comm:
     ) -> None:
         pass
 
-    @staticmethod
-    def _interface_from_state(state_cls: type) -> type:
-        outer_name = state_cls.__qualname__.rsplit(".", 1)[0]
-        return getattr(sys.modules[state_cls.__module__], outer_name)
-
-    async def set_state(self, state: Any) -> None:
+    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.
         """
-        interface = Comm._interface_from_state(type(state))
         await self._set_state(interface, state)
 
     async def _set_state(self, interface: type[Interface], state: Any) -> None:
         pass
 
-    @staticmethod
-    def _interface_from_capabilities(caps_cls: type) -> type:
-        outer_name = caps_cls.__qualname__.rsplit(".", 1)[0]
-        return getattr(sys.modules[caps_cls.__module__], outer_name)
-
-    async def set_capabilities(self, capabilities: Any) -> None:
+    async def set_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
         """Publish capabilities for this module.
 
-        Called by Module.open() for each interface that defines a Capabilities
+        Called by Module.open() for each interface that defines a capabilities
         dataclass. Not intended to be called directly by module authors after
         that point — capabilities are fixed for the module lifetime.
 
         Args:
+            interface: Interface type the capabilities belong to.
             capabilities: Capabilities dataclass instance.
         """
-        interface = Comm._interface_from_capabilities(type(capabilities))
         await self._set_capabilities(interface, capabilities)
 
     async def _set_capabilities(self, interface: type[Interface], capabilities: Any) -> None:

pyobs/comm/local/localcomm.py

@@ -120,7 +120,7 @@ class LocalComm(Comm):
 
     async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
         """Fetch capabilities from a remote module."""
-        if not hasattr(interface, "Capabilities"):
+        if interface.capabilities is None:
             return None
         try:
             remote = self._network.get_client(module)

pyobs/comm/proxy.py

@@ -21,13 +21,20 @@ class Proxy:
 
     __module__ = "pyobs.comm"
 
-    def __init__(self, comm: Comm, client: str, interfaces: list[type[Interface]]):
+    def __init__(
+        self,
+        comm: Comm,
+        client: str,
+        interfaces: list[type[Interface]],
+        capabilities: dict[type[Interface], Any] | None = None,
+    ):
         """Creates a new proxy.
 
         Args:
             comm: Comm object to use for connection.
             client: Name of client to connect to.
             interfaces: List of interfaces supported by client.
+            capabilities: Pre-populated capabilities dict, keyed by interface type.
         """
 
         # set client and interfaces
@@ -53,8 +60,9 @@ class Proxy:
         # create methods
         self._methods = self._create_methods()
 
-        # store state
+        # store state and capabilities
         self._state: dict[type[Interface], Any] = {}
+        self._capabilities: dict[type[Interface], Any] = capabilities if capabilities is not None else {}
 
     @property
     def name(self) -> str:
@@ -170,6 +178,10 @@ class Proxy:
         """Latest known state for the given interface, or None if nothing has arrived yet."""
         return self._state.get(interface)
 
+    def capabilities(self, interface: type[Interface]) -> Any | None:
+        """Capabilities for the given interface, populated once at Proxy construction."""
+        return self._capabilities.get(interface)
+
     async def wait_for_state(
         self,
         interface: type[Interface],

pyobs/comm/xmpp/xmppcomm.py

@@ -658,7 +658,7 @@ class XmppComm(Comm):
                     item_xml = items_xml.find(f"{{{pubsub_ns}}}item")
                     payload = list(item_xml)[0] if item_xml is not None and len(item_xml) > 0 else None
                     if payload is not None:
-                        state_obj = _xml_to_dataclass(payload, interface.State)
+                        state_obj = _xml_to_dataclass(payload, interface.state)
                         for callback in callbacks:
                             callback(state_obj)
         else:
@@ -786,7 +786,7 @@ class XmppComm(Comm):
             item_xml = items_xml.find(f"{{{pubsub_ns}}}item") if items_xml is not None else None
             payload = list(item_xml)[0] if item_xml is not None and len(item_xml) > 0 else None
             if payload is not None:
-                callback(_xml_to_dataclass(payload, interface.State))
+                callback(_xml_to_dataclass(payload, interface.state))
         except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
             pass
 
@@ -828,7 +828,7 @@ class XmppComm(Comm):
 
     async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
         """Fetch and deserialize capabilities for a remote module's interface."""
-        if not hasattr(interface, "Capabilities"):
+        if interface.capabilities is None:
             return None
         # Use full JID (with resource) if we know it — bare JID may not route correctly
         full_jid = next(
@@ -848,7 +848,7 @@ class XmppComm(Comm):
             for elem in child:
                 tag = elem.tag.split("}")[-1]
                 if tag == "capabilities" and f"{{{ns}}}" in elem.tag:
-                    return _xml_to_dataclass(elem, interface.Capabilities)
+                    return _xml_to_dataclass(elem, interface.capabilities)
         return None
 
     async def _set_presence(self, state: ModuleState, error_string: str = "") -> None:
@@ -902,7 +902,7 @@ class XmppComm(Comm):
             payload = list(item_xml)[0] if item_xml is not None and len(item_xml) > 0 else None
             if payload is not None and node in self._state_node_handlers:
                 _, callbacks = self._state_node_handlers[node]
-                state_obj = _xml_to_dataclass(payload, interface.State)
+                state_obj = _xml_to_dataclass(payload, interface.state)
                 for cb in callbacks:
                     cb(state_obj)
         except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):

pyobs/interfaces/IBinning.py

@@ -8,20 +8,25 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class BinningState:
+    x: int
+    y: int
+    time: Time = field(default_factory=Time.now)
+
+
+@dataclass
+class BinningCapabilities:
+    binnings: list[BinningState] = field(default_factory=list)
+
+
 class IBinning(Interface, metaclass=ABCMeta):
     """The camera supports binning, to be used together with :class:`~pyobs.interfaces.ICamera`."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        x: int
-        y: int
-        time: Time = field(default_factory=Time.now)
-
-    @dataclass
-    class Capabilities:
-        binnings: list[IBinning.State] = field(default_factory=list)
+    state = BinningState
+    capabilities = BinningCapabilities
 
     @abstractmethod
     async def set_binning(self, x: int, y: int, **kwargs: Any) -> None:
@@ -37,4 +42,4 @@ class IBinning(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IBinning"]
+__all__ = ["IBinning", "BinningState", "BinningCapabilities"]

pyobs/interfaces/IConfig.py

@@ -7,16 +7,17 @@ from typing import Any
 from .interface import Interface
 
 
+@dataclass
+class ConfigCapabilities:
+    caps: dict[str, tuple[bool, bool, bool]] = field(default_factory=dict)
+
+
 class IConfig(Interface, metaclass=ABCMeta):
     """The module allows access to some of its configuration options."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class Capabilities:
-        readable: list[str] = field(default_factory=list)
-        writable: list[str] = field(default_factory=list)
-        options: dict[str, list[str]] = field(default_factory=dict)
+    capabilities = ConfigCapabilities
 
     @abstractmethod
     async def get_config_value(self, name: str, **kwargs: Any) -> Any:
@@ -47,4 +48,4 @@ class IConfig(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IConfig"]
+__all__ = ["IConfig", "ConfigCapabilities"]

pyobs/interfaces/ICooling.py

@@ -9,17 +9,20 @@ from ..utils.time import Time
 from .ITemperatures import ITemperatures
 
 
+@dataclass
+class CoolingState:
+    setpoint: Annotated[float, Unit.CELSIUS] | None
+    power: Annotated[int, Unit.PERCENT] | None
+    enabled: bool
+    time: Time = field(default_factory=Time.now)
+
+
 class ICooling(ITemperatures, metaclass=ABCMeta):
     """The module can control the cooling of a device."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        setpoint: Annotated[float, Unit.CELSIUS] | None
-        power: Annotated[int, Unit.PERCENT] | None
-        enabled: bool
-        time: Time = field(default_factory=Time.now)
+    state = CoolingState
 
     @abstractmethod
     async def set_cooling(self, enabled: bool, setpoint: Annotated[float, Unit.CELSIUS], **kwargs: Any) -> None:
@@ -35,4 +38,4 @@ class ICooling(ITemperatures, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["ICooling"]
+__all__ = ["ICooling", "CoolingState"]

pyobs/interfaces/IExposure.py

@@ -10,17 +10,20 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class ExposureState:
+    status: ExposureStatus
+    progress: Annotated[float, Unit.PERCENT]
+    exposure_time_left: Annotated[float, Unit.SECONDS] = 0.0
+    time: Time = field(default_factory=Time.now)
+
+
 class IExposure(Interface, metaclass=ABCMeta):
     """The module controls a camera."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        status: ExposureStatus
-        progress: Annotated[float, Unit.PERCENT]
-        exposure_time_left: Annotated[float, Unit.SECONDS] = 0.0
-        time: Time = field(default_factory=Time.now)
+    state = ExposureState
 
 
-__all__ = ["IExposure"]
+__all__ = ["IExposure", "ExposureState"]

pyobs/interfaces/IExposureTime.py

@@ -9,15 +9,18 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class ExposureTimeState:
+    exposure_time: Annotated[float, Unit.SECONDS]
+    time: Time = field(default_factory=Time.now)
+
+
 class IExposureTime(Interface, metaclass=ABCMeta):
     """The camera supports exposure times, to be used together with :class:`~pyobs.interfaces.ICamera`."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        exposure_time: Annotated[float, Unit.SECONDS]
-        time: Time = field(default_factory=Time.now)
+    state = ExposureTimeState
 
     @abstractmethod
     async def set_exposure_time(self, exposure_time: Annotated[float, Unit.SECONDS], **kwargs: Any) -> None:
@@ -32,4 +35,4 @@ class IExposureTime(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IExposureTime"]
+__all__ = ["IExposureTime", "ExposureTimeState"]

pyobs/interfaces/IFilters.py

@@ -8,19 +8,24 @@ from ..utils.time import Time
 from .IMotion import IMotion
 
 
+@dataclass
+class FilterState:
+    filter: str
+    time: Time = field(default_factory=Time.now)
+
+
+@dataclass
+class FiltersCapabilities:
+    filters: list[str] = field(default_factory=list)
+
+
 class IFilters(IMotion, metaclass=ABCMeta):
     """The module can change filters in a device."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        filter: str
-        time: Time = field(default_factory=Time.now)
-
-    @dataclass
-    class Capabilities:
-        filters: list[str] = field(default_factory=list)
+    state = FilterState
+    capabilities = FiltersCapabilities
 
     @abstractmethod
     async def set_filter(self, filter_name: str, **kwargs: Any) -> None:
@@ -36,4 +41,4 @@ class IFilters(IMotion, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IFilters"]
+__all__ = ["IFilters", "FilterState", "FiltersCapabilities"]

pyobs/interfaces/IFocuser.py

@@ -8,16 +8,19 @@ from ..utils.time import Time
 from .IMotion import IMotion
 
 
+@dataclass
+class FocuserState:
+    focus: float
+    focus_offset: float
+    time: Time = field(default_factory=Time.now)
+
+
 class IFocuser(IMotion, metaclass=ABCMeta):
     """The module is a focusing device."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        focus: float
-        focus_offset: float
-        time: Time = field(default_factory=Time.now)
+    state = FocuserState
 
     @abstractmethod
     async def set_focus(self, focus: float, **kwargs: Any) -> None:
@@ -46,4 +49,4 @@ class IFocuser(IMotion, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IFocuser"]
+__all__ = ["IFocuser", "FocuserState"]

pyobs/interfaces/IGain.py

@@ -8,16 +8,19 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class GainState:
+    gain: float
+    offset: float
+    time: Time = field(default_factory=Time.now)
+
+
 class IGain(Interface, metaclass=ABCMeta):
     """The camera supports setting of gain, to be used together with :class:`~pyobs.interfaces.ICamera`."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        gain: float
-        offset: float
-        time: Time = field(default_factory=Time.now)
+    state = GainState
 
     @abstractmethod
     async def set_gain(self, gain: float, **kwargs: Any) -> None:
@@ -44,4 +47,4 @@ class IGain(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IGain"]
+__all__ = ["IGain", "GainState"]

pyobs/interfaces/IImageFormat.py

@@ -10,19 +10,24 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class ImageFormatState:
+    image_format: ImageFormat
+    time: Time = field(default_factory=Time.now)
+
+
+@dataclass
+class ImageFormatCapabilities:
+    image_formats: list[str] = field(default_factory=list)
+
+
 class IImageFormat(Interface, metaclass=ABCMeta):
     """The module supports different image formats (e.g. INT16, FLOAT32), mainly used by cameras."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        image_format: ImageFormat
-        time: Time = field(default_factory=Time.now)
-
-    @dataclass
-    class Capabilities:
-        image_formats: list[str] = field(default_factory=list)
+    state = ImageFormatState
+    capabilities = ImageFormatCapabilities
 
     @abstractmethod
     async def set_image_format(self, fmt: ImageFormat, **kwargs: Any) -> None:
@@ -37,4 +42,4 @@ class IImageFormat(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IImageFormat"]
+__all__ = ["IImageFormat", "ImageFormatState", "ImageFormatCapabilities"]

pyobs/interfaces/IImageType.py

@@ -10,15 +10,18 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class ImageTypeState:
+    image_type: ImageType
+    time: Time = field(default_factory=Time.now)
+
+
 class IImageType(Interface, metaclass=ABCMeta):
     """The module supports different image types (e.g. object, bias, dark, etc), mainly used by cameras."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class State:
-        image_type: ImageType
-        time: Time = field(default_factory=Time.now)
+    state = ImageTypeState
 
     @abstractmethod
     async def set_image_type(self, image_type: ImageType, **kwargs: Any) -> None:
@@ -30,4 +33,4 @@ class IImageType(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IImageType"]
+__all__ = ["IImageType", "ImageTypeState"]

pyobs/interfaces/IMode.py

@@ -8,19 +8,24 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class ModeState:
+    modes: dict[str, str] = field(default_factory=dict)  # group -> current mode
+    time: Time = field(default_factory=Time.now)
+
+
+@dataclass
+class ModeCapabilities:
+    modes: dict[str, list[str]] = field(default_factory=dict)  # group -> list of modes
+
+
 class IMode(Interface, metaclass=ABCMeta):
     """The module can change modes in a device."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class Capabilities:
-        modes: dict[str, list[str]] = field(default_factory=dict)  # group -> list of modes
-
-    @dataclass
-    class State:
-        modes: dict[str, str] = field(default_factory=dict)  # group -> current mode
-        time: Time = field(default_factory=Time.now)
+    state = ModeState
+    capabilities = ModeCapabilities
 
     @abstractmethod
     async def set_mode(self, mode: str, group: int = 0, **kwargs: Any) -> None:
@@ -37,4 +42,4 @@ class IMode(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IMode"]
+__all__ = ["IMode", "ModeState", "ModeCapabilities"]

pyobs/interfaces/IModule.py

@@ -7,15 +7,18 @@ from typing import Any
 from .interface import Interface
 
 
+@dataclass
+class ModuleCapabilities:
+    label: str = ""
+    version: str = ""
+
+
 class IModule(Interface, metaclass=ABCMeta):
     """The module is actually a module. Implemented by all modules."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class Capabilities:
-        version: str = ""
-        label: str = ""
+    capabilities = ModuleCapabilities
 
     @abstractmethod
     async def reset_error(self, **kwargs: Any) -> bool:
@@ -23,4 +26,4 @@ class IModule(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IModule"]
+__all__ = ["IModule", "ModuleCapabilities"]

pyobs/interfaces/IMotion.py

@@ -10,21 +10,25 @@ from ..utils.time import Time
 from .IReady import IReady
 
 
+@dataclass
+class DeviceMotionStatus:
+    name: str
+    status: MotionStatus
+
+
+@dataclass
+class MotionState:
+    status: MotionStatus
+    devices: list[DeviceMotionStatus] = field(default_factory=list)
+    time: Time = field(default_factory=Time.now)
+
+
 class IMotion(IReady, metaclass=ABCMeta):
     """The module controls a device that can move."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class DeviceMotionStatus:
-        name: str
-        status: MotionStatus
-
-    @dataclass
-    class State:
-        status: MotionStatus
-        devices: list[IMotion.DeviceMotionStatus] = field(default_factory=list)
-        time: Time = field(default_factory=Time.now)
+    state = MotionState
 
     @abstractmethod
     async def init(self, **kwargs: Any) -> None:
@@ -54,4 +58,4 @@ class IMotion(IReady, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IMotion"]
+__all__ = ["IMotion", "DeviceMotionStatus", "MotionState"]

pyobs/interfaces/IMultiFiber.py

@@ -8,24 +8,28 @@ from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class MultiFiberState:
+    fiber: str = ""
+    pixel_x: float = 0.0
+    pixel_y: float = 0.0
+    radius: float = 0.0
+    time: Time = field(default_factory=Time.now)
+
+
+@dataclass
+class MultiFiberCapabilities:
+    fiber_count: int = 0
+
+
 class IMultiFiber(Interface, metaclass=ABCMeta):
     """An interface for multi-fiber setups that helps to set/get a fiber and retrieve position and size of the
     current fiber on the acquisition/guiding image."""
 
     __module__ = "pyobs.interfaces"
 
-    @dataclass
-    class Capabilities:
-        fiber_count: int = 0
-        fiber_names: list[str] = field(default_factory=list)
-
-    @dataclass
-    class State:
-        fiber: str = ""
-        pixel_x: float = 0.0
-        pixel_y: float = 0.0
-        radius: float = 0.0
-        time: Time = field(default_factory=Time.now)
+    state = MultiFiberState
+    capabilities = MultiFiberCapabilities
 
     @abstractmethod
     async def abort(self, **kwargs: Any) -> None:
@@ -42,4 +46,4 @@ class IMultiFiber(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IMultiFiber"]
+__all__ = ["IMultiFiber", "MultiFiberState", "MultiFiberCapabilities"]