pyobs-core 2.0.0.dev15__tar.gz → 2.0.0.dev17__tar.gz

{pyobs_core-2.0.0.dev15 → pyobs_core-2.0.0.dev17}/PKG-INFO

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

pyobs_core-2.0.0.dev17/pyobs/interfaces/IStructuredConfig.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.config_schema import ConfigFieldSchema, ConfigSchema  # re-export
+from ..utils.time import Time
+from .IConfig import ConfigScalar
+from .interface import Interface
+
+ConfigValue = ConfigScalar | list["ConfigValue"] | dict[str, "ConfigValue"]
+
+
+@dataclass
+class ConfigAppliedState:
+    config: dict[str, ConfigValue]
+    time: Time = field(default_factory=Time.now)
+
+
+class IStructuredConfig(Interface, metaclass=ABCMeta):
+    """The module accepts a whole structured (possibly nested) config
+    object in one call, rather than per-field get/set (see IConfig for
+    the per-field variant)."""
+
+    __module__ = "pyobs.interfaces"
+
+    capabilities = ConfigSchema
+    state = ConfigAppliedState
+
+    @abstractmethod
+    async def set_config(self, config: dict[str, ConfigValue], **kwargs: Any) -> None:
+        """Apply a full structured config to this module.
+
+        Args:
+            config: Nested dict matching this module's ConfigSchema
+                (fetch via get_capabilities). Values are validated and
+                deserialized into the module's internal config dataclass.
+
+        Raises:
+            ValueError: If config doesn't match the module's schema, or
+                values fail validation.
+        """
+        ...
+
+
+__all__ = ["IStructuredConfig", "ConfigAppliedState", "ConfigSchema", "ConfigFieldSchema"]

{pyobs_core-2.0.0.dev15 → pyobs_core-2.0.0.dev17}/pyobs/interfaces/__init__.py

@@ -55,6 +55,7 @@ from .IRunning import IRunning, RunningState
 from .IScriptRunner import IScriptRunner
 from .ISpectrograph import ISpectrograph
 from .IStartStop import IStartStop
+from .IStructuredConfig import ConfigAppliedState, ConfigFieldSchema, ConfigSchema, IStructuredConfig
 from .ISyncTarget import ISyncTarget
 from .ITelescope import ITelescope
 from .ITemperatures import ITemperatures, SensorReading, TemperaturesState
@@ -142,6 +143,10 @@ __all__ = [
     "RunningState",
     "IScriptRunner",
     "IStartStop",
+    "IStructuredConfig",
+    "ConfigAppliedState",
+    "ConfigSchema",
+    "ConfigFieldSchema",
     "ISyncTarget",
     "ITelescope",
     "ITemperatures",

{pyobs_core-2.0.0.dev15 → pyobs_core-2.0.0.dev17}/pyobs/modules/camera/basevideo.py

@@ -147,6 +147,7 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         self._app.add_routes(
             [
                 web.get("/", self.web_handler),
+                web.get("/ping", self.ping_handler),
                 web.get("/video.mjpg", self.video_handler),
                 web.get("/{filename}", self.image_handler),
             ]
@@ -194,6 +195,17 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         """
         return web.Response(text=INDEX_HTML, content_type="text/html")
 
+    async def ping_handler(self, request: web.Request) -> web.Response:
+        """Handles GET access to /ping for testing connectivity.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            Response with a JSON status.
+        """
+        return web.json_response({"status": "ok"})
+
     async def video_handler(self, request: web.Request) -> web.StreamResponse:
         """Handles access to /video.mjpg and returns the video.
 

{pyobs_core-2.0.0.dev15 → pyobs_core-2.0.0.dev17}/pyobs/modules/utils/httpfilecache.py

@@ -34,7 +34,13 @@ class HttpFileCache(Module):
 
         # define web server
         self._app = web.Application(client_max_size=self._max_file_size)
-        self._app.add_routes([web.get("/{filename}", self.download_handler), web.post("/", self.upload_handler)])
+        self._app.add_routes(
+            [
+                web.get("/ping", self.ping_handler),
+                web.get("/{filename}", self.download_handler),
+                web.post("/", self.upload_handler),
+            ]
+        )
         self._runner = web.AppRunner(self._app)
         self._site: web.TCPSite | None = None
 
@@ -61,6 +67,17 @@ class HttpFileCache(Module):
         """Whether the server is started."""
         return self._is_listening
 
+    async def ping_handler(self, request: web.Request) -> web.Response:
+        """Handles GET access to /ping for testing connectivity.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            Response with a JSON status.
+        """
+        return web.json_response({"status": "ok"})
+
     async def download_handler(self, request: web.Request) -> web.Response:
         """Handles GET access to /{filename} and returns image.
 

pyobs_core-2.0.0.dev17/pyobs/robotic/scheduler/targets/__init__.py

@@ -0,0 +1,7 @@
+from .dynamictarget import DynamicTarget
+from .heliocentricpolartarget import HeliocentricPolarTarget
+from .helioprojectivetarget import HelioprojectiveTarget
+from .siderealtarget import SiderealTarget
+from .target import Target
+
+__all__ = ["Target", "DynamicTarget", "HeliocentricPolarTarget", "HelioprojectiveTarget", "SiderealTarget"]

pyobs_core-2.0.0.dev15/pyobs/robotic/scheduler/targets/heliocentricpolar.py → pyobs_core-2.0.0.dev17/pyobs/robotic/scheduler/targets/heliocentricpolartarget.py

@@ -7,7 +7,7 @@ from pyobs.utils.time import Time
 from .target import Target
 
 
-class HeliocentricPolar(Target):
+class HeliocentricPolarTarget(Target):
     mu: float
     psi: float
 
@@ -37,4 +37,4 @@ class HeliocentricPolar(Target):
         return f"{self.name} ({self.coord})"
 
 
-__all__ = ["HeliocentricPolar"]
+__all__ = ["HeliocentricPolarTarget"]

pyobs_core-2.0.0.dev15/pyobs/robotic/scheduler/targets/helioprojectiveradialarget.py → pyobs_core-2.0.0.dev17/pyobs/robotic/scheduler/targets/helioprojectivetarget.py

@@ -5,22 +5,22 @@ from pyobs.utils.time import Time
 from .target import Target
 
 
-class HelioprojectiveRadialTarget(Target):
-    psi: float
-    delta: float
+class HelioprojectiveTarget(Target):
+    tx: float
+    ty: float
 
     @property
     def coord(self) -> SkyCoord:
         return self.coordinates(Time.now())
 
     def coordinates(self, time: Time) -> SkyCoord:
-        from sunpy.coordinates import HelioprojectiveRadial
+        from sunpy.coordinates import Helioprojective
 
         return SkyCoord(
-            self.psi,
-            self.delta,
-            unit="deg",
-            frame=HelioprojectiveRadial,
+            self.tx,
+            self.ty,
+            unit="arcsec",
+            frame=Helioprojective,
             observer="earth",
             obstime=time,
         )
@@ -29,4 +29,4 @@ class HelioprojectiveRadialTarget(Target):
         return f"{self.name} ({self.coord})"
 
 
-__all__ = ["HelioprojectiveRadialTarget"]
+__all__ = ["HelioprojectiveTarget"]

pyobs_core-2.0.0.dev17/pyobs/utils/config_schema.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+import functools
+import types
+import typing
+from typing import Annotated, Any, get_args, get_origin, get_type_hints
+
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
+
+from pyobs.utils.enums import Unit
+
+
+@dataclasses.dataclass
+class ConfigFieldSchema:
+    type: str
+    unit: Unit | None = None
+    options: list[str] | None = None
+    default: Any | None = None
+    nested: dict[str, ConfigFieldSchema] | None = None
+
+
+@dataclasses.dataclass
+class ConfigSchema:
+    fields: dict[str, ConfigFieldSchema]
+
+
+@functools.cache
+def dataclass_to_schema(cls: type) -> ConfigSchema:
+    """Recursively derive a ConfigSchema from a dataclass type.
+
+    Handles: plain scalars (str/int/float/bool), Enum-typed fields (→
+    type="enum" with `options`), Annotated[T, Unit.X] (→ populates `unit`),
+    and nested dataclasses (→ type="object" with `nested`).
+    Raises a clear error for unsupported field types rather than silently
+    guessing — this schema is consumed by GUI rendering code, silent
+    fallbacks there are worse than a loud failure here.
+    """
+    if not dataclasses.is_dataclass(cls):
+        raise TypeError(f"Not a dataclass: {cls!r}")
+
+    hints = get_type_hints(cls, include_extras=True)
+    fields: dict[str, ConfigFieldSchema] = {}
+    for f in dataclasses.fields(cls):
+        fields[f.name] = _field_schema(hints[f.name], f.default)
+    return ConfigSchema(fields=fields)
+
+
+def _field_schema(annotation: Any, default: Any) -> ConfigFieldSchema:
+    unit = None
+    origin = get_origin(annotation)
+    if origin is Annotated:
+        annotation, *extras = get_args(annotation)
+        unit = next((e for e in extras if isinstance(e, Unit)), None)
+
+    if dataclasses.is_dataclass(annotation):
+        nested_schema = dataclass_to_schema(annotation)
+        return ConfigFieldSchema(type="object", nested=nested_schema.fields)
+
+    if isinstance(annotation, type) and issubclass(annotation, enum.Enum):
+        return ConfigFieldSchema(
+            type="enum",
+            options=[e.value for e in annotation],
+            default=default if default is not dataclasses.MISSING else None,
+        )
+
+    type_name = {str: "str", int: "int", float: "float", bool: "bool"}.get(annotation)
+    if type_name is None:
+        raise TypeError(f"Unsupported config field type for schema: {annotation!r}")
+
+    return ConfigFieldSchema(
+        type=type_name,
+        unit=unit,
+        default=default if default is not dataclasses.MISSING else None,
+    )
+
+
+@functools.cache
+def pydantic_to_schema(cls: type[BaseModel]) -> ConfigSchema:
+    """Recursively derive a ConfigSchema from a Pydantic BaseModel.
+
+    Counterpart to dataclass_to_schema, for config objects that need to be
+    Pydantic models (e.g. for their own validation) rather than plain
+    dataclasses. Handles: plain scalars (str/int/float/bool), Literal-typed
+    fields (-> type="enum" with `options`), Optional[...]/`X | None`
+    (unwrapped), nested BaseModel fields (-> type="object" with `nested`),
+    and opaque `dict` fields (-> type="object" with no nested schema, for
+    freeform blobs). Raises for anything else unhandled, for the same
+    reason as dataclass_to_schema: this schema drives GUI rendering, and a
+    silent fallback there is worse than a loud failure here.
+    """
+    if not (isinstance(cls, type) and issubclass(cls, BaseModel)):
+        raise TypeError(f"Not a Pydantic model: {cls!r}")
+
+    fields: dict[str, ConfigFieldSchema] = {}
+    for name, info in cls.model_fields.items():
+        default = None if info.default is PydanticUndefined else info.default
+        fields[name] = _pydantic_field_schema(info.annotation, default)
+    return ConfigSchema(fields=fields)
+
+
+def _pydantic_field_schema(annotation: Any, default: Any) -> ConfigFieldSchema:
+    origin = get_origin(annotation)
+
+    if origin is typing.Union or origin is types.UnionType:
+        args = [a for a in get_args(annotation) if a is not type(None)]
+        if len(args) == 1:
+            return _pydantic_field_schema(args[0], default)
+
+    if origin is typing.Literal:
+        return ConfigFieldSchema(type="enum", options=[str(v) for v in get_args(annotation)], default=default)
+
+    if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+        return ConfigFieldSchema(type="object", nested=pydantic_to_schema(annotation).fields)
+
+    if annotation is dict or origin is dict:
+        return ConfigFieldSchema(type="object", default=default)
+
+    type_name = {str: "str", int: "int", float: "float", bool: "bool"}.get(annotation)
+    if type_name is None:
+        raise TypeError(f"Unsupported config field type for schema: {annotation!r}")
+
+    return ConfigFieldSchema(type=type_name, default=default)
+
+
+__all__ = ["ConfigFieldSchema", "ConfigSchema", "dataclass_to_schema", "pydantic_to_schema"]

{pyobs_core-2.0.0.dev15 → pyobs_core-2.0.0.dev17}/pyproject.toml

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

pyobs_core-2.0.0.dev15/pyobs/robotic/scheduler/targets/__init__.py

@@ -1,7 +0,0 @@
-from .dynamictarget import DynamicTarget
-from .heliocentricpolar import HeliocentricPolar
-from .helioprojectiveradialarget import HelioprojectiveRadialTarget
-from .siderealtarget import SiderealTarget
-from .target import Target
-
-__all__ = ["Target", "DynamicTarget", "HeliocentricPolar", "HelioprojectiveRadialTarget", "SiderealTarget"]