pyobs-core 2.0.0.dev75__tar.gz → 2.0.0.dev77__tar.gz

{pyobs_core-2.0.0.dev75 → pyobs_core-2.0.0.dev77}/PKG-INFO

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

{pyobs_core-2.0.0.dev75 → pyobs_core-2.0.0.dev77}/pyobs/application.py

@@ -16,6 +16,7 @@ from pyobs.modules import Module, MultiModule
 from pyobs.object import get_class_from_string, get_object
 from pyobs.utils.config import pre_process_yaml
 from pyobs.utils.logging.context import ModuleNameFilter
+from pyobs.utils.versions import loaded_pyobs_packages
 
 # just init logger with something here, will be overwritten in __init__
 log = logging.getLogger(__name__)
@@ -375,6 +376,18 @@ class Application:
 
             # open module
             log.info("Opening module...")
+
+            # record the loaded pyobs package versions for comm-less consumers (e.g. web-admin
+            # reading the log/journal); both construction paths have finished importing everything
+            # by this point. Guarded like the IERS priming above: metadata scanning can raise on
+            # any installed distribution with broken dist-info, and that's not worth aborting
+            # startup over.
+            try:
+                packages = loaded_pyobs_packages()
+                log.info("Loaded pyobs packages: %s", ", ".join(f"{k}={v}" for k, v in packages.items()))
+            except Exception:
+                log.warning("Could not determine loaded pyobs package versions, continuing anyway.", exc_info=True)
+
             await self._module.startup()
             log.info("Started successfully.")
 

{pyobs_core-2.0.0.dev75 → pyobs_core-2.0.0.dev77}/pyobs/mixins/weatheraware.py

@@ -76,13 +76,14 @@ class WeatherAwareMixin:
             # do we need to park?
             if motion_status not in [MotionStatus.PARKED, MotionStatus.PARKING]:
                 # error state?
-                if is_error_state and not self.__weatheraware_is_error_state:
-                    log.error("Telescope is in error mode, cannot park.")
+                if is_error_state:
+                    # only log once when entering error state, and never try to park
+                    # while it persists -- park() would just raise again every cycle
+                    if not self.__weatheraware_is_error_state:
+                        log.error("Telescope is in error mode, cannot park.")
                 else:
-                    # parking?
-                    if motion_status != MotionStatus.PARKED:
-                        log.warning("Weather is bad, shutting down.")
-                        await msi.park()
+                    log.warning("Weather is bad, shutting down.")
+                    await msi.park()
 
             # save error state
             self.__weatheraware_is_error_state = is_error_state

{pyobs_core-2.0.0.dev75 → pyobs_core-2.0.0.dev77}/pyobs/modules/camera/basecamera.py

@@ -111,6 +111,10 @@ class BaseCamera(
         # register exception
         self._register_exception(exc.GrabImageError, 3, timespan=600, callback=self._default_remote_error_callback)
 
+        # re-publish exposure progress while exposing, so clients see a live progress bar and
+        # remaining time instead of the frozen values from the EXPOSING status transition
+        self.add_background_task(self._publish_exposure_progress)
+
     async def open(self) -> None:
         """Open module."""
         await Module.open(self)
@@ -185,7 +189,7 @@ class BaseCamera(
             return 0.0
         duration = datetime.timedelta(seconds=self._exposure.exposure_time)
         diff = self._exposure.start + duration - datetime.datetime.now(datetime.UTC)
-        return diff.total_seconds()
+        return max(diff.total_seconds(), 0.0)
 
     async def _get_exposure_progress(self) -> float:
         """Returns the progress of the current exposure in percent.
@@ -209,6 +213,29 @@ class BaseCamera(
             percentage = diff.total_seconds() / self._exposure[1] * 100.0
             return min(percentage, 100.0)
 
+    async def _publish_exposure_progress(self) -> None:
+        """Background task: re-publish IExposure state while exposing.
+
+        _change_exposure_status() only publishes IExposure on status transitions, and at the
+        EXPOSING transition self._exposure isn't set yet, so progress and exposure_time_left are
+        both 0. Without this periodic re-publish, the GUI shows a frozen 0% bar and 0.0s remaining
+        for the whole exposure.
+        """
+        while True:
+            try:
+                if self._camera_status == ExposureStatus.EXPOSING:
+                    await self.comm.set_state(
+                        IExposure,
+                        ExposureState(
+                            status=self._camera_status,
+                            progress=await self._get_exposure_progress(),
+                            exposure_time_left=await self._get_exposure_time_left(),
+                        ),
+                    )
+            except Exception:
+                pass
+            await asyncio.sleep(1.0)
+
     @abstractmethod
     async def _expose(self, exposure_time: float, open_shutter: bool, abort_event: asyncio.Event) -> Image:
         """Actually do the exposure, should be implemented by derived classes.

pyobs_core-2.0.0.dev77/pyobs/utils/versions.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from importlib.metadata import PackageNotFoundError, packages_distributions, version
+
+
+def loaded_pyobs_packages(sys_modules: Mapping[str, object] | None = None) -> dict[str, str]:
+    """Return the version of every loaded ``pyobs``-prefixed distribution.
+
+    Builds the top-level import name -> distribution name map from
+    :func:`importlib.metadata.packages_distributions`, keeps only the distributions whose
+    top-level name is present in ``sys_modules`` and whose name starts with ``pyobs``, and reads
+    each version from :func:`importlib.metadata.version`.
+
+    Args:
+        sys_modules: Module-name -> module mapping to inspect. Defaults to ``sys.modules``.
+
+    Returns:
+        Distribution name -> version, sorted by name. A distribution whose version cannot be
+        resolved (``PackageNotFoundError``) is skipped.
+
+    Note:
+        Editable installs (``pip install -e`` / ``uv pip install -e``, i.e. a dev checkout)
+        typically don't populate the file records that ``packages_distributions()`` needs to
+        derive its top-level-name -> distribution mapping, so a package installed that way is
+        silently omitted here. Not fixed since the only consumer (pyobsd/web-admin reading the
+        module's log/journal) only needs this in production, where installs are non-editable.
+    """
+
+    if sys_modules is None:
+        import sys
+
+        sys_modules = sys.modules
+
+    loaded: dict[str, str] = {}
+    for module_name, dists in packages_distributions().items():
+        if module_name not in sys_modules:
+            continue
+        for dist in dists:
+            if not dist.startswith("pyobs"):
+                continue
+            try:
+                loaded[dist] = version(dist)
+            except PackageNotFoundError:
+                continue
+
+    return dict(sorted(loaded.items()))
+
+
+__all__ = ["loaded_pyobs_packages"]

{pyobs_core-2.0.0.dev75 → pyobs_core-2.0.0.dev77}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.0.0.dev75"
+version = "2.0.0.dev77"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"