pyobs-core 1.53.0__tar.gz → 2.0.0.dev3__tar.gz

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

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

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

@@ -98,7 +98,7 @@ class Application:
                     super().__init__(identifier="pyobs", **kw)
 
                 def _format_record(self, record: logging.LogRecord) -> list[tuple[str, Any]]:
-                    pairs = super()._format_record(record)
+                    pairs: list[tuple[str, Any]] = super()._format_record(record)
                     pairs.append(("PYOBS_MODULE", getattr(record, "pyobs_module", "")))
                     return pairs
 
@@ -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-1.53.0 → pyobs_core-2.0.0.dev3}/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,149 @@ class Comm:
     ) -> None:
         pass
 
+    @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,
+        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.53.0 → 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-1.53.0 → pyobs_core-2.0.0.dev3}/pyobs/comm/proxy.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 import types
-from typing import TYPE_CHECKING, Any, get_type_hints
+from collections.abc import Coroutine
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, get_type_hints
 
 from pyobs.interfaces import Interface
 from pyobs.utils.types import cast_bound_arguments_to_simple
@@ -10,6 +12,9 @@ from pyobs.utils.types import cast_bound_arguments_to_simple
 if TYPE_CHECKING:
     from pyobs.comm import Comm
 
+"""Class of a proxy."""
+ProxyType = TypeVar("ProxyType")
+
 
 class Proxy:
     """A proxy for remote pyobs modules."""
@@ -48,6 +53,9 @@ class Proxy:
         # create methods
         self._methods = self._create_methods()
 
+        # store state
+        self._state: dict[type[Interface], Any] = {}
+
     @property
     def name(self) -> str:
         """Name of the client."""
@@ -150,5 +158,59 @@ class Proxy:
 
         return inner
 
+    def update_state(self, interface: type[Interface], state: Any) -> None:
+        """Called by Comm whenever a new state arrives. Not intended to be called directly by module code."""
+        self._state[interface] = state
+
+    def clear_state(self) -> None:
+        """Clear all cached state. Called by Comm when the remote module disconnects."""
+        self._state.clear()
+
+    def state(self, interface: type[Interface]) -> Any | None:
+        """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:
+    async with self.proxy("camera", ICooling) as camera:
+        ...
+    """
+
+    def __init__(self, coro: Coroutine[Any, Any, ProxyType]) -> None:
+        self._coro = coro
+
+    async def __aenter__(self) -> ProxyType:
+        return await self._coro
+
+    async def __aexit__(self, *exc_info: Any) -> None:
+        # intentionally a no-op: the underlying Proxy is owned and cached
+        # by Comm, not by this block, and stays alive for other callers.
+        pass
+
 
 __all__ = ["Proxy"]