pyobs-core 2.22.0__tar.gz → 2.23.0__tar.gz

{pyobs_core-2.22.0 → pyobs_core-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-core
-Version: 2.22.0
+Version: 2.23.0
 Summary: robotic telescope software
 Project-URL: Homepage, https://www.pyobs.org
 Project-URL: Documentation, https://docs.pyobs.org

{pyobs_core-2.22.0 → pyobs_core-2.23.0}/pyobs/interfaces/IMotion.py

@@ -38,6 +38,8 @@ class IMotion(IReady, metaclass=ABCMeta):
             InitError: If device could not be initialized.
             InitAbortedError: If initialization was interrupted on purpose (e.g. by park() or stop_motion()); not a
                 device fault.
+            InitRefusedError: If initialization was not started because a precondition is not met (e.g. bad
+                weather); not a device fault.
         """
         ...
 

{pyobs_core-2.22.0 → pyobs_core-2.23.0}/pyobs/modules/module.py

@@ -251,8 +251,8 @@ class Module(Object, IModule, IConfig):
 
         Args:
             exc_type: Exception type (or a shared ancestor) to watch for. RemoteError also
-                counts remote domain faults, except expected PointingLimitError and
-                InitAbortedError rejections.
+                counts remote domain faults, except expected PointingLimitError,
+                InitAbortedError and InitRefusedError rejections.
             limit: Number of occurrences that triggers the callback.
             timespan: If given, only count occurrences within the last timespan seconds.
             module: If given, only count occurrences tagged as coming from this remote module
@@ -284,17 +284,18 @@ class Module(Object, IModule, IConfig):
     def _counts_as_remote_error(exception: Exception) -> bool:
         """Classify remote domain failures for broad handlers, excluding expected rejections.
 
-        Expected rejections are PointingLimitError and InitAbortedError.
+        Expected rejections are PointingLimitError, InitAbortedError and InitRefusedError.
 
         Actual RemoteError inheritance and explicit domain handlers are handled separately.
         """
         return getattr(exception, "remote_module", None) is not None and not isinstance(
-            exception, exc.PointingLimitError | exc.InitAbortedError
+            exception, exc.PointingLimitError | exc.InitAbortedError | exc.InitRefusedError
         )
 
     def _store_exception(self, exception: exc.PyobsError, module: str | None) -> None:
         # Preserve actual ancestors and classify eligible remote domain faults as RemoteError
-        # for broad severity handlers. Expected rejections (pointing limits, aborted init) retain their domain buckets.
+        # for broad severity handlers. Expected rejections (pointing limits, aborted or refused init) retain their
+        # domain buckets.
         classes: list[type] = list(type(exception).__mro__)
         if self._counts_as_remote_error(exception) and exc.RemoteError not in classes:
             classes.append(exc.RemoteError)

{pyobs_core-2.22.0 → pyobs_core-2.23.0}/pyobs/utils/exceptions.py

@@ -138,6 +138,18 @@ class InitAbortedError(PyobsError):
     pass
 
 
+class InitRefusedError(PyobsError):
+    """Initialization was not started because a precondition is not met, e.g. the weather is bad or another
+    motion is in progress. Nothing was attempted and the device is fine, so this is an expected outcome, not a
+    fault: don't alert, and call init() again only once the precondition holds. Deliberately neither a
+    MotionError nor an InitError, so that it never counts towards a module's repeated-motion-failure
+    escalation. Distinct from InitAbortedError, which means an init that was already running was cut short.
+    Remote rejections also do not count towards broad RemoteError severity handlers; explicit handlers for this
+    class or its ancestors still apply."""
+
+    pass
+
+
 class GrabImageError(PyobsError):
     pass
 

{pyobs_core-2.22.0 → pyobs_core-2.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.22.0"
+version = "2.23.0"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"

pyobs_core-2.22.0/pyobs/comm/xmpp/xep_0009/binding.py

@@ -1,170 +0,0 @@
-# Slixmpp: The Slick XMPP Library
-# Copyright (C) 2011 Nathanael C. Fritz, Dann Martens (TOMOTON).
-# This file is part of Slixmpp.
-# See the file LICENSE for copying permission.
-import base64
-import logging
-import time
-from typing import Any
-
-from slixmpp.xmlstream import ET
-
-log = logging.getLogger(__name__)
-
-_namespace = "jabber:iq:rpc"
-
-
-def fault2xml(code: int, message: str) -> ET.Element:
-    value: dict[str, Any] = dict()
-    value["faultCode"] = code
-    value["faultString"] = message
-    fault = ET.Element("fault", {"xmlns": _namespace})
-    fault.append(_py2xml((value,)))
-    return fault
-
-
-def xml2fault(params: ET.Element) -> dict[str, Any]:
-    vals = []
-    for value in params.findall(f"{{{_namespace}}}value"):
-        vals.append(_xml2py(value)[0])
-    fault = dict()
-    fault["code"] = vals[0]["faultCode"]
-    fault["string"] = vals[0]["faultString"]
-    return fault
-
-
-def py2xml(*args: Any) -> ET.Element:
-    params = ET.Element(f"{{{_namespace}}}params")
-    for x in args:
-        param = ET.Element(f"{{{_namespace}}}param")
-        param.append(_py2xml(x))
-        params.append(param)  # <params><param>...
-    return params
-
-
-def _py2xml(*args: Any) -> ET.Element:  # type: ignore[return]
-    for x in args:
-        val = ET.Element(f"{{{_namespace}}}value")
-        if x is None:
-            nil = ET.Element(f"{{{_namespace}}}nil")
-            val.append(nil)
-        elif type(x) is int:
-            i4 = ET.Element(f"{{{_namespace}}}i4")
-            i4.text = str(x)
-            val.append(i4)
-        elif type(x) is bool:
-            boolean = ET.Element(f"{{{_namespace}}}boolean")
-            boolean.text = str(int(x))
-            val.append(boolean)
-        elif type(x) is str:
-            string = ET.Element(f"{{{_namespace}}}string")
-            string.text = x
-            val.append(string)
-        elif type(x) is float:
-            double = ET.Element(f"{{{_namespace}}}double")
-            double.text = str(x)
-            val.append(double)
-        elif type(x) is rpcbase64:
-            b64 = ET.Element(f"{{{_namespace}}}base64")
-            b64.text = x.encoded()
-            val.append(b64)
-        elif type(x) is rpctime:
-            iso = ET.Element(f"{{{_namespace}}}dateTime.iso8601")
-            iso.text = str(x)
-            val.append(iso)
-        elif type(x) in (list, tuple):
-            array = ET.Element(f"{{{_namespace}}}array")
-            data = ET.Element(f"{{{_namespace}}}data")
-            for y in x:
-                data.append(_py2xml(y))
-            array.append(data)
-            val.append(array)
-        elif type(x) is dict:
-            struct = ET.Element(f"{{{_namespace}}}struct")
-            for y in x.keys():
-                member = ET.Element(f"{{{_namespace}}}member")
-                name = ET.Element(f"{{{_namespace}}}name")
-                name.text = y
-                member.append(name)
-                member.append(_py2xml(x[y]))
-                struct.append(member)
-            val.append(struct)
-        return val
-
-
-def xml2py(params: ET.Element) -> list[Any]:
-    namespace = "jabber:iq:rpc"
-    vals: list[Any] = []
-    for param in params.findall(f"{{{namespace}}}param"):
-        vals.append(_xml2py(param.find(f"{{{namespace}}}value")))
-    return vals
-
-
-def _xml2py(value: Any) -> Any:
-    namespace = "jabber:iq:rpc"
-    find_value = value.find
-    if find_value(f"{{{namespace}}}nil") is not None:
-        return None
-    if find_value(f"{{{namespace}}}i4") is not None:
-        return int(find_value(f"{{{namespace}}}i4").text)
-    if find_value(f"{{{namespace}}}int") is not None:
-        return int(find_value(f"{{{namespace}}}int").text)
-    if find_value(f"{{{namespace}}}boolean") is not None:
-        return bool(int(find_value(f"{{{namespace}}}boolean").text))
-    if find_value(f"{{{namespace}}}string") is not None:
-        return find_value(f"{{{namespace}}}string").text
-    if find_value(f"{{{namespace}}}double") is not None:
-        return float(find_value(f"{{{namespace}}}double").text)
-    if find_value(f"{{{namespace}}}base64") is not None:
-        return rpcbase64(find_value(f"{{{namespace}}}base64").text.encode())
-    if find_value(f"{{{namespace}}}Base64") is not None:
-        # Older versions of XEP-0009 used Base64
-        return rpcbase64(find_value(f"{{{namespace}}}Base64").text.encode())
-    if find_value(f"{{{namespace}}}dateTime.iso8601") is not None:
-        return rpctime(find_value(f"{{{namespace}}}dateTime.iso8601").text)
-    if find_value(f"{{{namespace}}}struct") is not None:
-        struct = {}
-        for member in find_value(f"{{{namespace}}}struct").findall(f"{{{namespace}}}member"):
-            struct[member.find(f"{{{namespace}}}name").text] = _xml2py(member.find(f"{{{namespace}}}value"))
-        return struct
-    if find_value(f"{{{namespace}}}array") is not None:
-        array = []
-        for val in find_value(f"{{{namespace}}}array").find(f"{{{namespace}}}data").findall(f"{{{namespace}}}value"):
-            array.append(_xml2py(val))
-        return array
-    raise ValueError()
-
-
-class rpcbase64:
-    def __init__(self, data: bytes):
-        # base 64 encoded string
-        self.data = data
-
-    def decode(self) -> bytes:
-        return base64.b64decode(self.data)
-
-    def __str__(self) -> str:
-        return self.decode().decode()
-
-    def encoded(self) -> str:
-        return self.data.decode()
-
-
-class rpctime:
-    def __init__(self, data: Any | None = None):
-        # assume string data is in iso format YYYYMMDDTHH:MM:SS
-        if type(data) is str:
-            self.timestamp = time.strptime(data, "%Y%m%dT%H:%M:%S")
-        elif type(data) is time.struct_time:
-            self.timestamp = data
-        elif data is None:
-            self.timestamp = time.gmtime()
-        else:
-            raise ValueError()
-
-    def iso8601(self) -> str:
-        # return a iso8601 string
-        return time.strftime("%Y%m%dT%H:%M:%S", self.timestamp)
-
-    def __str__(self) -> str:
-        return self.iso8601()