pyobs-core 2.0.0.dev10__py3-none-any.whl → 2.0.0.dev13__py3-none-any.whl

pyobs/application.py

@@ -114,6 +114,11 @@ class Application:
             class PyobsJournaldLogHandler(JournaldLogHandler):
                 """JournaldLogHandler that adds SYSLOG_IDENTIFIER=pyobs and PYOBS_MODULE per record."""
 
+                # logging.CRITICAL and logging.FATAL are both 50, so the upstream LEVELS dict
+                # literal collides and silently maps level 50 to FATAL's priority (0, "emerg")
+                # instead of CRITICAL's (2, "crit"). Override explicitly to restore priority 2.
+                LEVELS = {**JournaldLogHandler.LEVELS, logging.CRITICAL: 2}
+
                 def __init__(self, **kw: Any) -> None:
                     super().__init__(identifier="pyobs", **kw)
 

pyobs/cli/_cli.py

@@ -1,9 +1,12 @@
 import argparse
+import logging
 import os
 from typing import Any
 
 import yaml
 
+log = logging.getLogger("pyobs")
+
 
 class CLI:
     # name of section in configuration file
@@ -42,11 +45,17 @@ class CLI:
 
     def _load_config(self) -> None:
         """Load config from config file"""
-        config_file = os.path.expanduser(os.path.join("~", ".config", "pyobs.yaml"))
-        if not os.path.exists(config_file):
-            config_file = os.path.expanduser(os.path.join("/", "etc", "pyobs.yaml"))
-            if not os.path.exists(config_file):
-                return
+        candidates = [
+            os.path.expanduser(os.path.join("~", ".config", "pyobs.yaml")),
+            os.path.join("/", "etc", "pyobs.yaml"),
+            os.path.join("/", "opt", "pyobs", "storage", "pyobs.yaml"),
+        ]
+        for config_file in candidates:
+            if os.path.exists(config_file):
+                break
+        else:
+            return
+        log.info("Using config file %s.", config_file)
         with open(config_file) as f:
             cfg = yaml.safe_load(f)
             if cfg is None or self.CONFIG_SECTION not in cfg:

pyobs/cli/pyobsd.py

@@ -31,6 +31,7 @@ class PyobsDaemonCLI(CLI):
         "run_path",
         "log_path",
         "log_level",
+        "syslog",
         "chuid",
     ]
 
@@ -46,6 +47,12 @@ class PyobsDaemonCLI(CLI):
             choices=["critical", "error", "warning", "info", "debug"],
             default=self._config.get("log-level", "info"),
         )
+        self._parser.add_argument(
+            "--syslog",
+            action="store_true",
+            help="send module logs to systemd journal",
+            default=self._config.get("syslog", False),
+        )
         self._parser.add_argument("--chuid", type=str, default=self._config.get("chuid", "pyobs:pyobs"))
         self._parser.add_argument("-v", "--verbose", action="store_true")
 
@@ -64,6 +71,7 @@ class PyobsDaemonCLI(CLI):
             str(os.path.join(self._config["path"], self._config["run_path"])),
             str(os.path.join(self._config["path"], self._config["log_path"])),
             log_level=self._config["log_level"],
+            syslog=self._config["syslog"],
             chuid=self._config["chuid"],
             verbose=self._config["verbose"],
         )
@@ -89,6 +97,7 @@ class PyobsDaemon:
         run_path: str,
         log_path: str,
         log_level: str = "info",
+        syslog: bool = False,
         chuid: str | None = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -97,6 +106,7 @@ class PyobsDaemon:
         self._run_path = run_path
         self._log_path = log_path
         self._log_level = log_level
+        self._syslog = syslog
         self._verbose = verbose
 
         # parse optional user/group from chuid (format: "user:group" or "user")
@@ -298,6 +308,8 @@ class PyobsDaemon:
             self._log_level,
             self._config_file(module),
         ]
+        if self._syslog:
+            cmd.append("--syslog")
 
         if self._verbose:
             print(f"[DEBUG] Executing: {' '.join(cmd)}")

pyobs/comm/comm.py

@@ -34,10 +34,12 @@ class Comm:
 
         self._proxies: dict[str, Proxy] = {}
         self._state_subscriptions: dict[str, list[tuple[type[Interface], StateCallback]]] = {}
+        self._presence_subscriptions: dict[str, list[PresenceCallback]] = {}
         self._module: Module | None = None
         self._log_queue: asyncio.Queue[LogEvent] = asyncio.Queue()
         self._logging_task: asyncio.Task[Any] | None = None
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
+        self._registered_events: set[type[Event]] = set()
         self._closing = asyncio.Event()
 
     @property
@@ -144,7 +146,7 @@ class Comm:
 
             # subscribe to state
             for interface in interfaces:
-                if interface.state is not None:
+                if interface.has_own_state():
                     await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
 
             self._proxies[client] = proxy
@@ -265,6 +267,12 @@ class Comm:
         for interface, callback in self._state_subscriptions.pop(sender, []):
             await self.unsubscribe_state(sender, interface, callback)
 
+        # tear down any presence subscriptions held for that client -- otherwise a stale
+        # callback (e.g. bound to a since-destroyed GUI widget) lingers and can blow up
+        # the next presence update for this client, silently swallowing its reconnect
+        for callback in self._presence_subscriptions.pop(sender, []):
+            await self.unsubscribe_presence(sender, callback)
+
         return True
 
     @property
@@ -434,6 +442,7 @@ class Comm:
 
         # we also want to register all events derived from the given one
         event_classes = self._get_derived_events(event_class)
+        self._registered_events.update(event_classes)
 
         # do we have a handler?
         if handler:
@@ -590,11 +599,27 @@ class Comm:
             module: Name of remote module.
             callback: Called with (ModuleState, error_string) on each update.
         """
+        self._presence_subscriptions.setdefault(module, []).append(callback)
         await self._subscribe_presence(module, callback)
 
     async def _subscribe_presence(self, module: str, callback: PresenceCallback) -> None:
         pass
 
+    async def unsubscribe_presence(self, module: str, callback: PresenceCallback) -> None:
+        """Unsubscribe from presence updates.
+
+        Args:
+            module: Name of remote module.
+            callback: Callback that was registered.
+        """
+        subs = self._presence_subscriptions.get(module)
+        if subs is not None and callback in subs:
+            subs.remove(callback)
+        await self._unsubscribe_presence(module, callback)
+
+    async def _unsubscribe_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/xmpp/rpc.py

@@ -48,12 +48,13 @@ def xml_to_params(params_elem: ET.Element, names: list[str], types: dict[str, An
         type_hint = types.get(name, Any)
         value_elem = param_elem.find(f"{{{_NS}}}value")
         if value_elem is None:
-            result.append(None)
-            continue
+            raise ValueError(f"Malformed RPC param '{name}': missing <value> element.")
         pyobs_value = value_elem.find(f"{{{_PYOBS_NS}}}value")
         if pyobs_value is None:
-            result.append(None)
-            continue
+            raise ValueError(
+                f"Malformed RPC param '{name}': missing <value> element in namespace '{_PYOBS_NS}' "
+                f"(sender may have serialized it without the required xmlns)."
+            )
         children = list(pyobs_value)
         result.append(xml_to_value(children[0], type_hint) if children else None)
     return result
@@ -214,6 +215,10 @@ class RPC:
             response_params = return_to_xml(return_value, return_type)
             self._client.plugin["xep_0009"].make_iq_method_response(iq["id"], iq["from"], response_params).send()
 
+        except exc.ForbiddenError as e:
+            e.log(log, "WARNING", f"Forbidden call to {pmethod}: {e}")
+            self._client.plugin["xep_0009"].forbidden(iq).send()
+
         except Exception as e:
             if isinstance(e, exc.PyObsError):
                 e.log(log, "ERROR", f"Exception in call to {pmethod}: {e}", exc_info=True)

pyobs/comm/xmpp/serializer.py

@@ -27,11 +27,17 @@ strip the namespace from the tag before matching (tag.split('}')[-1]).
 from __future__ import annotations
 
 import dataclasses
+import inspect
+import types as _builtin_types
 from enum import StrEnum
-from typing import Annotated, Any, get_args, get_origin, get_type_hints
+from typing import Annotated, Any, Union, get_args, get_origin, get_type_hints
 
 from slixmpp.xmlstream import ET
 
+from ...interfaces.interface import Interface as _Interface
+from ...utils.enums import Unit
+from ...utils.time import Time as _Time
+
 # Namespace used for the <pyobs:value> wrapper in RPC
 PYOBS_NS = "urn:pyobs:rpc:1"
 
@@ -329,10 +335,184 @@ def _parse_scalar(text: str, type_hint: Any) -> Any:
     return text
 
 
+# ---------------------------------------------------------------------------
+# Interface schema (disco#info <pyobs:interface> blocks)
+# ---------------------------------------------------------------------------
+
+
+def _wire_type(hint: Any, enums: dict[str, type]) -> tuple[str, str | None]:
+    """Map a Python type hint to a (wire_type_string, unit_string|None) pair."""
+    origin = get_origin(hint)
+    args = get_args(hint)
+
+    # Annotated[T, ...] — extract optional Unit annotation
+    if origin is Annotated:
+        inner = args[0]
+        unit = next((a for a in args[1:] if isinstance(a, Unit)), None)
+        type_str, _ = _wire_type(inner, enums)
+        return type_str, unit.value if unit else None
+
+    # T | None → optional<T>  (handles typing.Union and builtin types.UnionType)
+    if origin is Union or origin is _builtin_types.UnionType:
+        non_none = [a for a in args if a is not type(None)]
+        if len(non_none) == 1:
+            inner_str, _ = _wire_type(non_none[0], enums)
+            return f"optional<{inner_str}>", None
+        return "any", None
+
+    # list[T] → array<T>
+    if origin is list:
+        inner_str, _ = _wire_type(args[0] if args else Any, enums)
+        return f"array<{inner_str}>", None
+
+    # Primitives — bool before int (bool is a subclass of int)
+    if hint is bool:
+        return "bool", None
+    if hint is int:
+        return "int32", None
+    if hint is float:
+        return "float64", None
+    if hint is str:
+        return "string", None
+    if hint is type(None):
+        return "void", None
+
+    # Time (pyobs's astropy.time.Time subclass)
+    if isinstance(hint, type) and issubclass(hint, _Time):
+        return "datetime", None
+
+    # StrEnum subclass → enum(Name) + record for <types> block
+    if isinstance(hint, type) and issubclass(hint, StrEnum) and hint is not StrEnum:
+        enums[hint.__name__] = hint
+        return f"enum({hint.__name__})", None
+
+    # dataclass → struct<Name>
+    if dataclasses.is_dataclass(hint) and isinstance(hint, type):
+        return f"struct<{hint.__name__}>", None
+
+    return "any", None
+
+
+def _interface_schema_to_xml(interface: type) -> ET.Element:
+    """Build the <{ns}interface> disco#info schema element for one Interface subclass."""
+    ns = f"urn:pyobs:interface:{interface.__name__}:{interface.version}"
+    root = ET.Element(f"{{{ns}}}interface", attrib={"name": interface.__name__})
+
+    enums: dict[str, type] = {}
+
+    # Collect <command> elements from abstract methods, MRO base-first
+    seen: set[str] = set()
+    cmd_elems: list[ET.Element] = []
+
+    for base in reversed(interface.__mro__):
+        if base in (object, _Interface):
+            continue
+        for name, member in sorted(base.__dict__.items()):
+            if name.startswith("_") or name in seen:
+                continue
+            if not getattr(member, "__isabstractmethod__", False):
+                continue
+            seen.add(name)
+
+            try:
+                hints = get_type_hints(member, include_extras=True)
+                sig = inspect.signature(member)
+            except Exception:
+                continue
+
+            cmd = ET.Element("command", attrib={"name": name})
+            for param_name, param in sig.parameters.items():
+                if param_name == "self" or param.kind in (param.VAR_KEYWORD, param.VAR_POSITIONAL):
+                    continue
+                if param_name not in hints:
+                    continue
+                type_str, unit_str = _wire_type(hints[param_name], enums)
+                attrib: dict[str, str] = {"name": param_name, "type": type_str}
+                if unit_str:
+                    attrib["unit"] = unit_str
+                ET.SubElement(cmd, "parameter", attrib=attrib)
+
+            cmd_elems.append(cmd)
+
+    # Build <state> element (after commands, so enum collection covers both)
+    state_elem: ET.Element | None = None
+    if getattr(interface, "state", None) is not None and dataclasses.is_dataclass(interface.state):
+        state_node = f"state/{interface.__name__}/{interface.version}"
+        state_elem = ET.Element("state", attrib={"node": state_node})
+        try:
+            state_hints = get_type_hints(interface.state, include_extras=True)
+        except Exception:
+            state_hints = {}
+        for f in dataclasses.fields(interface.state):
+            type_str, unit_str = _wire_type(state_hints.get(f.name, Any), enums)
+            fattrib: dict[str, str] = {"name": f.name, "type": type_str}
+            if unit_str:
+                fattrib["unit"] = unit_str
+            ET.SubElement(state_elem, "field", attrib=fattrib)
+
+    # Emit in order: <types> → <command>... → <state>
+    if enums:
+        types_elem = ET.SubElement(root, "types")
+        for enum_name, enum_cls in sorted(enums.items()):
+            enum_elem = ET.SubElement(types_elem, "enum", attrib={"name": enum_name})
+            for member in enum_cls:
+                val_elem = ET.SubElement(enum_elem, "value")
+                val_elem.text = member.value
+
+    for cmd in cmd_elems:
+        root.append(cmd)
+
+    if state_elem is not None:
+        root.append(state_elem)
+
+    return root
+
+
+def _event_schema_to_xml(event_cls: type) -> ET.Element:
+    """Build the <{ns}event> disco#info schema element for one Event subclass."""
+    ns = f"urn:pyobs:event:{event_cls.__name__}:{event_cls.version}"
+    root = ET.Element(f"{{{ns}}}event", attrib={"name": event_cls.__name__})
+
+    enums: dict[str, type] = {}
+    field_elems: list[ET.Element] = []
+
+    try:
+        hints = get_type_hints(event_cls.__init__, include_extras=True)
+        sig = inspect.signature(event_cls.__init__)
+    except Exception:
+        return root
+
+    for param_name, param in sig.parameters.items():
+        if param_name == "self" or param.kind in (param.VAR_KEYWORD, param.VAR_POSITIONAL):
+            continue
+        if param_name not in hints:
+            continue
+        type_str, unit_str = _wire_type(hints[param_name], enums)
+        attrib: dict[str, str] = {"name": param_name, "type": type_str}
+        if unit_str:
+            attrib["unit"] = unit_str
+        field_elems.append(ET.Element("field", attrib=attrib))
+
+    if enums:
+        types_elem = ET.SubElement(root, "types")
+        for enum_name, enum_cls in sorted(enums.items()):
+            enum_elem = ET.SubElement(types_elem, "enum", attrib={"name": enum_name})
+            for member in enum_cls:
+                val_elem = ET.SubElement(enum_elem, "value")
+                val_elem.text = member.value
+
+    for f in field_elems:
+        root.append(f)
+
+    return root
+
+
 __all__ = [
     "PYOBS_NS",
     "value_to_xml",
     "xml_to_value",
     "_dataclass_to_xml",
     "_xml_to_dataclass",
+    "_interface_schema_to_xml",
+    "_event_schema_to_xml",
 ]

pyobs/comm/xmpp/xep_0009/rpc.py

@@ -5,8 +5,12 @@ from slixmpp.xmlstream import ET
 class XEP_0009(XEP_0009_original):
     """Small fix for the original XEP_0009 plugin."""
 
-    def _handle_error(self, iq):
-        pass
+    def handle_error(self, iq):
+        """Route RPC-level errors (e.g. forbidden, item-not-found) through the same
+        jabber_rpc_error event as transport-level errors, instead of being silently
+        dropped -- the base class's own name for this hook, previously shadowed by a
+        same-but-underscored no-op that never actually overrode it."""
+        self.xmpp.event("jabber_rpc_error", iq)
 
     def extract_method(self, stanza):
         xml = ET.fromstring(f"{stanza}")
@@ -16,6 +20,10 @@ class XEP_0009(XEP_0009_original):
         """Expose method to public."""
         return self._item_not_found(iq)
 
+    def forbidden(self, iq):
+        """Expose method to public."""
+        return self._forbidden(iq)
+
     def send_fault(self, iq, fault_xml):
         """Expose method to public."""
         return self._send_fault(iq, fault_xml)

pyobs/comm/xmpp/xmppclient.py

@@ -32,6 +32,7 @@ class XmppClient(slixmpp.ClientXMPP):
         self._auth_event = asyncio.Event()
         self._auth_success = False
         self._jid_conflict = False
+        self._conflict_reason: str | None = None
 
         # auto-accept invitations
         self.auto_authorize = True
@@ -54,8 +55,21 @@ class XmppClient(slixmpp.ClientXMPP):
         self.add_event_handler("auth_success", lambda ev: self._auth(True))
         self.add_event_handler("failed_auth", lambda ev: self._auth(False))
         self.add_event_handler("failed_all_auth", self.failed_all_auth)
+        self.add_event_handler("stream_error", self._stream_error)
         self.add_filter("in", self._filter_messages)
 
+    def reconnect(self, wait: int | float = 2.0, reason: str = "Reconnecting") -> Any:
+        """Disconnect only, instead of slixmpp's default reconnect-in-place.
+
+        xep_0199's keepalive calls this on ping timeout. slixmpp's own
+        implementation would reconnect this same client object, while
+        XmppComm's "disconnected" handler independently spins up a brand-new
+        XmppClient. The two then fight over the same JID resource, each
+        kicking the other off the server ("replaced by new connection"),
+        forever. Leaving reconnection solely to XmppComm avoids that.
+        """
+        return self.disconnect(0.0, reason=reason)
+
     def _filter_messages(self, stanza: StanzaBase) -> StanzaBase | None:
         # if a user with same JID is already connected, we get a conflict
         if '<conflict xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" />' in str(stanza):
@@ -63,6 +77,28 @@ class XmppClient(slixmpp.ClientXMPP):
             return None
         return stanza
 
+    def _stream_error(self, error: Any) -> None:
+        """Called when the server sends a <stream:error/>, e.g. when this connection gets
+        kicked because another session took over the same JID/resource.
+
+        Args:
+            error: The stream error stanza.
+        """
+        if error["condition"] == "conflict":
+            self._jid_conflict = True
+            self._conflict_reason = error["text"] or None
+
+    @property
+    def kicked_by_conflict(self) -> bool:
+        """Whether this client was (or is being) kicked because another session connected
+        with the same JID, rather than disconnecting for some other reason."""
+        return self._jid_conflict
+
+    @property
+    def conflict_reason(self) -> str | None:
+        """Human-readable reason text sent alongside the conflict stream error, if any."""
+        return self._conflict_reason
+
     async def wait_connect(self) -> bool:
         """Wait for client to connect.