pyobs-core 2.0.0.dev57__tar.gz → 2.0.0.dev59__tar.gz

{pyobs_core-2.0.0.dev57 → pyobs_core-2.0.0.dev59}/PKG-INFO

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

{pyobs_core-2.0.0.dev57 → pyobs_core-2.0.0.dev59}/pyobs/application.py

@@ -22,11 +22,14 @@ log = logging.getLogger(__name__)
 
 
 # --- IERS offline fallback ---------------------------------------------
-# When PYOBS_IERS_OFFLINE=1, skip live IERS/USNO downloads and rely on the
-# astropy-iers-data snapshot bundled with the installed astropy package.
-# Useful when the upstream IERS servers are down/unreachable, or when
-# running on a telescope control machine without outbound internet access.
-if os.environ.get("PYOBS_IERS_OFFLINE", "").lower() in ("1", "true", "yes"):
+# Skip live IERS/USNO downloads and rely on the astropy-iers-data snapshot bundled with the
+# installed astropy package. Useful when the upstream IERS servers are down/unreachable/slow,
+# or when running on a telescope control machine without reliable outbound internet access --
+# astropy's own auto-refresh (IERS_Auto, triggered from inside coordinate transforms like
+# Observer.altaz) does a synchronous network fetch inline wherever it's called from, which can
+# stall an asyncio event loop for as long as that fetch takes if invoked from a module's main
+# thread (see pyobs.modules.telescope.basetelescope._update_celestial_headers).
+def _disable_iers_auto_download() -> None:
     from astropy.utils.iers import conf as iers_conf
 
     iers_conf.auto_download = False
@@ -34,11 +37,18 @@ if os.environ.get("PYOBS_IERS_OFFLINE", "").lower() in ("1", "true", "yes"):
     iers_conf.iers_degraded_accuracy = "warn"
 
     log.warning(
-        "PYOBS_IERS_OFFLINE is set — disabling IERS auto-download and "
-        "relying on the bundled astropy-iers-data snapshot. Earth "
-        "orientation/UT1-UTC accuracy may degrade for predictions far "
-        "from the snapshot date."
+        "IERS auto-download disabled — relying on the bundled astropy-iers-data snapshot. "
+        "Earth orientation/UT1-UTC accuracy may degrade for predictions far from the "
+        "snapshot date."
     )
+
+
+# PYOBS_IERS_OFFLINE=1 kept as a standalone env-var trigger for anyone not going through the
+# `pyobs` CLI's config/env machinery (e.g. importing Application directly). The CLI-driven path
+# (Application.__init__'s iers_offline kwarg, wired from pyobs.cli.pyobs's GLOBAL_CONFIG_KEYS)
+# calls the same _disable_iers_auto_download() below instead.
+if os.environ.get("PYOBS_IERS_OFFLINE", "").lower() in ("1", "true", "yes"):
+    _disable_iers_auto_download()
 # -------------------------------------------------------------------------
 
 # turn RuntimeWarnings into errors
@@ -83,6 +93,7 @@ class Application:
         log_level: str = "info",
         syslog: bool = False,
         influx_log: InfluxLogConfig | None = None,
+        iers_offline: bool = False,
         **kwargs: Any,
     ):
         """Initializes a pyobs application.
@@ -103,6 +114,11 @@ class Application:
             log_level: Logging level.
             syslog: Send log to systemd journal, tagged with SYSLOG_IDENTIFIER=pyobs
                     and PYOBS_MODULE=<module name>. Requires logging-journald.
+            iers_offline: Disable astropy's IERS/leap-second auto-download (see
+                _disable_iers_auto_download's docstring above). Same effect as setting
+                PYOBS_IERS_OFFLINE=1, but sourced from pyobs's own config/CLI machinery
+                (pyobs.cli.pyobs's GLOBAL_CONFIG_KEYS) instead of a bare env var, so it applies
+                the same way regardless of how the module process was spawned.
             influx_log: Log to influx DB.
         """
         if (config is None) == (module_factory is None):
@@ -110,6 +126,9 @@ class Application:
         if module_factory is not None and loop_module_class is None:
             raise ValueError("loop_module_class is required when module_factory is given.")
 
+        if iers_offline:
+            _disable_iers_auto_download()
+
         # get config name without path and extension
         self._config = config
         config_base = (

{pyobs_core-2.0.0.dev57 → pyobs_core-2.0.0.dev59}/pyobs/cli/pyobs.py

@@ -20,8 +20,10 @@ class PyobsCLI(CLI):
     # list of parameters that can be defined in the config file
     GLOBAL_CONFIG_KEYS = [
         "log_level",
+        "syslog",
         "influx_log",
         "debug_time",
+        "iers_offline",
     ]
 
     def init_cli(self) -> None:
@@ -54,6 +56,12 @@ class PyobsCLI(CLI):
             help="send to influx log: <host> <token> <org> <bucket>",
             default=self._config.get("influx_log", None),
         )
+        self._parser.add_argument(
+            "--iers-offline",
+            action="store_true",
+            help="disable astropy IERS/leap-second auto-download, use the bundled snapshot",
+            default=self._config.get("iers_offline", False),
+        )
 
         # debug stuff
         self._parser.add_argument(

{pyobs_core-2.0.0.dev57 → pyobs_core-2.0.0.dev59}/pyobs/cli/pyobsd.py

@@ -69,7 +69,16 @@ class PyobsDaemonCLI(CLI):
         sp.add_parser("start", help="start modules").add_argument("modules", type=str, nargs="*")
         sp.add_parser("stop", help="stop modules").add_argument("modules", type=str, nargs="*")
         sp.add_parser("restart", help="restart modules").add_argument("modules", type=str, nargs="*")
-        sp.add_parser("status", help="status of modules").add_argument("--json", action="store_true")
+        status_parser = sp.add_parser("status", help="status of modules")
+        status_parser.add_argument("--json", action="store_true")
+        status_parser.add_argument(
+            "--cpu-interval",
+            type=float,
+            default=None,
+            metavar="SECONDS",
+            help="measure CPU%% over this many seconds (shared across all modules, one sleep "
+            "total, not one per module); omitted by default since it makes status blocking",
+        )
         sp.add_parser("list", help="list of modules")
         sp.add_parser("logs", help="show/follow module logs via journalctl").add_argument(
             "args", nargs=argparse.REMAINDER, help="[module] [journalctl arguments...]"
@@ -97,7 +106,7 @@ class PyobsDaemonCLI(CLI):
             case "restart":
                 daemon.restart(modules=self._config["modules"])
             case "status":
-                daemon.status(print_json=self._config["json"])
+                daemon.status(print_json=self._config["json"], cpu_interval=self._config["cpu_interval"])
             case "list":
                 daemon.list_modules()
             case "logs":
@@ -214,15 +223,41 @@ class PyobsDaemon:
         return None
 
     def _process_info(self, pid: int) -> dict[str, Any]:
-        """Return uptime (seconds), cpu_percent, and rss_mb for a running PID."""
+        """Return uptime (seconds) and rss_mb for a running PID. No CPU -- that needs a
+        shared sampling window across all processes, see _sample_cpu_percent."""
         try:
             proc = psutil.Process(pid)
             uptime = time.time() - proc.create_time()
-            cpu = proc.cpu_percent(interval=0.1)
             rss_mb = proc.memory_info().rss / 1024 / 1024
-            return {"uptime": uptime, "cpu": cpu, "rss_mb": rss_mb}
+            return {"uptime": uptime, "rss_mb": rss_mb}
         except psutil.NoSuchProcess:
-            return {"uptime": 0.0, "cpu": 0.0, "rss_mb": 0.0}
+            return {"uptime": 0.0, "rss_mb": 0.0}
+
+    @staticmethod
+    def _sample_cpu_percent(pids: list[int], interval: float) -> dict[int, float]:
+        """Sample CPU% for multiple PIDs over one shared interval, instead of the
+        interval-per-process cost of calling Process.cpu_percent(interval=...) serially --
+        that would take len(pids) * interval seconds and grows with the number of modules.
+        psutil.cpu_percent(interval=None) after construction always returns 0.0 (it has no
+        prior sample to diff against); it's the second, unblocked call after the shared
+        sleep that reports the percentage actually elapsed, so pids share a single sleep.
+        """
+        procs = {}
+        for pid in pids:
+            try:
+                proc = psutil.Process(pid)
+                proc.cpu_percent(interval=None)  # prime -- discard the meaningless 0.0
+                procs[pid] = proc
+            except psutil.NoSuchProcess:
+                continue
+        time.sleep(interval)
+        result = {}
+        for pid, proc in procs.items():
+            try:
+                result[pid] = proc.cpu_percent(interval=None)
+            except psutil.NoSuchProcess:
+                result[pid] = 0.0
+        return result
 
     @staticmethod
     def _fmt_uptime(seconds: float) -> str:
@@ -267,7 +302,7 @@ class PyobsDaemon:
         time.sleep(1)
         self.start(modules=modules)
 
-    def status(self, print_json: bool = False) -> None:
+    def status(self, print_json: bool = False, cpu_interval: float | None = None) -> None:
         configs = self._list_configs()
         # map "active" (no leading underscore) name -> config name, so that
         # PID files (always named without underscore) can be matched back to
@@ -278,13 +313,19 @@ class PyobsDaemon:
         pid_stems = [self._module(p) for p in glob.glob(os.path.join(self._run_path, "*.pid"))]
         modules = sorted(set(configs) | {active_to_config.get(s, s) for s in pid_stems})
 
+        pids = {module: pid for module in modules if (pid := self._running_pid(module)) is not None}
+        # CPU% is off by default -- a meaningful reading needs a real sampling window (see
+        # _sample_cpu_percent), and forcing that cost on every plain "status" call would make
+        # it slow for no benefit when nobody's looking at CPU. Only pay for it if asked.
+        cpu_by_pid = self._sample_cpu_percent(list(pids.values()), cpu_interval) if cpu_interval else {}
+
         if print_json:
             result: dict[str, Any] = {}
             for module in modules:
-                pid = self._running_pid(module)
+                pid = pids.get(module)
                 if pid is not None:
                     info = self._process_info(pid)
-                    result[module] = {"running": True, "pid": pid, **info}
+                    result[module] = {"running": True, "pid": pid, "cpu": cpu_by_pid.get(pid), **info}
                 else:
                     result[module] = {"running": False}
             print(json.dumps(result))
@@ -293,13 +334,15 @@ class PyobsDaemon:
             print(f"{'module':<30}  {'status':<8}  {'uptime':>12}  {'cpu':>6}  {'rss':>8}")
             print("-" * 72)
             for module in modules:
-                pid = self._running_pid(module)
+                pid = pids.get(module)
                 if pid is not None:
                     info = self._process_info(pid)
+                    cpu = cpu_by_pid.get(pid)
+                    cpu_str = f"{cpu:>5.1f}%" if cpu is not None else f"{'-':>6}"
                     print(
                         f"{module:<30}  {'running':<8}  "
                         f"{self._fmt_uptime(info['uptime']):>12}  "
-                        f"{info['cpu']:>5.1f}%  "
+                        f"{cpu_str}  "
                         f"{info['rss_mb']:>6.1f} MB"
                     )
                 else:

{pyobs_core-2.0.0.dev57 → pyobs_core-2.0.0.dev59}/pyproject.toml

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