pyobs-core 2.0.0.dev42__tar.gz → 2.0.0.dev44__tar.gz

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/PKG-INFO

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

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/application.py

@@ -10,6 +10,7 @@ from typing import Any, TypedDict
 
 import yaml
 
+from pyobs.comm.dummy import DummyComm
 from pyobs.modules import Module, MultiModule
 from pyobs.object import get_class_from_string, get_object
 from pyobs.utils.config import pre_process_yaml
@@ -181,6 +182,14 @@ class Application:
         asyncio.set_event_loop(self._loop)
 
         # create module and open it
+        config_stem = Path(self._config).stem.lstrip("_")
+        if "comm" not in cfg and not issubclass(klass, MultiModule):
+            # no comm configured -- module would otherwise fall back to a DummyComm named
+            # with the fixed placeholder "module", indistinguishable from every other
+            # comm-less module in PYOBS_MODULE log tagging (see
+            # specs/steering/finding-module-logs-under-pyobsd.md) and guaranteed to trip the
+            # stem-mismatch check below. Give it the config file's own stem instead.
+            cfg = {**cfg, "comm": {"class": f"{DummyComm.__module__}.{DummyComm.__name__}", "name": config_stem}}
         log.info("Creating module from class %s...", klass.__name__)
         self._module = get_object(cfg, Module)
 
@@ -193,7 +202,6 @@ class Application:
         # (module.py), never meant to match a filename -- each child module is already
         # correctly distinguished via execute()/BackgroundTask.
         if not isinstance(self._module, MultiModule):
-            config_stem = Path(self._config).stem.lstrip("_")
             if self._module.name != config_stem:
                 log.warning(
                     "Config file stem (%s) does not match module's own name "

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/cli/pyobsd.py

@@ -33,6 +33,7 @@ class PyobsDaemonCLI(CLI):
         "log_path",
         "log_level",
         "syslog",
+        "file_log",
         "chuid",
     ]
 
@@ -54,6 +55,12 @@ class PyobsDaemonCLI(CLI):
             help="send module logs to systemd journal (use --no-syslog to disable)",
             default=self._config.get("syslog", True),
         )
+        self._parser.add_argument(
+            "--file-log",
+            action=argparse.BooleanOptionalAction,
+            help="also write each module's log to <log-path>/<module>.log (off by default; use --file-log to enable)",
+            default=self._config.get("file_log", False),
+        )
         self._parser.add_argument("--chuid", type=str, default=self._config.get("chuid", "pyobs:pyobs"))
         self._parser.add_argument("-v", "--verbose", action="store_true")
 
@@ -76,6 +83,7 @@ class PyobsDaemonCLI(CLI):
             str(os.path.join(self._config["path"], self._config["log_path"])),
             log_level=self._config["log_level"],
             syslog=self._config["syslog"],
+            file_log=self._config["file_log"],
             chuid=self._config["chuid"],
             verbose=self._config["verbose"],
         )
@@ -104,6 +112,7 @@ class PyobsDaemon:
         log_path: str,
         log_level: str = "info",
         syslog: bool = False,
+        file_log: bool = False,
         chuid: str | None = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -113,6 +122,7 @@ class PyobsDaemon:
         self._log_path = log_path
         self._log_level = log_level
         self._syslog = syslog
+        self._file_log = file_log
         self._verbose = verbose
 
         # parse optional user/group from chuid (format: "user:group" or "user")
@@ -317,18 +327,18 @@ class PyobsDaemon:
 
     def _start_service(self, module: str) -> None:
         os.makedirs(self._run_path, exist_ok=True)
-        os.makedirs(self._log_path, exist_ok=True)
 
         cmd = [
             self._pyobs_exec,
             "--pid-file",
             self._pid_file(module),
-            "--log-file",
-            self._log_file(module),
             "--log-level",
             self._log_level,
             self._config_file(module),
         ]
+        if self._file_log:
+            os.makedirs(self._log_path, exist_ok=True)
+            cmd += ["--log-file", self._log_file(module)]
         if self._syslog:
             cmd.append("--syslog")
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/comm/comm.py

@@ -41,6 +41,7 @@ class Comm:
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
         self._registered_events: set[type[Event]] = set()
         self._closing = asyncio.Event()
+        self._published_state: set[type[Interface]] = set()
 
     @property
     def has_module(self) -> bool:
@@ -381,7 +382,10 @@ class Comm:
                 return
 
             except Exception:
-                log.exception("Something went wrong")
+                # don't forward this back through CommLoggingHandler -- it would re-queue
+                # itself onto _log_queue, and if the send failure is due to a sustained
+                # outage, every retry generates another one of these, forever
+                log.exception("Something went wrong", extra={"pyobs_no_forward": True})
                 pass
 
     def log_message(self, entry: LogEvent) -> None:
@@ -479,11 +483,17 @@ class Comm:
             interface: Interface type for the state.
             state: State object to publish.
         """
+        self._published_state.add(interface)
         await self._set_state(interface, state)
 
     async def _set_state(self, interface: type[Interface], state: Any) -> None:
         pass
 
+    def missing_published_state(self, interfaces: list[type[Interface]]) -> list[type[Interface]]:
+        """Return interfaces (from the given list) that declare state via has_own_state() but
+        haven't had set_state() called for them yet."""
+        return [i for i in interfaces if i.has_own_state() and i not in self._published_state]
+
     async def set_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
         """Publish capabilities for this module.
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/comm/commlogging.py

@@ -31,6 +31,12 @@ class CommLoggingHandler(logging.Handler):
             rec: Log record to send.
         """
 
+        # a record about the forwarding pipeline itself failing (e.g. Comm._logging's own
+        # send failure) must not be forwarded again, or a sustained outage turns into an
+        # unbounded loop of "failed to send" records about failing to send that record
+        if getattr(rec, "pyobs_no_forward", False):
+            return
+
         # format message
         msg = self._formatter.format(rec)  # noqa: UP031
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/comm/dummy/dummycomm.py

@@ -14,9 +14,17 @@ log = logging.getLogger(__name__)
 class DummyComm(Comm):
     """A dummy implementation of the Comm interface."""
 
-    def __init__(self, *args: Any, **kwargs: Any):
-        """Creates a new dummy comm."""
+    def __init__(self, name: str = "module", *args: Any, **kwargs: Any):
+        """Creates a new dummy comm.
+
+        Args:
+            name: Name to report for this comm. Defaults to the generic placeholder "module"
+                for callers (e.g. tests) that construct a DummyComm directly without a real
+                identity; Application fills in the config file's stem when a module has no
+                comm of its own configured.
+        """
         Comm.__init__(self, *args, **kwargs)
+        self._name = name
 
     @property
     def clients(self) -> list[str]:
@@ -47,8 +55,8 @@ class DummyComm(Comm):
 
     @property
     def name(self) -> str:
-        """Name of this client, which is unknown."""
-        return "module"
+        """Name of this client."""
+        return self._name
 
     async def send_event(self, event: Event) -> None:
         """Send an event to other clients.
@@ -56,7 +64,7 @@ class DummyComm(Comm):
         Args:
             event (Event): Event to send
         """
-        self._send_event_to_module(event, "module")
+        self._send_event_to_module(event, self._name)
 
 
 __all__ = ["DummyComm"]

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/comm/proxy.py

@@ -7,6 +7,7 @@ from collections.abc import Coroutine
 from typing import TYPE_CHECKING, Any, Generic, TypeVar, get_type_hints
 
 from pyobs.interfaces import Interface
+from pyobs.utils.time import Time
 
 if TYPE_CHECKING:
     from pyobs.comm import Comm
@@ -172,9 +173,22 @@ class Proxy:
         """Clear all cached state. Called by Comm when the remote module disconnects."""
         self._state.clear()
 
-    def get_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)
+    def get_state(self, interface: type[Interface], *, max_age: float | None = None) -> Any | None:
+        """Latest known state for the given interface, or None if nothing has arrived yet
+        (or, with max_age given, if the latest known state is older than max_age seconds)."""
+        state = self._state.get(interface)
+        if state is None or max_age is None:
+            return state
+        return state if self._state_age(state) <= max_age else None
+
+    def _state_age(self, state: Any) -> float:
+        """Seconds since `state` (a State dataclass instance) was constructed by its publisher."""
+        t = getattr(state, "time", None)
+        if t is None:
+            raise ValueError(
+                f"{type(state).__name__} has no 'time' field -- max_age is not supported for this interface."
+            )
+        return (Time.now() - t).sec
 
     def update_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
         """Called by Comm once capabilities for an interface arrive.
@@ -194,16 +208,22 @@ class Proxy:
         self,
         interface: type[Interface],
         timeout: float = 10.0,
+        *,
+        max_age: float | None = None,
     ) -> Any:
-        """Return state immediately if available, otherwise wait for the first update.
+        """Return state immediately if available (and fresh enough per max_age), otherwise wait
+        for the next update.
 
         Returns None on timeout rather than raising -- every caller across the codebase already
         does `if state is not None else ...` right after calling this, so that's the contract
         actually being relied on; letting asyncio.wait_for's TimeoutError propagate would just
-        turn "peer hasn't published yet" into an unhandled exception for all of them.
+        turn "peer hasn't published yet" into an unhandled exception for all of them. The same
+        None-on-"not usable yet" contract now also covers "published, but too stale" when max_age
+        is given.
         """
-        if self._state.get(interface) is not None:
-            return self._state[interface]
+        cached = self._state.get(interface)
+        if cached is not None and (max_age is None or self._state_age(cached) <= max_age):
+            return cached
 
         event = asyncio.Event()
 
@@ -220,7 +240,10 @@ class Proxy:
         finally:
             await self._comm.unsubscribe_state(self._client, interface, _notify)
 
-        return self._state.get(interface)
+        result = self._state.get(interface)
+        if max_age is not None and result is not None and self._state_age(result) > max_age:
+            return None
+        return result
 
     async def wait_for_capabilities(
         self,

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/comm/xmpp/xmppcomm.py

@@ -315,6 +315,14 @@ class XmppComm(Comm):
         self._xmpp.enable_direct_tls = self._use_tls
         self._xmpp.enable_plaintext = not self._use_tls
         self._xmpp.plugin["feature_mechanisms"].unencrypted_scram = not self._use_tls  # type: ignore[typeddict-item]
+        # Without this, slixmpp still refuses PLAIN over a non-TLS connection even
+        # with enable_plaintext set above -- it only affects the stream feature
+        # advertisement, not SASL mechanism selection. Matters in practice: this
+        # server's SCRAM implementation fails unencrypted SCRAM auth with "Invalid
+        # channel binding" (confirmed against ejabberd 26.4.0), so without this
+        # flag every non-TLS connection falls through all mechanisms and fails
+        # with "No appropriate login method" rather than falling back to PLAIN.
+        self._xmpp.plugin["feature_mechanisms"].unencrypted_plain = not self._use_tls  # type: ignore[typeddict-item]
         if self._ignore_cert_errors:
             self._xmpp.ssl_context.check_hostname = False
             self._xmpp.ssl_context.verify_mode = ssl.CERT_NONE

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/interfaces/IRunning.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta
 from dataclasses import dataclass, field
-from typing import Any
 
 from ..utils.time import Time
 from .interface import Interface
@@ -21,10 +20,5 @@ class IRunning(Interface, metaclass=ABCMeta):
 
     state = RunningState
 
-    @abstractmethod
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        ...
-
 
 __all__ = ["IRunning", "RunningState"]

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/interfaces/interface.py

@@ -42,7 +42,7 @@ class Interface(metaclass=ABCMeta):
             )
         _REGISTRY[cls.__name__] = cls
 
-    def get_state(self, interface: "type[Interface]") -> Any | None:
+    def get_state(self, interface: "type[Interface]", *, max_age: float | None = None) -> Any | None:
         """Return the last received state for the given interface, or None."""
         return None
 
@@ -50,7 +50,9 @@ class Interface(metaclass=ABCMeta):
         """Return the capabilities for the given interface, or None."""
         return None
 
-    async def wait_for_state(self, interface: "type[Interface]", timeout: float = 10.0) -> Any | None:
+    async def wait_for_state(
+        self, interface: "type[Interface]", timeout: float = 10.0, *, max_age: float | None = None
+    ) -> Any | None:
         """Return state immediately if available, otherwise wait for the first update."""
         return None
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/mixins/follow.py

@@ -15,13 +15,18 @@ log = logging.getLogger(__name__)
 
 
 async def get_coords(
-    obj: IPointingAltAz | IPointingRaDec, mode: type[IPointingAltAz | IPointingRaDec]
+    obj: IPointingAltAz | IPointingRaDec,
+    mode: type[IPointingAltAz | IPointingRaDec],
+    max_age: float | None = None,
 ) -> tuple[float, float]:
     """Gets coordinates from object
 
     Args:
         obj: Object to fetch coordinates from.
         mode: IAltAz or IRaDec.
+        max_age: If obj is a remote Proxy, treat cached state older than this many seconds the
+            same as "not available" (raises ValueError below). Ignored for a Module, whose own
+            state is always current from its own perspective.
 
     Returns:
         Return from method call.
@@ -29,7 +34,7 @@ async def get_coords(
 
     if mode == IPointingAltAz:
         if isinstance(obj, Proxy):
-            state: AltAzState | None = obj.get_state(IPointingAltAz)
+            state: AltAzState | None = obj.get_state(IPointingAltAz, max_age=max_age)
         elif isinstance(obj, Module):
             state = obj.comm.get_own_state(IPointingAltAz)
         else:
@@ -39,7 +44,7 @@ async def get_coords(
         return state.alt, state.az
     elif mode == IPointingRaDec:
         if isinstance(obj, Proxy):
-            state2: RaDecState | None = obj.get_state(IPointingRaDec)
+            state2: RaDecState | None = obj.get_state(IPointingRaDec, max_age=max_age)
         elif isinstance(obj, Module):
             state2 = obj.comm.get_own_state(IPointingRaDec)
         else:
@@ -80,6 +85,7 @@ class FollowMixin:
         interval: float = 10,
         tolerance: float = 1,
         only_follow_when_ready: bool = True,
+        follow_max_age: float | None = None,
         *args: Any,
         **kwargs: Any,
     ):
@@ -91,6 +97,11 @@ class FollowMixin:
             tolerance: Tolerance in degrees between both devices to trigger new movement.
             mode: Set to "altaz" to follow Alt/Az coordinates or "radec" to follow RA/Dec.
             only_follow_when_ready: Only follow if is_ready() is True.
+            follow_max_age: Treat the followed device's cached position as unavailable once
+                it's older than this many seconds -- guards against silently following a frozen
+                position if the followed device's own position-publish loop dies while its
+                connection stays up. Defaults to 3x interval (loose enough to tolerate a slow
+                tick, tight enough to notice a dead feed within a few position checks).
         """
 
         # store
@@ -99,6 +110,7 @@ class FollowMixin:
         self.__follow_tolerance = tolerance
         self.__follow_mode = mode
         self.__follow_only_when_ready = only_follow_when_ready
+        self.__follow_max_age = follow_max_age if follow_max_age is not None else interval * 3
 
         # store self for later
         this = self
@@ -154,7 +166,7 @@ class FollowMixin:
                 else:
                     continue
                 async with module.proxy(this.__follow_device, this.__follow_mode) as proxy:
-                    xy_coords = await get_coords(proxy, this.__follow_mode)
+                    xy_coords = await get_coords(proxy, this.__follow_mode, max_age=this.__follow_max_age)
                 if xy_coords is None:
                     continue
                 other_coords = build_skycoord(xy_coords, this.__follow_mode)

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/mixins/weatheraware.py

@@ -18,8 +18,9 @@ class WeatherAwareMixin:
 
     __module__ = "pyobs.mixins"
 
-    def __init__(self, weather: str | IWeather | None = None, **kwargs: Any):
+    def __init__(self, weather: str | IWeather | None = None, weather_max_age: float = 120.0, **kwargs: Any):
         self.__weather = weather
+        self.__weather_max_age = weather_max_age
         self.__is_weather_good: bool | None = None
         self.__last_park_attempt: float | None = None
         self.__weatheraware_is_error_state = False
@@ -121,7 +122,9 @@ class WeatherAwareMixin:
                     try:
                         # get good status
                         async with module.proxy(this.__weather, IWeather) as proxy:
-                            weather_state = await proxy.wait_for_state(IWeather, timeout=5.0)
+                            weather_state = await proxy.wait_for_state(
+                                IWeather, timeout=5.0, max_age=this.__weather_max_age
+                            )
                             this.__is_weather_good = weather_state.good if weather_state is not None else False
                         this.__weather_check_failures = 0
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/camera/dummycamera.py

@@ -153,6 +153,12 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
             ICooling,
             CoolingState(setpoint=self._cooling.set_point, power=self._cooling.power, enabled=self._cooling.enabled),
         )
+        await self.comm.set_state(
+            ITemperatures,
+            TemperaturesState(
+                readings=[SensorReading(name=name, value=value) for name, value in self._cooling.temperatures.items()]
+            ),
+        )
         await self.comm.set_state(IGain, GainState(gain=self._gain, offset=self._gain_offset))
         await self.comm.set_state(IWindow, WindowState(*self._full_frame))
         await self.comm.set_state(IBinning, BinningState(*self._binning))

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/focus/dummyautofocus.py

@@ -99,10 +99,6 @@ class DummyAutoFocus(Module, IAutoFocus):
         await self.comm.send_event(FocusFoundEvent(self._best_focus, error))
         return AutoFocusResult(focus=self._best_focus, focus_err=error)
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._running
-
     async def abort(self, **kwargs: Any) -> None:
         """Abort current actions."""
         self._abort.set()

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/focus/focusmodel.py

@@ -84,7 +84,7 @@ class FocusModel(Module, IFocusModel):
         focuser: str | None = None,
         weather: str | None = None,
         interval: int = 300,
-        temperatures: dict[str, dict[str, float]] | None = None,
+        temperatures: dict[str, dict[str, str]] | None = None,
         model: str | None = None,
         coefficients: dict[str, float] | None = None,
         update: bool = False,
@@ -96,6 +96,7 @@ class FocusModel(Module, IFocusModel):
         filter_offsets: dict[str, float] | None = None,
         filter_wheel: str | None = None,
         auto_focus: str | list[str] | None = None,
+        temp_max_age: float | None = None,
         **kwargs: Any,
     ):
         """Initialize a focus model.
@@ -115,6 +116,9 @@ class FocusModel(Module, IFocusModel):
             filter_offsets: Offsets for different filters. If None, they are not modeled.
             filter_wheel: Name of filter wheel module to use for fetching filter before setting focus.
             auto_focus: Name or list of names of auto-focus modules to accept focus values from.
+            temp_max_age: Treat a temperature module's cached ITemperatures reading as unavailable
+                once it's older than this many seconds -- guards against silently feeding a frozen
+                reading (from a dead sensor module) into the focus model. Defaults to 2x interval.
         """
         Module.__init__(self, **kwargs)
 
@@ -130,7 +134,8 @@ class FocusModel(Module, IFocusModel):
         self._focuser = focuser
         self._weather = weather
         self._interval = interval
-        self._temperatures: dict[str, dict[str, float]] = {} if temperatures is None else temperatures
+        self._temperatures: dict[str, dict[str, str]] = {} if temperatures is None else temperatures
+        self._temp_max_age = temp_max_age if temp_max_age is not None else float(interval) * 2
         self._focuser_ready = True
         self._coefficients = {} if coefficients is None else coefficients
         self._update_model = update
@@ -318,7 +323,7 @@ class FocusModel(Module, IFocusModel):
                 # get temperatures
                 async with self.proxy(cfg["module"], ITemperatures) as proxy:
                     try:
-                        temp_state = await proxy.wait_for_state(ITemperatures)
+                        temp_state = await proxy.wait_for_state(ITemperatures, max_age=self._temp_max_age)
                     except TimeoutError:
                         raise FocusTimeoutError(f"Timeout waiting for temperatures from module {cfg['module']}.")
                     module_temps[cfg["module"]] = (

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/focus/focusseries.py

@@ -291,10 +291,6 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
         """Abort current actions."""
         self._abort.set()
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._running
-
     async def _on_bad_weather(self, event: Event, sender: str) -> bool:
         """Abort series if a bad weather event occurs.
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/module.py

@@ -344,6 +344,17 @@ class Module(Object, IModule, IConfig):
         which would then never leave STARTING under Application/MultiModule.
         """
         await self.open()
+
+        # warn if any stateful interface hasn't published state yet
+        if self._comm is not None:
+            missing = self._comm.missing_published_state(self._interfaces)
+            for iface in missing:
+                log.warning(
+                    "Module %s implements %s which declares state, but no state has been published for it yet.",
+                    self.name,
+                    iface.__name__,
+                )
+
         await self.set_state(ModuleState.READY)
 
     async def close(self) -> None:

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/pointing/_baseguiding.py

@@ -95,14 +95,6 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
         await self._reset_guiding(enabled=False)
         await self.comm.set_state(IRunning, RunningState(running=False))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether auto-guiding is running.
-
-        Returns:
-            Auto-guiding is running.
-        """
-        return self._enabled
-
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
     ) -> dict[str, FitsHeaderEntry]:

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/pointing/acquisition.py

@@ -103,10 +103,6 @@ class Acquisition(BasePointing, CameraSettingsMixin, IAcquisition):
         await self.comm.set_state(IAcquisition, AcquisitionState())
         await self.comm.set_state(IRunning, RunningState(running=False))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._is_running
-
     @raises(exc.AbortedError, exc.AcquisitionError)
     @timeout(120)
     async def acquire_target(self, **kwargs: Any) -> AcquisitionResult:

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/pointing/dummyacquisition.py

@@ -59,10 +59,6 @@ class DummyAcquisition(Module, IAcquisition):
         await self.comm.set_state(IAcquisition, AcquisitionState())
         await self.comm.set_state(IRunning, RunningState(running=False))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._is_running
-
     @timeout(120)
     async def acquire_target(self, **kwargs: Any) -> AcquisitionResult:
         """Acquire target at given coordinates.

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/pointing/dummyguiding.py

@@ -56,9 +56,6 @@ class DummyAutoGuiding(Module, IAutoGuiding):
         await self.comm.set_state(IRunning, RunningState(running=False))
         await self._publish_guiding_state(loop_closed=False)
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        return self._running
-
     async def _publish_guiding_state(self, loop_closed: bool) -> None:
         await self.comm.set_state(
             IAutoGuiding,

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/robotic/mastermind.py

@@ -90,10 +90,6 @@ class Mastermind(Module, IAutonomous, IFitsHeaderBefore):
         self._running = False
         await self.comm.set_state(IRunning, RunningState(running=self._running))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._running
-
     async def _run_thread(self) -> None:
         # wait a little
         await asyncio.sleep(5)

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/robotic/pointing.py

@@ -50,7 +50,7 @@ class PointingSeries(Module, IAutonomous):
     async def open(self) -> None:
         """Open module."""
         await Module.open(self)
-        await self.comm.set_state(IRunning, RunningState(running=await self.is_running()))
+        await self.comm.set_state(IRunning, RunningState(running=True))
 
     async def start(self, **kwargs: Any) -> None:
         """Starts a service."""
@@ -60,10 +60,6 @@ class PointingSeries(Module, IAutonomous):
         """Stops a service."""
         pass
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return True
-
     async def _run_thread(self) -> None:
         """Run a pointing series."""
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/robotic/scheduler.py

@@ -119,10 +119,6 @@ class Scheduler(Module, IStartStop, IRunnable):
         self._running = False
         await self.comm.set_state(IRunning, RunningState(running=self._running))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether scheduler is running."""
-        return self._running
-
     async def _update_schedule(self) -> None:
         # get schedulable tasks and sort them
         log.info("Found update in schedulable block, downloading them...")

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/utils/kiosk.py

@@ -109,10 +109,6 @@ class Kiosk(Module, IStartStop):
         self._running = False
         await self.comm.set_state(IRunning, RunningState(running=self._running))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether kiosk mode is running."""
-        return self._running
-
     async def _camera_thread(self) -> None:
         """Thread for taking images."""
 

{pyobs_core-2.0.0.dev42 → pyobs_core-2.0.0.dev44}/pyobs/modules/utils/trigger.py

@@ -63,10 +63,6 @@ class Trigger(Module, IAutonomous):
         self._running = False
         await self.comm.set_state(IRunning, RunningState(running=self._running))
 
-    async def is_running(self, **kwargs: Any) -> bool:
-        """Whether a service is running."""
-        return self._running
-
     async def _handle_event(self, event: Event, sender: str) -> bool:
         """Handle an incoming event.