pyobs-core 2.0.0.dev1__tar.gz → 2.0.0.dev3__tar.gz

{pyobs_core-2.0.0.dev1 → pyobs_core-2.0.0.dev3}/PKG-INFO

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

{pyobs_core-2.0.0.dev1 → pyobs_core-2.0.0.dev3}/pyobs/application.py

@@ -140,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

{pyobs_core-2.0.0.dev1 → pyobs_core-2.0.0.dev3}/pyobs/comm/comm.py

@@ -4,12 +4,14 @@ import asyncio
 import functools
 import inspect
 import logging
+import sys
 from collections.abc import Callable, Coroutine
 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, ProxyType, _ProxyContext
@@ -18,6 +20,7 @@ if TYPE_CHECKING:
     from pyobs.modules import Module
 
 StateCallback = Callable[[Any], None]
+PresenceCallback = Callable[["ModuleState", str], None]
 
 log = logging.getLogger(__name__)
 
@@ -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())
@@ -129,7 +137,7 @@ class Comm:
 
             # subscribe to state
             for interface in interfaces:
-                if getattr(interface, "state", None) is not None:
+                if getattr(interface, "State", None) is not None:
                     await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
 
             self._proxies[client] = proxy
@@ -430,18 +438,86 @@ class Comm:
     ) -> None:
         pass
 
-    async def set_state(self, interface: type[Interface], state: Any) -> None:
+    @staticmethod
+    def _interface_from_state(state_cls: type) -> type:
+        outer_name = state_cls.__qualname__.rsplit(".", 1)[0]
+        return getattr(sys.modules[state_cls.__module__], outer_name)
+
+    async def set_state(self, state: Any) -> None:
         """Publish state for this module.
 
         Args:
             interface: Interface type for the state.
             state: State object to publish.
         """
+        interface = Comm._interface_from_state(type(state))
         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,
@@ -491,6 +567,20 @@ class Comm:
     ) -> 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-2.0.0.dev1 → pyobs_core-2.0.0.dev3}/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.dev3/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

{pyobs_core-2.0.0.dev1 → pyobs_core-2.0.0.dev3}/pyobs/comm/proxy.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 import types
 from collections.abc import Coroutine
@@ -169,6 +170,30 @@ class Proxy:
         """Latest known state for the given interface, or None if nothing has arrived yet."""
         return self._state.get(interface)
 
+    async def wait_for_state(
+        self,
+        interface: type[Interface],
+        timeout: float = 10.0,
+    ) -> Any:
+        """Return state immediately if available, otherwise wait for the first update."""
+        if self._state.get(interface) is not None:
+            return self._state[interface]
+
+        event = asyncio.Event()
+
+        def _notify(state: Any) -> None:
+            self._state[interface] = state
+            event.set()
+
+        # patch in a one-shot notifier alongside the existing callback
+        await self._comm.subscribe_state(self._client, interface, _notify)
+        try:
+            await asyncio.wait_for(event.wait(), timeout=timeout)
+        finally:
+            await self._comm.unsubscribe_state(self._client, interface, _notify)
+
+        return self._state.get(interface)
+
 
 class _ProxyContext(Generic[ProxyType]):
     """Returned by Comm.proxy() / Object.proxy() / Comm.safe_proxy(). Must be used as: