pyobs-core 2.0.0.dev8__py3-none-any.whl → 2.0.0.dev10__py3-none-any.whl

pyobs/comm/comm.py

@@ -193,14 +193,25 @@ class Comm:
             elif obj_type is None or isinstance(proxy, obj_type):
                 return proxy
             else:
-                raise ValueError(
-                    f'Proxy obtained from given name "{name_or_object}" is not of requested type "{obj_type}".'
-                )
+                message = f'Proxy obtained from given name "{name_or_object}" is not of requested type "{obj_type}".'
+                hint = self._diagnose_missing_interface(name_or_object, obj_type)
+                if hint is not None:
+                    message += f" {hint}"
+                raise ValueError(message)
 
         else:
             # completely wrong...
             raise ValueError(f'Given parameter is neither a name nor an object of requested type "{obj_type}".')
 
+    def _diagnose_missing_interface(self, client: str, obj_type: type[Any]) -> str | None:
+        """Backend hook, called when a proxy exists but doesn't implement obj_type.
+
+        Backends that can tell "genuinely missing" apart from "present at an
+        incompatible version" using data already in hand return a hint string
+        to append to the ValueError; other backends just return None.
+        """
+        return None
+
     async def _safe_resolve_proxy(
         self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
     ) -> Any | ProxyType | None:
@@ -600,53 +611,5 @@ class Comm:
                 if asyncio.iscoroutine(ret):
                     asyncio.create_task(ret)
 
-    def cast_to_simple_pre(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them to be sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-        return False, value
-
-    def cast_to_simple_post(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them to be sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-        return False, value
-
-    def cast_to_real_pre(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them after being sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-        return False, value
-
-    def cast_to_real_post(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them after being sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-        return False, value
-
 
 __all__ = ["Comm"]

pyobs/comm/local/localcomm.py

@@ -8,7 +8,6 @@ from pyobs.comm.comm import PresenceCallback
 from pyobs.events import Event
 from pyobs.interfaces import Interface
 from pyobs.utils.enums import ModuleState
-from pyobs.utils.types import cast_response_to_real
 
 from .localnetwork import LocalNetwork
 
@@ -53,11 +52,7 @@ class LocalComm(Comm):
         remote_client = self._network.get_client(client)
         if remote_client.module is None:
             raise ValueError
-        simple_results = await remote_client.module.execute(method, *args, sender=self.name)
-        real_results = cast_response_to_real(
-            simple_results, annotation["return"], self.cast_to_real_pre, self.cast_to_real_post
-        )
-        return real_results
+        return await remote_client.module.execute(method, *args, sender=self.name)
 
     async def send_event(self, event: Event) -> None:
         """Send an event to other clients."""

pyobs/comm/proxy.py

@@ -7,7 +7,6 @@ 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
 
 if TYPE_CHECKING:
     from pyobs.comm import Comm
@@ -123,11 +122,6 @@ class Proxy:
         ba = signature.bind(*args, **kwargs)
         ba.apply_defaults()
 
-        # cast to simple types
-        cast_bound_arguments_to_simple(
-            ba, type_hints, pre=self._comm.cast_to_simple_pre, post=self._comm.cast_to_simple_post
-        )
-
         # do request and return future
         return await self._comm.execute(self._client, method, type_hints, *ba.args[1:])
 

pyobs/comm/xmpp/rpc.py

@@ -159,7 +159,7 @@ class RPC:
         jid: str | slixmpp.JID = iq["id"]
         if isinstance(jid, slixmpp.JID):
             jid = jid.node
-        future = Future(annotation=annotation, comm=self._comm)
+        future = Future(annotation=annotation)
         self._futures[jid] = future
 
         await iq.send()

pyobs/comm/xmpp/xmppcomm.py

@@ -18,6 +18,7 @@ from slixmpp.xmlstream import ET
 from slixmpp.xmlstream.handler import Callback
 from slixmpp.xmlstream.matcher import MatchXMLMask
 
+import pyobs.interfaces
 from pyobs.comm import Comm
 from pyobs.events import Event, LogEvent, ModuleClosedEvent, ModuleOpenedEvent
 from pyobs.events.event import EventFactory
@@ -144,6 +145,8 @@ class XmppComm(Comm):
         self._connected = False
         self._online_clients: list[str] = []
         self._interface_cache: dict[str, asyncio.Future[list[type[Interface]]]] = {}
+        self._interface_features: dict[str, list[str]] = {}
+        self._warned_version_mismatches: set[tuple[str, str]] = set()
         self._user = user
         self._password = password
         self._domain = domain
@@ -253,7 +256,7 @@ class XmppComm(Comm):
         # add features
         if self._module is not None:
             for i in self._module.interfaces:
-                self._xmpp["xep_0030"].add_feature(f"pyobs:interface:{i.__name__}")
+                self._xmpp["xep_0030"].add_feature(f"urn:pyobs:interface:{i.__name__}:{i.version}")
 
         # register custom disco#info handler to inject <capability> elements
         if self._module is not None:
@@ -381,11 +384,24 @@ class XmppComm(Comm):
         try:
             if isinstance(info, slixmpp.stanza.iq.Iq):
                 info = info["disco_info"]
-            prefix = "pyobs:interface:"
-            interface_names = [i[len(prefix) :] for i in info["features"] if i.startswith(prefix)]
+            prefix = "urn:pyobs:interface:"
+            features = [i for i in info["features"] if i.startswith(prefix)]
         except TypeError:
             raise IndexError()
 
+        # cache raw features for this JID, so a later version-mismatch can be diagnosed
+        self._interface_features[jid] = features
+
+        # keep only names whose remote-published version matches what this client expects --
+        # a mismatch is treated the same as the interface not being there at all, rather than
+        # silently using the local (possibly incompatible) class
+        interface_names = []
+        for feature in features:
+            name, _, version = feature[len(prefix) :].rpartition(":")
+            local_cls = getattr(pyobs.interfaces, name, None)
+            if local_cls is not None and issubclass(local_cls, Interface) and str(local_cls.version) == version:
+                interface_names.append(name)
+
         # IModule not in list?
         if "IModule" not in interface_names:
             # try again or quit?
@@ -398,6 +414,39 @@ class XmppComm(Comm):
         # finished
         return interface_names
 
+    def _diagnose_missing_interface(self, client: str, obj_type: type[Any]) -> str | None:
+        """Checks the disco#info features already cached for client for a version of obj_type
+        other than the one this client expects, to tell a version mismatch apart from
+        obj_type genuinely not being implemented at all.
+        """
+        jid = self._get_full_client_name(client)
+        features = self._interface_features.get(jid, [])
+        prefix = f"urn:pyobs:interface:{obj_type.__name__}:"
+        other = [f for f in features if f.startswith(prefix)]
+        if not other:
+            return None
+
+        remote_version = other[0][len(prefix) :]
+        try:
+            remote_version_int = int(remote_version)
+        except ValueError:
+            return None
+        direction = "upgrade the remote module" if remote_version_int < obj_type.version else "upgrade this client"
+
+        pair = (jid, obj_type.__name__)
+        if pair not in self._warned_version_mismatches:
+            self._warned_version_mismatches.add(pair)
+            log.warning(
+                '"%s" implements %s at v%s, this client expects v%s (%s).',
+                client,
+                obj_type.__name__,
+                remote_version,
+                obj_type.version,
+                direction,
+            )
+
+        return f"Remote implements it at v{remote_version}, this client expects v{obj_type.version} ({direction})."
+
     async def _supports_interface(self, client: str, interface: type[Interface]) -> bool:
         """Checks, whether the given client supports the given interface.
 
@@ -557,6 +606,7 @@ class XmppComm(Comm):
         # clear interface cache
         if jid in self._interface_cache:
             del self._interface_cache[jid]
+        self._interface_features.pop(jid, None)
 
         # send event
         self._send_event_to_module(ModuleClosedEvent(), module_name)
@@ -730,38 +780,6 @@ class XmppComm(Comm):
         # never should reach this
         raise slixmpp.exceptions.IqTimeout(iq)
 
-    def cast_to_simple_pre(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them to be sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-
-        if isinstance(value, str):
-            return True, xml.sax.saxutils.escape(value)
-        else:
-            return False, value
-
-    def cast_to_real_post(self, value: Any, annotation: Any | None = None) -> tuple[bool, Any]:
-        """Special treatment of single parameters when converting them after being sent via Comm.
-
-        Args:
-            value: Value to be treated.
-            annotation: Annotation for value.
-
-        Returns:
-            A tuple containing a tuple that indicates whether this value should be further processed and a new value.
-        """
-
-        if isinstance(value, str):
-            return True, xml.sax.saxutils.unescape(value)
-        else:
-            return False, value
-
     @staticmethod
     def _state_namespace(interface: type[Interface]) -> str:
         return f"urn:pyobs:state:{interface.__name__}:{interface.version}"

pyobs/interfaces/IAutoFocus.py

@@ -1,24 +1,46 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
 from typing import Annotated, Any
 
 from ..utils.enums import Unit
+from ..utils.time import Time
 from .IAbortable import IAbortable
 
 
+@dataclass
+class AutoFocusResult:
+    focus: float
+    focus_err: float
+
+
+@dataclass
+class AutoFocusPoint:  # AutoFocusStatus.points element
+    focus: float
+    value: float
+
+
+@dataclass
+class AutoFocusState:  # growing curve during autofocus run
+    points: list[AutoFocusPoint] = field(default_factory=list)
+    time: Time = field(default_factory=Time.now)
+
+
 class IAutoFocus(IAbortable, metaclass=ABCMeta):
-    """The module can perform an auto-focus."""
+    """The module can perform an autofocus."""
 
     __module__ = "pyobs.interfaces"
 
+    state = AutoFocusState
+
     @abstractmethod
     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.
+    ) -> AutoFocusResult:
+        """Perform an autofocus series.
 
-        This method performs an auto-focus series with "count" images on each side of the initial guess and the given
+        This method performs an autofocus series with "count" images on each side of the initial guess and the given
         step size. With count=3, step=1 and guess=10, this takes images at the following focus values:
         7, 8, 9, 10, 11, 12, 13
 
@@ -28,23 +50,12 @@ class IAutoFocus(IAbortable, metaclass=ABCMeta):
             exposure_time: Exposure time for images.
 
         Returns:
-            Tuple of obtained best focus value and its uncertainty.
+            Result of autofocus.
 
         Raises:
             ValueError: If focus could not be obtained.
         """
         ...
 
-    @abstractmethod
-    async def auto_focus_status(self, **kwargs: Any) -> dict[str, Any]:
-        """Returns current status of auto focus.
-
-        Returned dictionary contains a list of focus/fwhm pairs in X and Y direction.
-
-        Returns:
-            Dictionary with current status.
-        """
-        ...
-
 
-__all__ = ["IAutoFocus"]
+__all__ = ["IAutoFocus", "AutoFocusResult", "AutoFocusPoint", "AutoFocusState"]

pyobs/interfaces/IFitsHeaderAfter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABCMeta, abstractmethod
 from typing import Any
 
+from .IFitsHeaderBefore import FitsHeaderEntry
 from .interface import Interface
 
 
@@ -15,7 +16,7 @@ class IFitsHeaderAfter(Interface, metaclass=ABCMeta):
     @abstractmethod
     async def get_fits_header_after(
         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.
 
         Args:

pyobs/interfaces/IFitsHeaderBefore.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass
 from typing import Any
 
 from .interface import Interface
 
 
+@dataclass
+class FitsHeaderEntry:
+    value: int | float | str | None
+    comment: str
+
+
 class IFitsHeaderBefore(Interface, metaclass=ABCMeta):
     """The module provides some additional header entries for FITS headers before some event (usually the start of the
     exposure)."""
@@ -15,7 +22,7 @@ class IFitsHeaderBefore(Interface, metaclass=ABCMeta):
     @abstractmethod
     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.
 
         Args:
@@ -27,4 +34,4 @@ class IFitsHeaderBefore(Interface, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["IFitsHeaderBefore"]
+__all__ = ["FitsHeaderEntry", "IFitsHeaderBefore"]

pyobs/interfaces/IFocusModel.py

@@ -1,18 +1,23 @@
 from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
 from typing import Any
 
+from ..utils.time import Time
 from .interface import Interface
 
 
+@dataclass
+class OptimalFocusState:  # 2.0 adds focus_err alongside the existing focus value
+    focus: float
+    time: Time = field(default_factory=Time.now)
+
+
 class IFocusModel(Interface, metaclass=ABCMeta):
     """The module provides a model for the telescope focus, e.g. based on temperatures."""
 
     __module__ = "pyobs.interfaces"
 
-    @abstractmethod
-    async def get_optimal_focus(self, **kwargs: Any) -> float:
-        """Returns the optimal focus."""
-        ...
+    state = OptimalFocusState
 
     @abstractmethod
     async def set_optimal_focus(self, **kwargs: Any) -> None:

pyobs/interfaces/IWeather.py

@@ -1,40 +1,39 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
 from typing import Any
 
 from pyobs.utils.enums import WeatherSensors
 
+from ..utils.time import Time
 from .IStartStop import IStartStop
 
 
-class IWeather(IStartStop, metaclass=ABCMeta):
-    """The module acts as a weather station."""
+@dataclass
+class WeatherSensorReading:  # WeatherState.readings element
+    sensor: WeatherSensors
+    value: float
+    unit: str
+    time: Time = field(default_factory=Time.now)
 
-    __module__ = "pyobs.interfaces"
 
-    @abstractmethod
-    async def get_weather_status(self, **kwargs: Any) -> dict[str, Any]:
-        """Returns status of object in form of a dictionary. See other interfaces for details."""
-        ...
+@dataclass
+class WeatherState:
+    good: bool
+    readings: list[WeatherSensorReading] = field(default_factory=list)
+    time: Time = field(default_factory=Time.now)
 
-    @abstractmethod
-    async def is_weather_good(self, **kwargs: Any) -> bool:
-        """Whether the weather is good to observe."""
-        ...
 
-    @abstractmethod
-    async def get_current_weather(self, **kwargs: Any) -> dict[str, Any]:
-        """Returns current weather.
+class IWeather(IStartStop, metaclass=ABCMeta):
+    """The module acts as a weather station."""
 
-        Returns:
-            Dictionary containing entries for time, good, and sensor, with the latter being another dictionary
-            with sensor information, which contain a value and a good flag.
-        """
-        ...
+    __module__ = "pyobs.interfaces"
+
+    state = WeatherState
 
     @abstractmethod
-    async def get_sensor_value(self, station: str, sensor: WeatherSensors, **kwargs: Any) -> tuple[str, float]:
+    async def get_sensor_value(self, station: str, sensor: WeatherSensors, **kwargs: Any) -> WeatherSensorReading:
         """Return value for given sensor.
 
         Args:
@@ -42,9 +41,9 @@ class IWeather(IStartStop, metaclass=ABCMeta):
             sensor: Name of sensor to get value from.
 
         Returns:
-            Tuple of current value of given sensor or None and time of measurement or None.
+            Current reading for the given sensor.
         """
         ...
 
 
-__all__ = ["IWeather"]
+__all__ = ["IWeather", "WeatherState", "WeatherSensorReading"]

pyobs/interfaces/__init__.py

@@ -13,7 +13,7 @@ __title__ = "Interfaces"
 
 from .IAbortable import IAbortable
 from .IAcquisition import IAcquisition
-from .IAutoFocus import IAutoFocus
+from .IAutoFocus import AutoFocusPoint, AutoFocusResult, AutoFocusState, IAutoFocus
 from .IAutoGuiding import IAutoGuiding
 from .IAutonomous import IAutonomous
 from .IBinning import BinningCapabilities, BinningState, IBinning
@@ -27,10 +27,10 @@ from .IExposure import ExposureState, IExposure
 from .IExposureTime import ExposureTimeState, IExposureTime
 from .IFilters import FiltersCapabilities, FilterState, IFilters
 from .IFitsHeaderAfter import IFitsHeaderAfter
-from .IFitsHeaderBefore import IFitsHeaderBefore
+from .IFitsHeaderBefore import FitsHeaderEntry, IFitsHeaderBefore
 from .IFlatField import IFlatField
 from .IFocuser import FocuserState, IFocuser
-from .IFocusModel import IFocusModel
+from .IFocusModel import IFocusModel, OptimalFocusState
 from .IGain import GainState, IGain
 from .IImageFormat import IImageFormat, ImageFormatCapabilities, ImageFormatState
 from .IImageType import IImageType, ImageTypeState
@@ -58,13 +58,16 @@ from .ISyncTarget import ISyncTarget
 from .ITelescope import ITelescope
 from .ITemperatures import ITemperatures, SensorReading, TemperaturesState
 from .IVideo import IVideo, VideoCapabilities
-from .IWeather import IWeather
+from .IWeather import IWeather, WeatherSensorReading, WeatherState
 from .IWindow import IWindow, WindowCapabilities, WindowState
 
 __all__ = [
     "IAbortable",
     "IAcquisition",
     "IAutoFocus",
+    "AutoFocusResult",
+    "AutoFocusPoint",
+    "AutoFocusState",
     "IAutoGuiding",
     "IAutonomous",
     "IBinning",
@@ -84,10 +87,12 @@ __all__ = [
     "IFilters",
     "FiltersCapabilities",
     "FilterState",
+    "FitsHeaderEntry",
     "IFitsHeaderAfter",
     "IFitsHeaderBefore",
     "IFlatField",
     "IFocusModel",
+    "OptimalFocusState",
     "IFocuser",
     "FocuserState",
     "IGain",
@@ -141,6 +146,8 @@ __all__ = [
     "IVideo",
     "VideoCapabilities",
     "IWeather",
+    "WeatherState",
+    "WeatherSensorReading",
     "IWindow",
     "WindowCapabilities",
     "WindowState",

pyobs/mixins/fitsheader.py

@@ -111,13 +111,8 @@ class FitsHeaderMixin:
             # add them to fits file
             if headers:
                 log.debug("Adding additional FITS headers from %s...", client)
-                for key, value in headers.items():
-                    # if value is not a string, it may be a list of value and comment
-                    if isinstance(value, list) and not isinstance(value, str):
-                        # convert list to tuple
-                        image.header[key] = tuple(value)
-                    else:
-                        image.header[key] = value
+                for key, entry in headers.items():
+                    image.header[key] = (entry.value, entry.comment)
 
     async def add_fits_headers(self, image: Image | fits.PrimaryHDU) -> None:
         """Add requested FITS headers to header of given image.

pyobs/mixins/fitsnamespace.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import logging
 from typing import Any
 
+from pyobs.interfaces import FitsHeaderEntry
+
 log = logging.getLogger(__name__)
 
 
@@ -15,8 +17,8 @@ class FitsNamespaceMixin:
         self.__namespaces = {} if fits_namespaces is None else fits_namespaces
 
     def _filter_fits_namespace(
-        self, hdr: dict[str, tuple[Any, str]], sender: str, namespaces: list[str] | None = None
-    ) -> dict[str, tuple[Any, str]]:
+        self, hdr: dict[str, FitsHeaderEntry], sender: str, namespaces: list[str] | None = None
+    ) -> dict[str, FitsHeaderEntry]:
         """Filter FITS header keywords by given namespaces. If no namespaces are given, let all through. Always
         let keywords with this module's name as namespace pass.
 

pyobs/mixins/weatheraware.py

@@ -120,7 +120,8 @@ class WeatherAwareMixin:
                     try:
                         # get good status
                         async with module.proxy(this.__weather, IWeather) as proxy:
-                            this.__is_weather_good = await proxy.is_weather_good()
+                            weather_state = await proxy.wait_for_state(IWeather, timeout=5.0)
+                            this.__is_weather_good = weather_state.good if weather_state is not None else False
 
                     except Exception:
                         # could either not connect or weather is not good