citrascope 0.1.0__py3-none-any.whl

citrascope/__main__.py

@@ -0,0 +1,23 @@
+import click
+
+from citrascope.citra_scope_daemon import CitraScopeDaemon
+from citrascope.settings._citrascope_settings import CitraScopeSettings
+
+
+@click.group()
+@click.option("--dev", is_flag=True, default=False, help="Use the development API (dev.app.citra.space)")
+@click.option("--log-level", default="INFO", help="Set logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
+@click.pass_context
+def cli(ctx, dev, log_level):
+    ctx.obj = {"settings": CitraScopeSettings(dev=dev, log_level=log_level)}
+
+
+@cli.command("start")
+@click.pass_context
+def start(ctx):
+    daemon = CitraScopeDaemon(ctx.obj["settings"])
+    daemon.run()
+
+
+if __name__ == "__main__":
+    cli()

citrascope/api/abstract_api_client.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractCitraApiClient(ABC):
+    @abstractmethod
+    def does_api_server_accept_key(self):
+        pass
+
+    @abstractmethod
+    def get_telescope(self, telescope_id):
+        pass
+
+    @abstractmethod
+    def get_satellite(self, satellite_id):
+        pass
+
+    @abstractmethod
+    def get_telescope_tasks(self, telescope_id):
+        pass
+
+    @abstractmethod
+    def get_ground_station(self, ground_station_id):
+        pass

citrascope/api/citra_api_client.py

@@ -0,0 +1,101 @@
+import os
+
+import httpx
+
+from .abstract_api_client import AbstractCitraApiClient
+
+
+class CitraApiClient(AbstractCitraApiClient):
+    def __init__(self, host: str, token: str, use_ssl: bool = True, logger=None):
+        self.base_url = ("https" if use_ssl else "http") + "://" + host
+        self.token = token
+        self.logger = logger
+        self.client = httpx.Client(base_url=self.base_url, headers={"Authorization": f"Bearer {self.token}"})
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+
+    def _request(self, method: str, endpoint: str, **kwargs):
+        try:
+            resp = self.client.request(method, endpoint, **kwargs)
+            if self.logger:
+                self.logger.debug(f"{method} {endpoint}: {resp.status_code} {resp.text}")
+            resp.raise_for_status()
+            return resp.json()
+        except httpx.HTTPStatusError as e:
+            if self.logger:
+                self.logger.error(f"HTTP error: {e.response.status_code} {e.response.text}")
+            return None
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Request error: {e}")
+            return None
+
+    def does_api_server_accept_key(self):
+        """Check if the API key is valid."""
+        response = self._request("GET", "/auth/personal-access-tokens")
+        return response is not None
+
+    def get_telescope(self, telescope_id):
+        """Check if the telescope ID is valid."""
+        return self._request("GET", f"/telescopes/{telescope_id}")
+
+    def get_satellite(self, satellite_id):
+        """Fetch satellite details from /satellites/{satellite_id}"""
+        return self._request("GET", f"/satellites/{satellite_id}")
+
+    def get_telescope_tasks(self, telescope_id):
+        """Fetch tasks for a given telescope."""
+        return self._request("GET", f"/telescopes/{telescope_id}/tasks")
+
+    def get_ground_station(self, ground_station_id):
+        """Fetch ground station details from /ground-stations/{ground_station_id}"""
+        return self._request("GET", f"/ground-stations/{ground_station_id}")
+
+    def upload_image(self, task_id, telescope_id, filepath):
+        """Upload an image file for a given task."""
+        signed_url_response = self._request(
+            "POST", f"/my/images?filename=citra_task_{task_id}_image.fits&telescope_id={telescope_id}&task_id={task_id}"
+        )
+        if not signed_url_response or "uploadUrl" not in signed_url_response:
+            if self.logger:
+                self.logger.error("Failed to get signed URL for image upload.")
+            return None
+
+        upload_url = signed_url_response["uploadUrl"]
+        fields = signed_url_response["fields"]
+
+        # Prepare the multipart form data
+        files = {"file": (os.path.basename(filepath), open(filepath, "rb"), "application/fits")}
+        data = fields  # Fields provided in the signed URL response
+
+        # Perform the POST request to upload the file
+        try:
+            response = httpx.post(upload_url, data=data, files=files)
+            if self.logger:
+                self.logger.debug(f"Image upload response: {response.status_code} {response.text}")
+            response.raise_for_status()
+            return signed_url_response.get("resultsUrl")  # Return the results URL if needed
+        except httpx.RequestError as e:
+            if self.logger:
+                self.logger.error(f"Failed to upload image: {e}")
+            return None
+        finally:
+            # Ensure the file is closed after the upload
+            files["file"][1].close()
+
+    def mark_task_complete(self, task_id):
+        """Mark a task as complete using the API."""
+        try:
+            body = {"status": "Succeeded"}
+            response = self._request("PUT", f"/tasks/{task_id}", json=body)
+            if self.logger:
+                self.logger.debug(f"Marked task {task_id} as complete: {response}")
+            return response
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Failed to mark task {task_id} as complete: {e}")
+            return None

citrascope/citra_scope_daemon.py

@@ -0,0 +1,90 @@
+import time
+from typing import Optional
+
+from citrascope.api.citra_api_client import AbstractCitraApiClient, CitraApiClient
+from citrascope.hardware.abstract_astro_hardware_adapter import AbstractAstroHardwareAdapter
+from citrascope.hardware.indi_adapter import IndiAdapter
+from citrascope.logging import CITRASCOPE_LOGGER
+from citrascope.settings._citrascope_settings import CitraScopeSettings
+from citrascope.tasks.runner import TaskManager
+
+
+class CitraScopeDaemon:
+    def __init__(
+        self,
+        settings: CitraScopeSettings,
+        api_client: Optional[AbstractCitraApiClient] = None,
+        hardware_adapter: Optional[AbstractAstroHardwareAdapter] = None,
+    ):
+        self.settings = settings
+        CITRASCOPE_LOGGER.setLevel(self.settings.log_level)
+        self.api_client = api_client or CitraApiClient(
+            self.settings.host,
+            self.settings.personal_access_token,
+            self.settings.use_ssl,
+            CITRASCOPE_LOGGER,
+        )
+        self.hardware_adapter = hardware_adapter or IndiAdapter(
+            CITRASCOPE_LOGGER, self.settings.indi_server_url, int(self.settings.indi_server_port)
+        )
+
+    def run(self):
+        CITRASCOPE_LOGGER.info(f"CitraAPISettings host is {self.settings.host}")
+        CITRASCOPE_LOGGER.info(f"CitraAPISettings telescope_id is {self.settings.telescope_id}")
+
+        # check api for valid key, telescope and ground station
+        if not self.api_client.does_api_server_accept_key():
+            CITRASCOPE_LOGGER.error("Aborting: could not authenticate with Citra API.")
+            return
+
+        citra_telescope_record = self.api_client.get_telescope(self.settings.telescope_id)
+        if not citra_telescope_record:
+            CITRASCOPE_LOGGER.error("Aborting: telescope_id is not valid on the server.")
+            return
+
+        ground_station = self.api_client.get_ground_station(citra_telescope_record["groundStationId"])
+        if not ground_station:
+            CITRASCOPE_LOGGER.error("Aborting: could not get ground station info from the server.")
+            return
+
+        # connect to hardware server
+        CITRASCOPE_LOGGER.info(f"Connecting to hardware server with {type(self.hardware_adapter).__name__}...")
+        self.hardware_adapter.connect()
+        time.sleep(1)
+        CITRASCOPE_LOGGER.info("List of hardware devices")
+        device_list = self.hardware_adapter.list_devices() or []
+
+        # check for telescope
+        if not self.settings.indi_telescope_name in device_list:
+            CITRASCOPE_LOGGER.error(
+                f"Aborting: could not find configured telescope ({self.settings.indi_telescope_name}) on hardware server."
+            )
+            return
+        self.hardware_adapter.select_telescope(self.settings.indi_telescope_name)
+        self.hardware_adapter.scope_slew_rate_degrees_per_second = citra_telescope_record["maxSlewRate"]
+        CITRASCOPE_LOGGER.info(
+            f"Found configured Telescope ({self.settings.indi_telescope_name}) on hardware server"
+            + f" (slew rate: {self.hardware_adapter.scope_slew_rate_degrees_per_second} deg/sec)"
+        )
+
+        # check for camera
+        if not self.settings.indi_camera_name in device_list:
+            CITRASCOPE_LOGGER.error(
+                f"Aborting: could not find configured camera ({self.settings.indi_camera_name}) on hardware server."
+            )
+            return
+        self.hardware_adapter.select_camera(self.settings.indi_camera_name)
+        CITRASCOPE_LOGGER.info(f"Found configured Camera ({self.settings.indi_camera_name}) on hardware server!")
+
+        task_manager = TaskManager(
+            self.api_client, citra_telescope_record, ground_station, CITRASCOPE_LOGGER, self.hardware_adapter
+        )
+        task_manager.start()
+
+        CITRASCOPE_LOGGER.info("Starting telescope task daemon... (press Ctrl+C to exit)")
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            CITRASCOPE_LOGGER.info("Shutting down daemon.")
+            task_manager.stop()

citrascope/hardware/abstract_astro_hardware_adapter.py

@@ -0,0 +1,110 @@
+import math
+from abc import ABC, abstractmethod
+
+
+class AbstractAstroHardwareAdapter(ABC):
+
+    logger = None  # Optional logger, can be set by subclasses
+
+    _slew_min_distance_deg: float = 2.0
+    scope_slew_rate_degrees_per_second: float = 0.0
+
+    def point_telescope(self, ra: float, dec: float):
+        """Point the telescope to the specified RA/Dec coordinates."""
+        # separated out to allow pre/post processing if needed
+        self._do_point_telescope(ra, dec)
+
+    @abstractmethod
+    def _do_point_telescope(self, ra: float, dec: float):
+        """Hardware-specific implementation to point the telescope."""
+        pass
+
+    def angular_distance(
+        self, ra1_degrees: float, dec1_degrees: float, ra2_degrees: float, dec2_degrees: float
+    ) -> float:  # TODO: move this out of the hardware adapter... this isn't hardware stuff
+        """Compute angular distance between two (RA hours, Dec deg) points in degrees."""
+
+        # Convert to radians
+        ra1_rad = math.radians(ra1_degrees)
+        ra2_rad = math.radians(ra2_degrees)
+        dec1_rad = math.radians(dec1_degrees)
+        dec2_rad = math.radians(dec2_degrees)
+        # Spherical law of cosines
+        cos_angle = math.sin(dec1_rad) * math.sin(dec2_rad) + math.cos(dec1_rad) * math.cos(dec2_rad) * math.cos(
+            ra1_rad - ra2_rad
+        )
+        # Clamp for safety
+        cos_angle = min(1.0, max(-1.0, cos_angle))
+        angle_rad = math.acos(cos_angle)
+        return math.degrees(angle_rad)
+
+    """
+    Abstract base class for controlling astrophotography hardware.
+
+    This adapter provides a common interface for interacting with telescopes, cameras,
+    filter wheels, focus dials, and other astrophotography devices.
+    """
+
+    @abstractmethod
+    def connect(self) -> bool:
+        """Connect to the hardware server."""
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """Disconnect from the hardware server."""
+        pass
+
+    @abstractmethod
+    def list_devices(self) -> list[str]:
+        """List all connected devices."""
+        pass
+
+    @abstractmethod
+    def select_telescope(self, device_name: str) -> bool:
+        """Select a specific camera by name."""
+        pass
+
+    @abstractmethod
+    def get_telescope_direction(self) -> tuple[float, float]:
+        """Read the current telescope direction (RA degrees, DEC degrees)."""
+        pass
+
+    @abstractmethod
+    def telescope_is_moving(self) -> bool:
+        """Check if the telescope is currently moving."""
+        pass
+
+    @abstractmethod
+    def select_camera(self, device_name: str) -> bool:
+        """Select a specific camera by name."""
+        pass
+
+    @abstractmethod
+    def take_image(self, task_id: str, exposure_duration_seconds=1.0) -> str:
+        """Capture an image with the currently selected camera. Returns the file path of the saved image."""
+        pass
+
+    @abstractmethod
+    def set_custom_tracking_rate(self, ra_rate: float, dec_rate: float):
+        """Set the tracking rate for the telescope in RA and Dec (arcseconds per second)."""
+        pass
+
+    @abstractmethod
+    def get_tracking_rate(self) -> tuple[float, float]:
+        """Get the current tracking rate for the telescope in RA and Dec (arcseconds per second)."""
+        pass
+
+    @abstractmethod
+    def perform_alignment(self, target_ra: float, target_dec: float) -> bool:
+        """
+        Perform plate-solving-based alignment to adjust the telescope's position.
+
+        Args:
+            target_ra (float): The target Right Ascension (RA) in degrees.
+            target_dec (float): The target Declination (Dec) in degrees.
+
+        Returns:
+            bool: True if alignment was successful, False otherwise.
+        """
+        pass

citrascope/hardware/indi_adapter.py

@@ -0,0 +1,290 @@
+import os
+import time
+from pathlib import Path
+
+import PyIndi
+import tetra3
+from pixelemon import Telescope, TelescopeImage, TetraSolver
+from pixelemon.optics import WilliamsMiniCat51
+from pixelemon.optics._base_optical_assembly import BaseOpticalAssembly
+from pixelemon.sensors import IMX174
+from pixelemon.sensors._base_sensor import BaseSensor
+
+from citrascope.hardware.abstract_astro_hardware_adapter import AbstractAstroHardwareAdapter
+
+
+# The IndiClient class which inherits from the module PyIndi.BaseClient class
+# Note that all INDI constants are accessible from the module as PyIndi.CONSTANTNAME
+class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
+    # Minimum angular distance (degrees) to consider a move significant for slew rate measurement
+    _slew_min_distance_deg: float = 2.0
+
+    our_scope: PyIndi.BaseDevice
+    our_camera: PyIndi.BaseDevice
+
+    _current_task_id: str = ""
+    _last_saved_filename: str = ""
+
+    _alignment_offset_ra: float = 0.0
+    _alignment_offset_dec: float = 0.0
+
+    def __init__(self, CITRA_LOGGER, host: str, port: int):
+        super(IndiAdapter, self).__init__()
+        self.logger = CITRA_LOGGER
+        self.logger.debug("creating an instance of IndiClient")
+        self.host = host
+        self.port = port
+
+        TetraSolver.high_memory()
+
+    def newDevice(self, d):
+        """Emmited when a new device is created from INDI server."""
+        self.logger.info(f"new device {d.getDeviceName()}")
+        # TODO: if it's the scope we want, set our_scope
+
+    def removeDevice(self, d):
+        """Emmited when a device is deleted from INDI server."""
+        self.logger.info(f"remove device {d.getDeviceName()}")
+        # TODO: if it's our_scope, set our_scope to None, and react accordingly
+
+    def newProperty(self, p):
+        """Emmited when a new property is created for an INDI driver."""
+        self.logger.debug(f"new property {p.getName()} as {p.getTypeAsString()} for device {p.getDeviceName()}")
+
+    def updateProperty(self, p):
+        """Emmited when a new property value arrives from INDI server."""
+        self.logger.debug(f"update property {p.getName()} as {p.getTypeAsString()} for device {p.getDeviceName()}")
+        try:
+
+            if (
+                hasattr(self, "our_scope")
+                and self.our_scope is not None
+                and p.getDeviceName() == self.our_scope.getDeviceName()
+            ):
+                value = None
+                changed_type = p.getTypeAsString()
+                if changed_type == "INDI_TEXT":
+                    value = self.our_scope.getText(p.getName())[0].value
+                if changed_type == "INDI_NUMBER":
+                    value = self.our_scope.getNumber(p.getName())[0].value
+                self.logger.debug(
+                    f"Scope '{self.our_scope.getDeviceName()}' property {p.getName()} updated value: {value}"
+                )
+
+            if p.getType() == PyIndi.INDI_BLOB:
+                blobProperty = self.our_camera.getBLOB(p.getName())
+                format = blobProperty[0].getFormat()
+                bloblen = blobProperty[0].getBlobLen()
+                size = blobProperty[0].getSize()
+                self.logger.debug(f"Received BLOB of format {format}, size {size}, length {bloblen}")
+
+                # if there's a task underway, save the image to a file
+                if self._current_task_id != "":
+                    os.makedirs("images", exist_ok=True)
+                    self._last_saved_filename = f"images/citra_task_{self._current_task_id}_image.fits"
+                    for b in blobProperty:
+                        with open(self._last_saved_filename, "wb") as f:
+                            f.write(b.getblobdata())
+                            self.logger.info(f"Saved {self._last_saved_filename}")
+                    self._current_task_id = ""
+        except Exception as e:
+            self.logger.error(f"Error processing updated property {p.getName()}: {e}")
+
+    def removeProperty(self, p):
+        """Emmited when a property is deleted for an INDI driver."""
+        self.logger.debug(f"remove property {p.getName()} as {p.getTypeAsString()} for device {p.getDeviceName()}")
+
+    def newMessage(self, d, m):
+        """Emmited when a new message arrives from INDI server."""
+        msg = d.messageQueue(m)
+        if "error" in msg.lower():
+            self.logger.error(f"new Message {msg}")
+        else:
+            self.logger.debug(f"new Message {msg}")
+
+    def serverConnected(self):
+        """Emmited when the server is connected."""
+        self.logger.info(f"INDI Server connected ({self.getHost()}:{self.getPort()})")
+
+    def serverDisconnected(self, code):
+        """Emmited when the server gets disconnected."""
+        self.logger.info(f"INDI Server disconnected (exit code = {code},{self.getHost()}:{self.getPort()})")
+
+    def newBLOB(self, bp):
+        for b in bp:
+            with open("image.fits", "wb") as f:
+                f.write(b.getblob())
+                print("Saved image.fits")
+
+    # ========================= AstroHardwareAdapter Methods =========================
+
+    def connect(self) -> bool:
+        self.setServer(self.host, self.port)
+        return self.connectServer()
+
+    def list_devices(self):
+        names = []
+        for device in self.getDevices():
+            names.append(device.getDeviceName())
+        return names
+
+    def select_telescope(self, device_name: str) -> bool:
+        devices = self.getDevices()
+        for device in devices:
+            if device.getDeviceName() == device_name:
+                self.our_scope = device
+                return True
+        return False
+
+    def disconnect(self):
+        self.disconnectServer()
+
+    def _do_point_telescope(self, ra: float, dec: float):
+        """Hardware-specific implementation to point the telescope to the specified RA/Dec coordinates."""
+        telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+        new_ra = float(ra)
+        new_dec = float(dec)
+        telescope_radec[0].setValue(new_ra)  # RA in hours
+        telescope_radec[1].setValue(new_dec)  # DEC in degrees
+        try:
+            self.sendNewNumber(telescope_radec)
+        except Exception as e:
+            self.logger.error(f"Error sending new RA/DEC to telescope: {e}")
+            return
+
+    def get_telescope_direction(self) -> tuple[float, float]:
+        """Read the current telescope direction (RA degrees, DEC degrees)."""
+        telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+        self.logger.debug(
+            f"Telescope currently pointed to RA: {telescope_radec[0].value * 15.0} degrees, DEC: {telescope_radec[1].value} degrees"
+        )
+        return telescope_radec[0].value * 15.0, telescope_radec[1].value
+
+    def telescope_is_moving(self) -> bool:
+        """Check if the telescope is currently moving."""
+        telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+        return telescope_radec.getState() == PyIndi.IPS_BUSY
+
+    def select_camera(self, device_name: str) -> bool:
+        """Select a specific camera by name."""
+        devices = self.getDevices()
+        for device in devices:
+            if device.getDeviceName() == device_name:
+                self.our_camera = device
+                self.setBLOBMode(PyIndi.B_ALSO, device_name, None)
+                return True
+        return False
+
+    def take_image(self, task_id: str, exposure_duration_seconds=1.0):
+        """Capture an image with the currently selected camera."""
+
+        self.logger.info(f"Taking {exposure_duration_seconds} second exposure...")
+        self._current_task_id = task_id
+        ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
+        ccd_exposure[0].setValue(exposure_duration_seconds)
+        self.sendNewNumber(ccd_exposure)
+
+        while self.is_camera_busy() and self._current_task_id != "":
+            self.logger.debug("Waiting for camera to finish exposure...")
+            time.sleep(0.2)
+
+        filename = self._last_saved_filename
+        self._last_saved_filename = ""
+        return filename
+
+    def is_camera_busy(self) -> bool:
+        """Check if the camera is currently busy taking an image."""
+        ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
+        return ccd_exposure.getState() == PyIndi.IPS_BUSY
+
+    def set_custom_tracking_rate(self, ra_rate: float, dec_rate: float):
+        """Set the tracking rate for the telescope in RA and Dec (arcseconds per second)."""
+        self.logger.info(f"Setting tracking rate: RA {ra_rate} arcseconds/s, Dec {dec_rate} arcseconds/s")
+        try:
+
+            track_state_prop = self.our_scope.getSwitch("TELESCOPE_TRACK_STATE")
+            track_state_prop[0].setState(PyIndi.ISS_OFF)
+            self.sendNewSwitch(track_state_prop)
+
+            track_mode_prop = self.our_scope.getSwitch("TELESCOPE_TRACK_MODE")
+            track_mode_prop[0].setState(PyIndi.ISS_OFF)  # TRACK_SIDEREAL
+            track_mode_prop[1].setState(PyIndi.ISS_OFF)  # TRACK_SOLAR
+            track_mode_prop[2].setState(PyIndi.ISS_OFF)  # TRACK_LUNAR
+            track_mode_prop[3].setState(PyIndi.ISS_ON)  # TRACK_CUSTOM
+            self.sendNewSwitch(track_mode_prop)
+
+            indi_tracking_rate = self.our_scope.getNumber("TELESCOPE_TRACK_RATE")
+            self.logger.info(
+                f"Current INDI tracking rates: 0: {indi_tracking_rate[0].value} 1: {indi_tracking_rate[1].value}"
+            )
+            indi_tracking_rate[0].setValue(ra_rate)
+            indi_tracking_rate[1].setValue(dec_rate)
+            self.sendNewNumber(indi_tracking_rate)
+
+            track_state_prop[0].setState(PyIndi.ISS_ON)  # Turn tracking ON
+            self.sendNewSwitch(track_state_prop)
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Error setting tracking rates: {e}")
+            return False
+
+    def get_tracking_rate(self) -> tuple[float, float]:
+        """Get the current tracking rate for the telescope in RA and Dec (arcseconds per second)."""
+        ra_rate = self.our_scope.getNumber("TELESCOPE_TRACK_RATE_RA")[0].value
+        dec_rate = self.our_scope.getNumber("TELESCOPE_TRACK_RATE_DEC")[0].value
+        return ra_rate, dec_rate
+
+    def perform_alignment(self, target_ra: float, target_dec: float) -> bool:
+        """
+        Perform plate-solving-based alignment to adjust the telescope's position.
+
+        Args:
+            target_ra (float): The target Right Ascension (RA) in degrees.
+            target_dec (float): The target Declination (Dec) in degrees.
+
+        Returns:
+            bool: True if alignment was successful, False otherwise.
+        """
+        try:
+
+            # take alignment exposure
+            alignment_filename = self.take_image("alignment", 5.0)
+
+            # this needs to be made configurable
+            sim_ccd = BaseSensor(
+                x_pixel_count=1280,
+                y_pixel_count=1024,
+                pixel_width=5.86,
+                pixel_height=5.86,
+            )
+            sim_scope = BaseOpticalAssembly(image_circle_diameter=9.61, focal_length=300, focal_ratio=6)
+            telescope = Telescope(sensor=sim_ccd, optics=sim_scope)
+            image = TelescopeImage.from_fits_file(Path(alignment_filename), telescope)
+
+            # this line can be used to read a manually sideloded FITS file for testing
+            # image = TelescopeImage.from_fits_file(Path("images/cosmos-2564_10s.fits"), Telescope(sensor=IMX174(), optics=WilliamsMiniCat51()))
+
+            solve = image.plate_solve
+
+            self.logger.debug(f"Plate solving result: {solve}")
+
+            if solve is None:
+                self.logger.error("Plate solving failed.")
+                return False
+
+            self.logger.info(
+                f"From {solve.number_of_stars} stars, solved RA: {solve.right_ascension:.4f}deg, Solved Dec: {solve.declination:.4f}deg in {solve.solve_time:.2f}ms, "
+                + f"false prob: {solve.false_positive_probability}, est fov: {solve.estimated_horizontal_fov:.3f}"
+            )
+            self._alignment_offset_dec = solve.declination - target_dec
+            self._alignment_offset_ra = solve.right_ascension - target_ra
+
+            self.logger.info(
+                f"Alignment offsets set to RA: {self._alignment_offset_ra} degrees, Dec: {self._alignment_offset_dec} degrees"
+            )
+
+            return True
+        except Exception as e:
+            self.logger.error(f"Error during alignment: {e}")
+            return False

citrascope/logging/__init__.py

@@ -0,0 +1,3 @@
+from citrascope.logging._citrascope_logger import CITRASCOPE_LOGGER
+
+__all__ = ["CITRASCOPE_LOGGER"]

citrascope/logging/_citrascope_logger.py

@@ -0,0 +1,35 @@
+import logging
+
+
+class ExcludeHttpRequestFilter(logging.Filter):
+    def filter(self, record):
+        return "HTTP Request:" not in record.getMessage()
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[94m",  # Blue
+        "INFO": "\033[92m",  # Green
+        "WARNING": "\033[93m",  # Yellow
+        "ERROR": "\033[91m",  # Red
+        "CRITICAL": "\033[95m",  # Magenta
+    }
+    RESET = "\033[0m"
+
+    def format(self, record):
+        color = self.COLORS.get(record.levelname, self.RESET)
+        record.levelname = f"{color}{record.levelname}{self.RESET}"
+        return super().format(record)
+
+
+CITRASCOPE_LOGGER = logging.getLogger()
+CITRASCOPE_LOGGER.setLevel(logging.INFO)
+
+handler = logging.StreamHandler()
+handler.addFilter(ExcludeHttpRequestFilter())
+log_format = "%(asctime)s %(levelname)s %(message)s"
+date_format = "%Y-%m-%d %H:%M:%S"
+formatter = ColoredFormatter(fmt=log_format, datefmt=date_format)
+handler.setFormatter(formatter)
+CITRASCOPE_LOGGER.handlers.clear()
+CITRASCOPE_LOGGER.addHandler(handler)