pyobs-core 2.0.0.dev52__tar.gz → 2.0.0.dev54__tar.gz

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/PKG-INFO

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

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/comm/comm.py

@@ -39,7 +39,8 @@ class Comm:
         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._events_sent: set[type[Event]] = set()
+        self._events_subscribed: set[type[Event]] = set()
         self._closing = asyncio.Event()
         self._published_state: set[type[Interface]] = set()
 
@@ -434,10 +435,10 @@ 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?
+        # do we have a handler? then we subscribe, otherwise we just declare that we send it
         if handler:
+            self._events_subscribed.update(event_classes)
             # loop classes
             for ev in event_classes:
                 # initialize list
@@ -447,6 +448,8 @@ class Comm:
                 if handler not in self._event_handlers[ev]:
                     # add handler
                     self._event_handlers[ev].append(handler)
+        else:
+            self._events_sent.update(event_classes)
 
         # if event is not a local one, we also need to do some XMPP stuff
         if not event_class.local:
@@ -457,8 +460,9 @@ class Comm:
     ) -> None:
         """Remove a handler previously added via register_event().
 
-        Leaves the event type itself registered (other handlers may still be interested in it,
-        and the module may still want to advertise/receive it), only stops calling this handler.
+        Leaves the event type itself registered as *sent* if the module also declared it via a
+        handler-less register_event() call, only stops calling this handler and, once no handler
+        is left for the event, drops it from what's advertised as *subscribed*.
 
         Args:
             event_class: Class of event that was registered.
@@ -470,6 +474,8 @@ class Comm:
             handlers = self._event_handlers.get(ev)
             if handlers is not None and handler in handlers:
                 handlers.remove(handler)
+                if not handlers:
+                    self._events_subscribed.discard(ev)
 
     async def _register_events(
         self, events: list[type[Event]], handler: Callable[[Event, str], Coroutine[Any, Any, bool]] | None = None

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/comm/xmpp/xmppcomm.py

@@ -37,6 +37,18 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+def _event_role(ev_cls: type[Event], events_sent: set[type[Event]], events_subscribed: set[type[Event]]) -> str:
+    """Space-separated role(s) ("send", "subscribe", or both) for an event class, for the
+    disco#info `role` attribute -- lets consumers with no access to the pyobs.events catalog
+    (e.g. pyobs-web-client) tell producers from consumers instead of guessing from the union."""
+    roles = []
+    if ev_cls in events_sent:
+        roles.append("send")
+    if ev_cls in events_subscribed:
+        roles.append("subscribe")
+    return " ".join(roles)
+
+
 def _retry_delay(attempt: int, cap: float = 30.0, base: float = 1.0) -> float:
     """Capped exponential backoff with full jitter.
 
@@ -984,10 +996,16 @@ class XmppComm(Comm):
             for interface in self._module.interfaces:
                 info.xml.append(_interface_schema_to_xml(interface))
 
-        # Append event schemas
-        for ev_cls in sorted(self._registered_events, key=lambda e: e.__name__):
-            if not ev_cls.local:
-                info.xml.append(_event_schema_to_xml(ev_cls))
+        # Append event schemas, tagged with a role attribute so consumers that have no access
+        # to the pyobs.events catalog themselves (e.g. pyobs-web-client) can tell which events
+        # a module actually sends vs. which it only subscribes to receive.
+        registered_events = self._events_sent | self._events_subscribed
+        for ev_cls in sorted(registered_events, key=lambda e: e.__name__):
+            if ev_cls.local:
+                continue
+            event_xml = _event_schema_to_xml(ev_cls)
+            event_xml.attrib["role"] = _event_role(ev_cls, self._events_sent, self._events_subscribed)
+            info.xml.append(event_xml)
 
         return info
 

pyobs_core-2.0.0.dev54/pyobs/images/processor.py

@@ -0,0 +1,63 @@
+from abc import ABCMeta, abstractmethod
+from typing import Any
+
+from pyobs.images import Image
+from pyobs.object import Object
+from pyobs.utils.exceptions import ImageError
+
+
+class ImageProcessor(Object, metaclass=ABCMeta):
+    VALID_ERROR_MODES = frozenset(("raise", "error", "info", "ignore"))
+
+    def __init__(self, on_error: str = "raise", **kwargs: Any):
+        """Init new image processor.
+
+        Args:
+            on_error: How the pipeline should handle an ImageError raised by this step. One of:
+                - "raise" (default): re-raise the exception, aborting the pipeline.
+                - "error": call handle_error(), pass its return value downstream.
+                - "info": log at INFO level, pass the pre-step image downstream unmodified.
+                - "ignore": silently pass the pre-step image downstream unmodified.
+        """
+        Object.__init__(self, **kwargs)
+
+        self._on_error = on_error
+        if self._on_error not in self.VALID_ERROR_MODES:
+            raise ValueError(f"on_error must be one of {sorted(self.VALID_ERROR_MODES)}, got {self._on_error!r}.")
+
+    @property
+    def on_error(self) -> str:
+        """The error handling mode for this step."""
+        return self._on_error
+
+    @abstractmethod
+    async def __call__(self, image: Image) -> Image:
+        """Processes an image.
+
+        Args:
+            image: Image to process.
+
+        Returns:
+            Processed image.
+        """
+
+    def handle_error(self, image: Image, error: ImageError) -> Image:
+        """Handle an ImageError raised by this step, when on_error == "error".
+
+        Override this to customize error handling (e.g. tag the image with a FITS header).
+        The default implementation re-raises the error.
+
+        Args:
+            image: The image that caused the error.
+            error: The ImageError that was raised.
+
+        Returns:
+            The image to pass to the next pipeline step.
+        """
+        raise error
+
+    async def reset(self) -> None:
+        """Resets state of image processor"""
+
+
+__all__ = ["ImageProcessor"]

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/images/processors/astrometry/dotnet.py

@@ -31,11 +31,15 @@ class AstrometryDotNet(Astrometry):
                          (commonly degrees for astrometry.net). Default: ``3.0``.
     :param int timeout: Timeout in seconds for the network call to the astrometry
                         web service. Default: ``10``.
-    :param bool exceptions: Whether to raise exceptions on failure. If ``True``,
-                            processing errors are raised (typically as
-                            :class:`pyobs.images.exceptions.ImageError`). If ``False``,
-                            errors are handled by marking the image header and returning
-                            the original image. Default: ``True``.
+    :param bool exceptions: Deprecated, use ``on_error`` instead. ``exceptions=False`` is
+                            equivalent to ``on_error="error"``; ``exceptions=True`` (the
+                            default) is equivalent to ``on_error="raise"``.
+    :param str on_error: How the pipeline should handle a failed solve: ``"raise"`` (default,
+                         abort the pipeline), ``"error"`` (mark ``WCSERR=1`` in the header, log
+                         a warning, and pass the image through -- see ``handle_error``),
+                         ``"info"``, or ``"ignore"``. Only takes effect when this processor
+                         runs as a step in a ``PipelineMixin`` pipeline; a direct call always
+                         raises on failure.
     :param kwargs: Additional keyword arguments forwarded to
                    :class:`pyobs.images.processors.astrometry.Astrometry`.
 
@@ -48,11 +52,9 @@ class AstrometryDotNet(Astrometry):
     - On success, receives solver output and writes the resulting WCS into a copy of
       the input image using :class:`pyobs.images.processors.astrometry._ResponseImageWriter`.
     - Logs the outcome, including WCS information, and returns the result image.
-    - On failure:
-
-        - If ``exceptions=True``, raises the underlying :class:`pyobs.images.exceptions.ImageError`.
-        - If ``exceptions=False``, sets ``WCSERR=1`` in the FITS header, logs a warning, and returns the original
-          image unchanged.
+    - On failure, raises the underlying :class:`pyobs.images.exceptions.ImageError`. When run as
+      a pipeline step with ``on_error="error"``, the pipeline calls ``handle_error``, which sets
+      ``WCSERR=1`` in the FITS header, logs a warning, and returns the original image unchanged.
 
     Input/Output
     ------------
@@ -69,20 +71,20 @@ class AstrometryDotNet(Astrometry):
        class: pyobs.images.processors.astrometry.AstrometryDotNet
        url: "http://localhost:8080/api"
 
-    Handle failures without raising exceptions:
+    Handle failures without aborting the pipeline:
 
     .. code-block:: yaml
 
        class: pyobs.images.processors.astrometry.AstrometryDotNet
        url: "http://localhost:8080/api"
-       exceptions: false
+       on_error: error
 
     Notes
     -----
     - The ``_DotNetRequestBuilder`` determines how sources are extracted and how the
       request is formed (including any unit conventions for ``radius``). Consult its
       documentation for details.
-    - ``WCSERR`` is used as a failure marker in the FITS header when ``exceptions=False``.
+    - ``WCSERR`` is used as a failure marker in the FITS header when ``handle_error`` runs.
     """
 
     __module__ = "pyobs.images.processors.astrometry"
@@ -93,7 +95,8 @@ class AstrometryDotNet(Astrometry):
         source_count: int = 50,
         radius: float = 3.0,
         timeout: int = 10,
-        exceptions: bool = True,
+        exceptions: bool | None = None,
+        on_error: str = "raise",
         **kwargs: Any,
     ):
         """Init new astronomy.net processor.
@@ -103,17 +106,28 @@ class AstrometryDotNet(Astrometry):
             source_count: Number of sources to send.
             radius: Radius to search in.
             timeout: Timeout in seconds for call to astrometry web service.
-            exceptions: Whether to raise Exceptions.
+            exceptions: Deprecated, use on_error instead. Whether to raise Exceptions.
+            on_error: How to handle a failed solve. One of "raise", "error", "info", "ignore".
+                On "error", handle_error() marks the image with WCSERR=1 and logs a warning.
         """
-        Astrometry.__init__(self, **kwargs)
+        Astrometry.__init__(self, on_error=on_error, **kwargs)
 
         self.url = url
 
         self.timeout = timeout
-        self.exceptions = exceptions
+
+        # backwards compat: if 'exceptions' is set but 'on_error' is left at its default,
+        # derive on_error from it.
+        if exceptions is not None and on_error == "raise":
+            self._on_error = "raise" if exceptions else "error"
 
         self._request_builder = _DotNetRequestBuilder(source_count, radius)
 
+    @property
+    def exceptions(self) -> bool:
+        """Deprecated, use on_error instead."""
+        return self.on_error != "error"
+
     async def _process(self, image: Image) -> Image:
         # build the request
         request = self._request_builder(image)
@@ -132,10 +146,7 @@ class AstrometryDotNet(Astrometry):
 
         return result_image
 
-    def _handle_error(self, image: Image, error: exc.ImageError) -> Image:
-        if self.exceptions:
-            raise error
-
+    def handle_error(self, image: Image, error: exc.ImageError) -> Image:
         image.header["WCSERR"] = 1
 
         log.warning(error.message)
@@ -145,16 +156,13 @@ class AstrometryDotNet(Astrometry):
     async def __call__(self, image: Image) -> Image:
         """Find astrometric solution on given image.
 
-        Writes WCSERR=1 into FITS header on failure.
+        Writes WCSERR=1 into FITS header on failure (see handle_error).
 
         Args:
             image: Image to analyse.
         """
 
-        try:
-            return await self._process(image)
-        except exc.ImageError as e:
-            return self._handle_error(image, e)
+        return await self._process(image)
 
 
 __all__ = ["AstrometryDotNet"]

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/mixins/pipeline.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from pyobs.images import Image, ImageProcessor
 from pyobs.object import Object
+from pyobs.utils.exceptions import ImageError
 
 log = logging.getLogger(__name__)
 
@@ -37,6 +38,10 @@ class PipelineMixin:
     async def run_pipeline(self, image: Image) -> Image:
         """Run the pipeline on the given image.
 
+        Each step is run, and an ImageError it raises is handled according to the step's
+        on_error setting (default "raise"): re-raised, dispatched to the step's handle_error(),
+        logged, or ignored. Non-ImageError exceptions always propagate.
+
         Args:
             image: Image to run pipeline on.
 
@@ -44,9 +49,18 @@ class PipelineMixin:
             Image after pipeline run.
         """
 
-        # loop steps, just let any exception pass
         for step in self.__pipeline_steps:
-            image = await step(image)
+            try:
+                image = await step(image)
+            except ImageError as e:
+                if step.on_error == "raise":
+                    raise
+                elif step.on_error == "error":
+                    image = step.handle_error(image, e)
+                elif step.on_error == "info":
+                    log.info("Step %s: %s", type(step).__name__, e)
+                elif step.on_error == "ignore":
+                    pass
 
         # finished
         return image

pyobs_core-2.0.0.dev54/pyobs/robotic/scheduler/_executor.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Coroutine
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, TypeVar
+
+_T = TypeVar("_T")
+
+# single worker: evaluate_constraints_and_merits calls are always awaited sequentially by the
+# caller (never fired concurrently), and DataProvider's functools.cache is not safe under real
+# concurrent access -- one worker keeps that access serialized while still freeing the main loop.
+_executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="pyobs-scheduler")
+
+
+async def run_cpu_bound(coro_fn: Callable[..., Coroutine[Any, Any, _T]], *args: object) -> _T:
+    """Runs an async callable to completion on a dedicated worker thread, off the caller's loop.
+
+    Args:
+        coro_fn: An async callable whose body does not itself need to run on the caller's
+            event loop (no dependency on the caller's other tasks, timers, or comm state).
+        args: Positional args for coro_fn.
+    """
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(_executor, lambda: asyncio.run(coro_fn(*args)))
+
+
+__all__ = ["run_cpu_bound"]

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/robotic/scheduler/constraints/moonilluminationconstraint.py

@@ -24,7 +24,7 @@ class MoonIlluminationConstraint(Constraint):
         return astroplan.MoonIlluminationConstraint(max=self.max_phase)
 
     async def __call__(self, time: Time, task: Task, data: DataProvider) -> bool:
-        moon_illumination = float(data.observer.moon_illumination(time))
+        moon_illumination = data.moon_illumination(time)
         return moon_illumination <= self.max_phase
 
 

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/robotic/scheduler/constraints/moonseparationconstraint.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import astroplan
-import astropy.coordinates
 import astropy.units as u
 import numpy as np
 from astropy.coordinates import SkyCoord
@@ -32,12 +31,12 @@ class MoonSeparationConstraint(Constraint):
         if task.target is None:
             return True
         coord = task.target.coordinates(time)
-        moon_separation = astropy.coordinates.get_body("moon", time).separation(coord, origin_mismatch="ignore")
+        moon_separation = data.moon(time).separation(coord, origin_mismatch="ignore")  # type: ignore[unexpected-keyword]
         return float(moon_separation.degree) >= self.min_distance
 
     async def filter_skycoord(self, time: Time, coords: SkyCoord, data: DataProvider) -> np.ndarray:
-        moon = astropy.coordinates.get_body("moon", time)
-        separations = moon.separation(coords, origin_mismatch="ignore").deg
+        moon = data.moon(time)
+        separations = moon.separation(coords, origin_mismatch="ignore").deg  # type: ignore[unexpected-keyword]
         return np.asarray(separations >= self.min_distance, dtype=np.bool_)
 
 

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/robotic/scheduler/constraints/solarelevationconstraint.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING, Literal
 
 import astroplan
 import astropy.units as u
-from astropy.coordinates import get_sun
 from pydantic import Field
 
 from pyobs.utils.time import Time
@@ -34,12 +33,12 @@ class SolarElevationConstraint(Constraint):
         return astroplan.AtNightConstraint(max_solar_altitude=self.max_elevation * u.deg)
 
     async def __call__(self, time: Time, task: Task, data: DataProvider) -> bool:
-        sun = data.observer.sun_altaz(time)
+        sun = data.sun_altaz(time)
         in_range = self.min_elevation <= float(sun.alt.degree) <= self.max_elevation
         if self.direction == "both":
             return in_range
         else:
-            sun_coord = get_sun(time)
+            sun_coord = data.sun(time)
             transit = data.observer.target_meridian_transit_time(time, sun_coord, which="nearest")
             midnight = data.observer.midnight(time, which="nearest")
 

pyobs_core-2.0.0.dev54/pyobs/robotic/scheduler/dataprovider.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass
+from functools import cache
+
+import astropy.coordinates
+from astroplan import Observer
+from astropy.coordinates import SkyCoord
+
+from pyobs.robotic.scheduler.observationarchiveevolution import (
+    ObservationArchiveEvolution,
+)
+from pyobs.utils.time import Time
+
+
+@dataclass
+class TaskSuccess:
+    date: Time
+    night: Time
+
+
+class DataProvider:
+    """Data provider for Merit classes.
+
+    The ``@cache``d methods below are only safe to call from a single thread at a time -- they're
+    used exclusively from within the scheduler's dedicated single-worker executor
+    (`pyobs.robotic.scheduler._executor.run_cpu_bound`), never concurrently from the caller's main
+    event loop. A new `DataProvider` is created per `schedule()` call, so cache lifetime is bounded
+    to one schedule computation and never leaks stale values across runs.
+    """
+
+    def __init__(self, observer: Observer, archive: ObservationArchiveEvolution | None = None):
+        self.observer = observer
+        self.archive = archive if archive else ObservationArchiveEvolution(observer)
+
+    @cache
+    def last_sunset(self, time: Time) -> Time:
+        """Returns the time of the last sunset."""
+
+        # get last sunset
+        return Time(self.observer.sun_set_time(time, which="previous"))
+
+    @cache
+    def last_sunrise(self, time: Time) -> Time:
+        """Returns the time of the last sunrise."""
+
+        # get last sunset
+        return Time(self.observer.sun_rise_time(time, which="previous"))
+
+    @cache
+    def night(self, time: Time) -> datetime.date:
+        """Returns the time of the last sunset."""
+        sunset = self.last_sunset(time)
+        return sunset.to_datetime().date()
+
+    @cache
+    def sun(self, time: Time) -> SkyCoord:
+        """Returns the Sun's coordinates at the given time."""
+        return astropy.coordinates.get_sun(time)
+
+    @cache
+    def sun_altaz(self, time: Time) -> SkyCoord:
+        """Returns the Sun's AltAz coordinates at the given time, as seen by the observer."""
+        return self.observer.sun_altaz(time)
+
+    @cache
+    def moon(self, time: Time) -> SkyCoord:
+        """Returns the Moon's coordinates at the given time."""
+        return astropy.coordinates.get_body("moon", time)
+
+    @cache
+    def moon_illumination(self, time: Time) -> float:
+        """Returns the Moon's illumination fraction at the given time."""
+        return float(self.observer.moon_illumination(time))
+
+
+__all__ = ["DataProvider"]

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/robotic/scheduler/ondemandscheduler.py

@@ -14,6 +14,7 @@ from pyobs.robotic.storage.observationarchive import ObservationArchive
 from pyobs.utils.time import Time
 
 from . import DataProvider
+from ._executor import run_cpu_bound
 from .constraints import Constraint
 from .observationarchiveevolution import ObservationArchiveEvolution
 from .taskscheduler import TaskScheduler
@@ -250,7 +251,7 @@ class OnDemandScheduler(TaskScheduler):
     ) -> tuple[Task | None, float]:
 
         # evaluate all merit functions at given time
-        merits = await self.evaluate_constraints_and_merits(tasks, projects, start, end, data)
+        merits = await run_cpu_bound(self.evaluate_constraints_and_merits, tasks, projects, start, end, data)
 
         # find max one
         idx = np.argmax(merits)
@@ -274,7 +275,7 @@ class OnDemandScheduler(TaskScheduler):
         other_tasks = [t for t in tasks if t is not task]
         t = start + TimeDelta(step * u.second)
         while t < start + TimeDelta(task.estimate_duration(time=start) * u.second):
-            merits = await self.evaluate_constraints_and_merits(other_tasks, projects, t, end, data)
+            merits = await run_cpu_bound(self.evaluate_constraints_and_merits, other_tasks, projects, t, end, data)
             for i, m in enumerate(merits):
                 if m > merit:
                     return other_tasks[i], t, m
@@ -295,7 +296,9 @@ class OnDemandScheduler(TaskScheduler):
         better_start: Time = start + TimeDelta(task.estimate_duration(time=start) * u.second)
 
         # evaluate merit of better_task at new start time
-        merit = (await self.evaluate_constraints_and_merits([better_task], projects, better_start, end, data))[0]
+        merit = (
+            await run_cpu_bound(self.evaluate_constraints_and_merits, [better_task], projects, better_start, end, data)
+        )[0]
 
         # if it got better, return it, otherwise return Nones
         if merit >= better_merit:

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyobs/vfs/vfs.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import io
 import logging
 from collections.abc import Awaitable, Callable
@@ -114,11 +115,15 @@ class VirtualFileSystem:
             hdulist: hdu list to write.
         """
 
-        # open file
-        async with self.open_file(filename, "wb") as f:
+        def _serialize() -> bytes:
             with io.BytesIO() as bio:
                 hdulist.writeto(bio, *args, **kwargs)
-                await f.write(bio.getvalue())
+                return bio.getvalue()
+
+        # open file
+        async with self.open_file(filename, "wb") as f:
+            data = await asyncio.to_thread(_serialize)
+            await f.write(data)
 
     async def read_image(self, filename: str) -> Image:
         """Convenience function that wraps around open_file() to read an Image.
@@ -145,11 +150,15 @@ class VirtualFileSystem:
             image: Image to write.
         """
 
-        # open file
-        async with self.open_file(filename, "wb") as f:
+        def _serialize() -> bytes:
             with io.BytesIO() as bio:
                 image.writeto(bio, *args, **kwargs)
-                await f.write(bio.getvalue())
+                return bio.getvalue()
+
+        # open file
+        async with self.open_file(filename, "wb") as f:
+            data = await asyncio.to_thread(_serialize)
+            await f.write(data)
 
     async def write_bytes(self, filename: str, data: bytes, *args: Any, **kwargs: Any) -> None:
         """Convenience function for writing bytes to a file.

{pyobs_core-2.0.0.dev52 → pyobs_core-2.0.0.dev54}/pyproject.toml

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

pyobs_core-2.0.0.dev52/pyobs/images/processor.py

@@ -1,28 +0,0 @@
-from abc import ABCMeta, abstractmethod
-from typing import Any
-
-from pyobs.images import Image
-from pyobs.object import Object
-
-
-class ImageProcessor(Object, metaclass=ABCMeta):
-    def __init__(self, **kwargs: Any):
-        """Init new image processor."""
-        Object.__init__(self, **kwargs)
-
-    @abstractmethod
-    async def __call__(self, image: Image) -> Image:
-        """Processes an image.
-
-        Args:
-            image: Image to process.
-
-        Returns:
-            Processed image.
-        """
-
-    async def reset(self) -> None:
-        """Resets state of image processor"""
-
-
-__all__ = ["ImageProcessor"]