pyobs-core 2.0.0.dev1__py3-none-any.whl → 2.0.0.dev4__py3-none-any.whl

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/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
@@ -442,6 +450,68 @@ class Comm:
     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 +561,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/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/comm/local/localcomm.py

@@ -1,9 +1,13 @@
+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
@@ -17,6 +21,13 @@ class LocalComm(Comm):
         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."""
@@ -24,54 +35,21 @@ class LocalComm(Comm):
 
     @property
     def clients(self) -> list[str]:
-        """Returns list of currently connected clients.
-
-        Returns:
-            (list) List of currently connected clients.
-        """
+        """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.
-
-        Args:
-            client: Name of client.
-
-        Returns:
-            List of supported interfaces.
-
-        Raises:
-            IndexError: If client cannot be found.
-        """
+        """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.
-
-        Args:
-            client: Client to check.
-            interface: Interface to check.
-
-        Returns:
-            Whether interface is supported.
-        """
+        """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.
-
-        Args:
-            client (str): ID of client.
-            method (str): Method to call.
-            annotation: Method annotation.
-            *args: List of parameters for given method.
-
-        Returns:
-            Passes through return from method call.
-        """
-
+        """Execute a given method on a remote client."""
         remote_client = self._network.get_client(client)
         if remote_client.module is None:
             raise ValueError
@@ -82,17 +60,98 @@ class LocalComm(Comm):
         return real_results
 
     async def send_event(self, event: Event) -> None:
-        """Send an event to other clients.
-
-        Args:
-            event (Event): Event to send
-        """
+        """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, self.name)
+            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/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: