pyobs-core 1.52.16__tar.gz → 2.0.0.dev4__tar.gz

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-core
-Version: 1.52.16
+Version: 2.0.0.dev4
 Summary: robotic telescope software
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
@@ -15,6 +15,7 @@ Requires-Dist: colour<0.2,>=0.1.5
 Requires-Dist: dacite>=1.9.2
 Requires-Dist: dbus-next<0.3,>=0.2.3
 Requires-Dist: influxdb-client>=1.49.0
+Requires-Dist: logging-journald>=0.6.11
 Requires-Dist: numpy<3,>=2.2.5
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: paramiko>=3.5.1

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/pyobs/application.py

@@ -13,6 +13,7 @@ import yaml
 from pyobs.modules import Module
 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
 
 # just init logger with something here, will be overwritten in __init__
 log = logging.getLogger(__name__)
@@ -37,6 +38,7 @@ class Application:
         config: str,
         log_file: str | None = None,
         log_level: str = "info",
+        syslog: bool = False,
         influx_log: InfluxLogConfig | None = None,
         **kwargs: Any,
     ):
@@ -46,6 +48,8 @@ class Application:
             config: Name of config file.
             log_file: Name of log file, if any.
             log_level: Logging level.
+            syslog: Send log to systemd journal, tagged with SYSLOG_IDENTIFIER=pyobs
+                    and PYOBS_MODULE=<module name>. Requires logging-journald.
             influx_log: Log to influx DB.
         """
 
@@ -53,13 +57,22 @@ class Application:
         self._config = config
         config_base = os.path.splitext(os.path.basename(config))[0]
 
-        # formatter for logging, and list of logging handlers
-        formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d %(message)s")
+        # filter that injects %(pyobs_module)s into every LogRecord from the context var
+        module_name_filter = ModuleNameFilter()
+
+        # formatters — file/stream include the module name as text; journal omits
+        # timestamp/priority since those are captured natively by journald
+        formatter = logging.Formatter(
+            "%(asctime)s [%(levelname)s] (%(pyobs_module)s) %(filename)s:%(lineno)d %(message)s"
+        )
+        journal_formatter = logging.Formatter("%(pyobs_module)s %(filename)s:%(lineno)d %(message)s")
+
         handlers: list[logging.Handler] = []
 
         # create stdout logging handler
         stream_handler = logging.StreamHandler()
         stream_handler.setFormatter(formatter)
+        stream_handler.addFilter(module_name_filter)
         handlers.append(stream_handler)
 
         # create file logging handler, if log file is given
@@ -70,10 +83,30 @@ class Application:
             else:
                 file_handler = logging.handlers.WatchedFileHandler(log_file)
 
-            # add log file handler
             file_handler.setFormatter(formatter)
+            file_handler.addFilter(module_name_filter)
             handlers.append(file_handler)
 
+        # systemd journal handler?
+        if syslog:
+            from logging_journald import JournaldLogHandler  # type: ignore[import-untyped]
+
+            class PyobsJournaldLogHandler(JournaldLogHandler):  # type: ignore[misc]
+                """JournaldLogHandler that adds SYSLOG_IDENTIFIER=pyobs and PYOBS_MODULE per record."""
+
+                def __init__(self, **kw: Any) -> None:
+                    super().__init__(identifier="pyobs", **kw)
+
+                def _format_record(self, record: logging.LogRecord) -> list[tuple[str, Any]]:
+                    pairs: list[tuple[str, Any]] = super()._format_record(record)
+                    pairs.append(("PYOBS_MODULE", getattr(record, "pyobs_module", "")))
+                    return pairs
+
+            journal_handler = PyobsJournaldLogHandler()
+            journal_handler.setFormatter(journal_formatter)
+            journal_handler.addFilter(module_name_filter)
+            handlers.append(journal_handler)
+
         # influx handler?
         if influx_log is not None:
             from pyobs.utils.influxdb import InfluxHandler
@@ -91,7 +124,12 @@ class Application:
 
         # set pyobs logger
         global log
+        from pathlib import Path
+
+        from pyobs.utils.logging.context import module_name
+
         log = logging.getLogger(__name__)
+        module_name.set(Path(self._config).stem)
 
         # load config
         log.info("Loading configuration from %s...", self._config)
@@ -102,8 +140,17 @@ class Application:
         class_name = cfg["class"]
         klass = get_class_from_string(class_name)
 
-        # create event loop
-        self._loop = klass.new_event_loop()
+        # create event loop — if top-level class doesn't override new_event_loop,
+        # check child modules for one that does (e.g. pyobs_gui.GUI in a MultiModule)
+        loop_class = klass
+        if klass.new_event_loop is Module.new_event_loop:
+            for mod_cfg in cfg.get("modules", {}).values():
+                if isinstance(mod_cfg, dict) and "class" in mod_cfg:
+                    child_klass = get_class_from_string(mod_cfg["class"])
+                    if child_klass.new_event_loop is not Module.new_event_loop:
+                        loop_class = child_klass
+                        break
+        self._loop = loop_class.new_event_loop()
         asyncio.set_event_loop(self._loop)
 
         # create module and open it
@@ -137,9 +184,6 @@ class Application:
     def _signal_handler(self, sig: int) -> None:
         """React to signals and quit the module."""
 
-        # stop loop
-        # loop = asyncio.get_running_loop()
-        # loop.stop()
         self._module.quit()
 
         # reset signal handlers

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/pyobs/background_task.py

@@ -27,6 +27,13 @@ class BackgroundTask:
         self._task = asyncio.create_task(self._func_wrapper())
 
     async def _func_wrapper(self) -> None:
+        # stamp the module name into the context var so all logging within this task
+        # (and any tasks it spawns) carries the correct PYOBS_MODULE field
+        from pyobs.utils.logging.context import module_name as _module_name_var
+
+        if hasattr(self._parent, "name"):
+            _module_name_var.set(self._parent.name)
+
         start = time.time()
         finish_count = 0
 

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/pyobs/cli/pyobs.py

@@ -41,6 +41,12 @@ class PyobsCLI(CLI):
         self._parser.add_argument(
             "-l", "--log-file", type=str, help="file to write log into", default=self._config.get("log_file", None)
         )
+        self._parser.add_argument(
+            "--syslog",
+            action="store_true",
+            help="send log to systemd journal",
+            default=self._config.get("syslog", False),
+        )
         self._parser.add_argument(
             "--influx-log",
             type=str,

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/pyobs/comm/comm.py

@@ -1,25 +1,28 @@
 from __future__ import annotations
 
 import asyncio
+import functools
 import inspect
 import logging
+import sys
 from collections.abc import Callable, Coroutine
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, overload
 
 import pyobs.interfaces
 from pyobs.events import Event, LogEvent, ModuleClosedEvent
 from pyobs.interfaces import Interface
+from pyobs.utils.enums import ModuleState
 
 from .commlogging import CommLoggingHandler
-from .proxy import Proxy
+from .proxy import Proxy, ProxyType, _ProxyContext
 
 if TYPE_CHECKING:
     from pyobs.modules import Module
 
-log = logging.getLogger(__name__)
-
+StateCallback = Callable[[Any], None]
+PresenceCallback = Callable[["ModuleState", str], None]
 
-ProxyType = TypeVar("ProxyType")
+log = logging.getLogger(__name__)
 
 
 class Comm:
@@ -27,13 +30,13 @@ class Comm:
 
     __module__ = "pyobs.comm"
 
-    def __init__(self, cache_proxies: bool = True):
+    def __init__(self) -> None:
         """Creates a comm module."""
 
         self._proxies: dict[str, Proxy] = {}
+        self._state_subscriptions: dict[str, list[tuple[type[Interface], StateCallback]]] = {}
         self._module: Module | None = None
         self._log_queue: asyncio.Queue[LogEvent] = asyncio.Queue()
-        self._cache_proxies = cache_proxies
         self._logging_task: asyncio.Task[Any] | None = None
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
         self._closing = asyncio.Event()
@@ -64,9 +67,14 @@ class Comm:
         """Open module."""
 
         # add handler to global logger
-        handler = CommLoggingHandler(self)
-        handler.setLevel(logging.INFO)
-        logging.getLogger().addHandler(handler)
+        root_logger = logging.getLogger()
+        if not any(isinstance(h, CommLoggingHandler) for h in root_logger.handlers):
+            from pyobs.utils.logging.context import ModuleNameFilter
+
+            handler = CommLoggingHandler(self)
+            handler.setLevel(logging.INFO)
+            handler.addFilter(ModuleNameFilter())
+            root_logger.addHandler(handler)
 
         # start logging thread
         self._logging_task = asyncio.create_task(self._logging())
@@ -117,7 +125,7 @@ class Comm:
             return None
 
         # if client doesn't exist or we disabled caching, fetch a new proxy
-        if client not in self._proxies or not self._cache_proxies:
+        if client not in self._proxies:
             # get interfaces
             try:
                 interfaces = await self.get_interfaces(client)
@@ -126,18 +134,20 @@ class Comm:
 
             # create new proxy
             proxy = Proxy(self, client, interfaces)
+
+            # subscribe to state
+            for interface in interfaces:
+                if getattr(interface, "State", None) is not None:
+                    await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
+
             self._proxies[client] = proxy
 
         # return proxy
         return self._proxies[client]
 
-    @overload
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType]) -> ProxyType: ...
-
-    @overload
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> Any: ...
-
-    async def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> Any | ProxyType:
+    async def _resolve_proxy(
+        self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
+    ) -> Any | ProxyType:
         """Returns object directly if it is of given type. Otherwise get proxy of client with given name and check type.
 
         If name_or_object is an object:
@@ -184,16 +194,41 @@ class Comm:
             # completely wrong...
             raise ValueError(f'Given parameter is neither a name nor an object of requested type "{obj_type}".')
 
-    async def safe_proxy(
+    async def _safe_resolve_proxy(
         self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
     ) -> Any | ProxyType | None:
         """Calls proxy() in a safe way and returns None instead of raising an exception."""
 
         try:
-            return await self.proxy(name_or_object, obj_type)
+            return await self._resolve_proxy(name_or_object, obj_type)
         except ValueError:
             return None
 
+    @overload
+    def proxy(self, name_or_object: str | object, obj_type: type[ProxyType]) -> _ProxyContext[ProxyType]: ...
+    @overload
+    def proxy(self, name_or_object: str | object, obj_type: None = None) -> _ProxyContext[Any]: ...
+
+    def proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> _ProxyContext[Any]:
+        """Returns a context manager; use as `async with self.proxy(...) as x:`."""
+        return _ProxyContext(self._resolve_proxy(name_or_object, obj_type))
+
+    @overload
+    def safe_proxy(
+        self, name_or_object: str | object, obj_type: type[ProxyType]
+    ) -> _ProxyContext[ProxyType | None]: ...
+    @overload
+    def safe_proxy(self, name_or_object: str | object, obj_type: None = None) -> _ProxyContext[Any]: ...
+
+    def safe_proxy(self, name_or_object: str | object, obj_type: type[ProxyType] | None = None) -> _ProxyContext[Any]:
+        """Same as proxy(), but yields None inside the block instead of raising."""
+        return _ProxyContext(self._safe_resolve_proxy(name_or_object, obj_type))
+
+    async def has_proxy(self, name_or_object: str | object, obj_type: type[Any] | None = None) -> bool:
+        """True if a proxy of the given type can currently be resolved. Doesn't keep a reference
+        to it, so doesn't need async with the way proxy()/safe_proxy() do."""
+        return await self._safe_resolve_proxy(name_or_object, obj_type) is not None
+
     async def _client_disconnected(self, event: Event, sender: str) -> bool:
         """Called when a client disconnects.
 
@@ -203,9 +238,15 @@ class Comm:
 
         """
 
-        # if a client disconnects, we remove its proxy
+        # if a client disconnects, clear its proxy state then evict it
         if sender in self._proxies:
+            self._proxies[sender].clear_state()
             del self._proxies[sender]
+
+        # tear down any state subscriptions held for that client
+        for interface, callback in self._state_subscriptions.pop(sender, []):
+            await self.unsubscribe_state(sender, interface, callback)
+
         return True
 
     @property
@@ -397,6 +438,143 @@ class Comm:
     ) -> None:
         pass
 
+    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.
+        """
+        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:
+        """Publish capabilities for this module.
+
+        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:
+            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:
+        pass
+
+    async def get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
+        """Fetch and deserialize capabilities for a remote module's interface.
+
+        Args:
+            module: Module name (e.g. "camera").
+            interface: Interface class whose Capabilities dataclass to fetch.
+
+        Returns:
+            Deserialized Capabilities dataclass instance, or None if not published.
+        """
+        return await self._get_capabilities(module, interface)
+
+    async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
+        return None
+
+    async def set_presence(self, state: ModuleState, error_string: str = "") -> None:
+        """Publish presence for this module (module lifecycle state).
+
+        Called automatically by Module.set_state — not intended to be called
+        directly by module authors.
+
+        Args:
+            state: Current module lifecycle state.
+            error_string: Error message, used when state is ERROR.
+        """
+        await self._set_presence(state, error_string)
+
+    async def _set_presence(self, state: ModuleState, error_string: str = "") -> None:
+        pass
+
+    def get_client_state(self, module: str) -> tuple[ModuleState, str] | None:
+        """Return the last known presence state of a connected module.
+
+        Returns (ModuleState, error_string) or None if the module is not connected.
+        This replaces the old get_state()/get_error_string() RPC pattern.
+        """
+        return self._get_client_state(module)
+
+    def _get_client_state(self, module: str) -> tuple[ModuleState, str] | None:
+        return None
+
+    async def subscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        """Subscribe to state updates for a given module and interface.
+
+        Delivers the current value immediately on subscribe.
+
+        Args:
+            module: Name of remote module.
+            interface: Interface type to subscribe to.
+            callback: Called with state object on each update.
+        """
+        self._state_subscriptions.setdefault(module, []).append((interface, callback))
+        await self._subscribe_state(module, interface, callback)
+
+    async def _subscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        pass
+
+    async def unsubscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        """Unsubscribe from state updates.
+
+        Args:
+            module: Name of remote module.
+            interface: Interface type to unsubscribe from.
+            callback: Callback that was registered.
+        """
+        await self._unsubscribe_state(module, interface, callback)
+
+    async def _unsubscribe_state(
+        self,
+        module: str,
+        interface: type[Interface],
+        callback: StateCallback,
+    ) -> None:
+        pass
+
+    async def subscribe_presence(self, module: str, callback: PresenceCallback) -> None:
+        """Subscribe to presence updates for a given module.
+
+        Delivers the current value immediately, then on every change.
+
+        Args:
+            module: Name of remote module.
+            callback: Called with (ModuleState, error_string) on each update.
+        """
+        await self._subscribe_presence(module, callback)
+
+    async def _subscribe_presence(self, module: str, callback: PresenceCallback) -> None:
+        pass
+
     def _send_event_to_module(self, event: Event, from_client: str) -> None:
         """Send an event to all connected modules.
 

{pyobs_core-1.52.16 → pyobs_core-2.0.0.dev4}/pyobs/comm/commlogging.py

@@ -34,9 +34,12 @@ class CommLoggingHandler(logging.Handler):
         # format message
         msg = self._formatter.format(rec)  # noqa: UP031
 
-        # create and send event
+        # create and send event — use pyobs_module if set (MultiModule context)
         time = datetime.fromtimestamp(rec.created, tz=UTC).strftime("%Y-%m-%dT%H:%M:%S.%f")
-        entry = LogEvent(time, rec.levelname, os.path.basename(rec.pathname), rec.funcName, rec.lineno, msg)
+        sender = getattr(rec, "pyobs_module", "") or ""
+        entry = LogEvent(
+            time, rec.levelname, os.path.basename(rec.pathname), rec.funcName, rec.lineno, msg, sender=sender
+        )
         self._comm.log_message(entry)
 
 

pyobs_core-2.0.0.dev4/pyobs/comm/local/localcomm.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from pyobs.comm import Comm
+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
+
+
+class LocalComm(Comm):
+    def __init__(self, name: str, *args: Any, **kwargs: Any):
+        Comm.__init__(self, *args, **kwargs)
+
+        self._name = name
+        self._network = LocalNetwork()
+        self._network.connect_client(self)
+
+        # in-memory state and capabilities storage
+        self._states: dict[str, Any] = {}  # node -> state object
+        self._state_handlers: dict[str, list[tuple[type[Interface], Callable[[Any], None]]]] = {}
+        self._capabilities: dict[type[Interface], Any] = {}  # interface -> Capabilities object
+        self._presence: tuple[ModuleState, str] = (ModuleState.READY, "")
+        self._presence_callbacks: dict[str, list[PresenceCallback]] = {}
+
+    @property
+    def name(self) -> str:
+        """Name of this client."""
+        return self._name
+
+    @property
+    def clients(self) -> list[str]:
+        """Returns list of currently connected clients."""
+        return self._network.get_client_names()
+
+    async def get_interfaces(self, client: str) -> list[type[Interface]]:
+        """Returns list of interfaces for given client."""
+        remote_client = self._network.get_client(client)
+        return [] if not remote_client.has_module else remote_client.module.interfaces
+
+    async def _supports_interface(self, client: str, interface: type[Interface]) -> bool:
+        """Checks whether the given client supports the given interface."""
+        interfaces = await self.get_interfaces(client)
+        return interface in interfaces
+
+    async def execute(self, client: str, method: str, annotation: dict[str, Any], *args: Any) -> Any:
+        """Execute a given method on a remote client."""
+        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
+
+    async def send_event(self, event: Event) -> None:
+        """Send an event to other clients."""
+        from pyobs.events import LogEvent as _LogEvent
+
+        sender = self.name
+        if isinstance(event, _LogEvent) and event.sender:
+            sender = event.sender
+        remote_clients = self._network.get_clients()
+        for client in remote_clients:
+            client._send_event_to_module(event, sender)
+
+    async def _register_events(
+        self, events: list[type[Event]], handler: Callable[[Event, str], Coroutine[Any, Any, bool]] | None = None
+    ) -> None:
+        pass
+
+    # -------------------------------------------------------------------------
+    # State
+    # -------------------------------------------------------------------------
+
+    async def _set_state(self, interface: type[Interface], state: Any) -> None:
+        """Publish state locally and dispatch to subscribers."""
+        node = f"pyobs:state:{self._name}:{interface.__name__}:{interface.version}"
+        self._states[node] = state
+
+        # dispatch to all subscribers for this node
+        if node in self._state_handlers:
+            for _, callback in self._state_handlers[node]:
+                callback(state)
+
+    async def _subscribe_state(self, module: str, interface: type[Interface], callback: Callable[[Any], None]) -> None:
+        """Subscribe to state updates from a remote module."""
+        node = f"pyobs:state:{module}:{interface.__name__}:{interface.version}"
+
+        if node not in self._state_handlers:
+            self._state_handlers[node] = []
+        self._state_handlers[node].append((interface, callback))
+
+        # also register on the remote comm so it can dispatch to us
+        try:
+            remote = self._network.get_client(module)
+            if node not in remote._state_handlers:
+                remote._state_handlers[node] = []
+            remote._state_handlers[node].append((interface, callback))
+
+            # deliver current value immediately if available
+            if node in remote._states:
+                callback(remote._states[node])
+        except KeyError:
+            pass  # remote not connected yet
+
+    # -------------------------------------------------------------------------
+    # Capabilities
+    # -------------------------------------------------------------------------
+
+    async def _set_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
+        """Store capabilities locally."""
+        self._capabilities[interface] = capabilities
+
+    async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
+        """Fetch capabilities from a remote module."""
+        if not hasattr(interface, "Capabilities"):
+            return None
+        try:
+            remote = self._network.get_client(module)
+            return remote._capabilities.get(interface)
+        except KeyError:
+            return None
+
+    # -------------------------------------------------------------------------
+    # Presence
+    # -------------------------------------------------------------------------
+
+    async def _set_presence(self, state: ModuleState, error_string: str = "") -> None:
+        """Store presence state and dispatch to all subscribers."""
+        self._presence = (state, error_string)
+        for client in self._network.get_clients():
+            for cb in client._presence_callbacks.get(self._name, []):
+                cb(state, error_string)
+
+    def _get_client_state(self, module: str) -> tuple[ModuleState, str] | None:
+        """Return presence state of a connected module."""
+        try:
+            remote = self._network.get_client(module)
+            return remote._presence
+        except KeyError:
+            return None
+
+    async def _subscribe_presence(self, module: str, callback: PresenceCallback) -> None:
+        """Register a presence callback and deliver the current state immediately."""
+        self._presence_callbacks.setdefault(module, []).append(callback)
+        try:
+            remote = self._network.get_client(module)
+            callback(*remote._presence)
+        except KeyError:
+            pass