citrascope 0.1.0__py3-none-any.whl

citrascope/settings/_citrascope_settings.py

@@ -0,0 +1,42 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from citrascope.logging import CITRASCOPE_LOGGER
+
+UNDEFINED_STRING = "undefined"
+
+
+class CitraScopeSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="CITRASCOPE_",
+        env_nested_delimiter="__",
+    )
+
+    # Default to production API
+    host: str = "api.citra.space"
+    port: int = 443
+
+    personal_access_token: str = UNDEFINED_STRING
+    use_ssl: bool = True
+    telescope_id: str = UNDEFINED_STRING
+
+    indi_server_url: str = "localhost"
+    indi_server_port: int = 7624
+    indi_telescope_name: str = UNDEFINED_STRING
+    indi_camera_name: str = UNDEFINED_STRING
+
+    log_level: str = "INFO"
+
+    def __init__(self, dev: bool = False, log_level: str = "INFO", **kwargs):
+        super().__init__(**kwargs)
+        self.log_level = log_level
+        if dev:
+            self.host = "dev.api.citra.space"
+            CITRASCOPE_LOGGER.info("Using development API endpoint.")
+
+    def model_post_init(self, __context) -> None:
+        if self.personal_access_token == UNDEFINED_STRING:
+            CITRASCOPE_LOGGER.warning(f"{self.__class__.__name__} personal_access_token has not been set")
+            exit(1)
+        if self.telescope_id == UNDEFINED_STRING:
+            CITRASCOPE_LOGGER.warning(f"{self.__class__.__name__} telescope_id has not been set")
+            exit(1)

citrascope/tasks/runner.py

@@ -0,0 +1,156 @@
+import heapq
+import os
+import threading
+import time
+from datetime import datetime
+
+from dateutil import parser as dtparser
+
+from citrascope.hardware.abstract_astro_hardware_adapter import AbstractAstroHardwareAdapter
+from citrascope.tasks.scope.static_telescope_task import StaticTelescopeTask
+from citrascope.tasks.scope.tracking_telescope_task import TrackingTelescopeTask
+from citrascope.tasks.task import Task
+
+
+class TaskManager:
+    def __init__(
+        self,
+        api_client,
+        telescope_record,
+        ground_station_record,
+        logger,
+        hardware_adapter: AbstractAstroHardwareAdapter,
+    ):
+        self.api_client = api_client
+        self.telescope_record = telescope_record
+        self.ground_station_record = ground_station_record
+        self.logger = logger
+        self.task_heap = []  # min-heap by start time
+        self.task_ids = set()
+        self.hardware_adapter = hardware_adapter
+        self.heap_lock = threading.RLock()
+        self._stop_event = threading.Event()
+        self.current_task_id = None  # Track currently executing task
+
+    def poll_tasks(self):
+        while not self._stop_event.is_set():
+            try:
+                tasks = self.api_client.get_telescope_tasks(self.telescope_record["id"])
+                added = 0
+                now = int(time.time())
+                with self.heap_lock:
+                    for task_dict in tasks:
+                        try:
+                            task = Task.from_dict(task_dict)
+                            tid = task.id
+                            task_start = task.taskStart
+                            task_stop = task.taskStop
+                            # Skip if task is in heap or is currently being executed
+                            if tid and task_start and tid not in self.task_ids and tid != self.current_task_id:
+                                try:
+                                    start_epoch = int(dtparser.isoparse(task_start).timestamp())
+                                    stop_epoch = int(dtparser.isoparse(task_stop).timestamp()) if task_stop else 0
+                                except Exception:
+                                    self.logger.error(f"Could not parse taskStart/taskStop for task {tid}")
+                                    continue
+                                if stop_epoch and stop_epoch < now:
+                                    self.logger.debug(f"Skipping past task {tid} that ended at {task_stop}")
+                                    continue  # Skip tasks whose end date has passed
+                                if task.status not in ["Pending", "Scheduled"]:
+                                    self.logger.debug(f"Skipping task {tid} with status {task.status}")
+                                    continue  # Only schedule pending/scheduled tasks
+                                heapq.heappush(self.task_heap, (start_epoch, stop_epoch, tid, task))
+                                self.task_ids.add(tid)
+                                added += 1
+                        except Exception as e:
+                            self.logger.error(f"Error adding task {tid} to heap: {e}", exc_info=True)
+                    if added > 0:
+                        self.logger.info(self._heap_summary("Added tasks"))
+                    self.logger.info(self._heap_summary("Polled tasks"))
+            except Exception as e:
+                self.logger.error(f"Exception in poll_tasks loop: {e}", exc_info=True)
+                time.sleep(5)  # avoid tight error loop
+            self._stop_event.wait(15)
+
+    def task_runner(self):
+        while not self._stop_event.is_set():
+            try:
+                now = int(time.time())
+                completed = 0
+                while True:
+                    with self.heap_lock:
+                        if not (self.task_heap and self.task_heap[0][0] <= now):
+                            break
+                        _, _, tid, task = self.task_heap[0]
+                        self.logger.info(f"Starting task {tid} at {datetime.now().isoformat()}: {task}")
+                        self.current_task_id = tid  # Mark as in-flight
+
+                    # Observation is now outside the lock!
+                    try:
+                        observation_succeeded = self._observe_satellite(task)
+                    except Exception as e:
+                        self.logger.error(f"Exception during observation for task {tid}: {e}", exc_info=True)
+                        observation_succeeded = False
+
+                    with self.heap_lock:
+                        self.current_task_id = None  # Clear after done (success or fail)
+                        if observation_succeeded:
+                            self.logger.info(f"Completed observation task {tid} successfully.")
+                            heapq.heappop(self.task_heap)
+                            self.task_ids.discard(tid)
+                            completed += 1
+                        else:
+                            self.logger.error(f"Observation task {tid} failed.")
+
+                if completed > 0:
+                    self.logger.info(self._heap_summary("Completed tasks"))
+            except Exception as e:
+                self.logger.error(f"Exception in task_runner loop: {e}", exc_info=True)
+                time.sleep(5)  # avoid tight error loop
+            self._stop_event.wait(1)
+
+    def _observe_satellite(self, task: Task):
+
+        # stake a still
+        static_task = StaticTelescopeTask(
+            self.api_client, self.hardware_adapter, self.logger, self.telescope_record, self.ground_station_record, task
+        )
+        return static_task.execute()
+
+        # track the sat for a while with longer exposure
+        # tracking_task = TrackingTelescopeTask(
+        #     self.api_client, self.hardware_adapter, self.logger, self.telescope_record, self.ground_station_record, task
+        # )
+        # return tracking_task.execute()
+
+    def _heap_summary(self, event):
+        with self.heap_lock:
+            summary = f"{event}: {len(self.task_heap)} tasks in queue. "
+            next_tasks = []
+            if self.task_heap:
+                next_tasks = [
+                    f"{tid} at {datetime.fromtimestamp(start).isoformat()}"
+                    for start, stop, tid, _ in self.task_heap[:3]
+                ]
+                if len(self.task_heap) > 3:
+                    next_tasks.append(f"... ({len(self.task_heap)-3} more)")
+            if self.current_task_id is not None:
+                # Show the current in-flight task at the front
+                summary += f"Current: {self.current_task_id}. "
+            if next_tasks and len(next_tasks) > 1 and self.current_task_id != next_tasks[0].split()[0]:
+                summary += "Next: " + ", ".join(next_tasks)
+            else:
+                summary += "No tasks scheduled."
+            return summary
+
+    def start(self):
+        self._stop_event.clear()
+        self.poll_thread = threading.Thread(target=self.poll_tasks, daemon=True)
+        self.runner_thread = threading.Thread(target=self.task_runner, daemon=True)
+        self.poll_thread.start()
+        self.runner_thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+        self.poll_thread.join()
+        self.runner_thread.join()

citrascope/tasks/scope/base_telescope_task.py

@@ -0,0 +1,205 @@
+import os
+import time
+from abc import ABC, abstractmethod
+
+from dateutil import parser as dtparser
+from skyfield.api import Angle, EarthSatellite, load, wgs84
+
+from citrascope.hardware.abstract_astro_hardware_adapter import AbstractAstroHardwareAdapter
+
+
+class AbstractBaseTelescopeTask(ABC):
+    def __init__(
+        self,
+        api_client,
+        hardware_adapter: AbstractAstroHardwareAdapter,
+        logger,
+        telescope_record,
+        ground_station_record,
+        task,
+    ):
+        self.api_client = api_client
+        self.hardware_adapter: AbstractAstroHardwareAdapter = hardware_adapter
+        self.logger = logger
+        self.telescope_record = telescope_record
+        self.ground_station_record = ground_station_record
+        self.task = task
+
+    def fetch_satellite(self) -> dict | None:
+        satellite_data = self.api_client.get_satellite(self.task.satelliteId)
+        if not satellite_data:
+            self.logger.error(f"Could not fetch satellite data for {self.task.satelliteId}")
+            return None
+        elsets = satellite_data.get("elsets", [])
+        if not elsets:
+            self.logger.error(f"No elsets found for satellite {self.task.satelliteId}")
+            return None
+        satellite_data["most_recent_elset"] = self._get_most_recent_elset(satellite_data)
+        return satellite_data
+
+    def _get_most_recent_elset(self, satellite_data) -> dict | None:
+        if "most_recent_elset" in satellite_data:
+            return satellite_data["most_recent_elset"]
+
+        elsets = satellite_data.get("elsets", [])
+        if not elsets:
+            self.logger.error(f"No elsets found for satellite {self.task.satelliteId}")
+            return None
+        most_recent_elset = max(
+            elsets,
+            key=lambda e: (
+                dtparser.isoparse(e["creationEpoch"])
+                if e.get("creationEpoch")
+                else dtparser.isoparse("1970-01-01T00:00:00Z")
+            ),
+        )
+        return most_recent_elset
+
+    def upload_image_and_mark_complete(self, filepath):
+        upload_result = self.api_client.upload_image(self.task.id, self.telescope_record["id"], filepath)
+        if upload_result:
+            self.logger.info(f"Successfully uploaded image for task {self.task.id}")
+        else:
+            self.logger.error(f"Failed to upload image for task {self.task.id}")
+        try:
+            os.remove(filepath)
+            self.logger.info(f"Deleted local image file {filepath} after upload.")
+        except Exception as e:
+            self.logger.error(f"Failed to delete local image file {filepath}: {e}")
+        marked_complete = self.api_client.mark_task_complete(self.task.id)
+        if not marked_complete:
+            task_check = self.api_client.get_telescope_tasks(self.telescope_record["id"])
+            for t in task_check:
+                if t["id"] == self.task.id and t.get("status") == "Succeeded":
+                    self.logger.info(f"Task {self.task.id} is already marked complete.")
+                    return True
+            self.logger.error(f"Failed to mark task {self.task.id} as complete.")
+            return False
+        self.logger.info(f"Marked task {self.task.id} as complete.")
+        return True
+
+    @abstractmethod
+    def execute(self):
+        pass
+
+    def _get_skyfield_ground_station_and_satellite(self, satellite_data):
+        """
+        Returns (ground_station, satellite, ts) Skyfield objects for the given satellite and elset.
+        """
+        ts = load.timescale()
+        most_recent_elset = self._get_most_recent_elset(satellite_data)
+        if most_recent_elset is None:
+            raise ValueError("No valid elset available for satellite.")
+
+        ground_station = wgs84.latlon(
+            self.ground_station_record["latitude"],
+            self.ground_station_record["longitude"],
+            elevation_m=self.ground_station_record["altitude"],
+        )
+        satellite = EarthSatellite(most_recent_elset["tle"][0], most_recent_elset["tle"][1], satellite_data["name"], ts)
+        return ground_station, satellite, ts
+
+    def get_target_radec_and_rates(self, satellite_data, seconds_from_now: float = 0.0):
+        ground_station, satellite, ts = self._get_skyfield_ground_station_and_satellite(satellite_data)
+        difference = satellite - ground_station
+        days_to_add = seconds_from_now / (24 * 60 * 60)  # Skyfield uses days
+        topocentric = difference.at(ts.now() + days_to_add)
+        target_ra, target_dec, _ = topocentric.radec()
+
+        # determine ra/dec travel rates
+        rates = topocentric.frame_latlon_and_rates(
+            ground_station
+        )  # TODO can this be collapsed with .radec() call above?
+        target_dec_rate = rates[4]
+        target_ra_rate = rates[3]
+
+        return target_ra, target_dec, target_ra_rate, target_dec_rate
+
+    def predict_slew_time_seconds(self, satellite_data, seconds_from_now: float = 0.0) -> float:
+        current_scope_ra, current_scope_dec = self.hardware_adapter.get_telescope_direction()
+        current_target_ra, current_target_dec, _, _ = self.get_target_radec_and_rates(satellite_data, seconds_from_now)
+
+        ra_diff_deg = abs((current_target_ra.degrees - current_scope_ra))  # type: ignore
+        dec_diff_deg = abs(current_target_dec.degrees - current_scope_dec)  # type: ignore
+
+        if ra_diff_deg > dec_diff_deg:
+            return ra_diff_deg / self.hardware_adapter.scope_slew_rate_degrees_per_second
+        else:
+            return dec_diff_deg / self.hardware_adapter.scope_slew_rate_degrees_per_second
+
+    def point_to_lead_position(self, satellite_data):
+
+        self.logger.debug(f"Using TLE {satellite_data['most_recent_elset']['tle']}")
+
+        max_angular_distance_deg = 0.3
+        attempts = 0
+        max_attempts = 10
+        while attempts < max_attempts:
+            attempts += 1
+            # Estimate lead position and slew time
+            lead_ra, lead_dec, est_slew_time = self.estimate_lead_position(satellite_data)
+            self.logger.info(
+                f"Pointing ahead to RA: {lead_ra.hours:.4f}h, DEC: {lead_dec.degrees:.4f}°, estimated slew time: {est_slew_time:.1f}s"
+            )
+
+            # Move the scope
+            slew_start_time = time.time()
+            self.hardware_adapter.point_telescope(lead_ra.hours, lead_dec.degrees)  # type: ignore
+            while self.hardware_adapter.telescope_is_moving():
+                self.logger.debug(f"Slewing to lead position for {satellite_data['name']}...")
+                time.sleep(0.1)
+
+            slew_duration = time.time() - slew_start_time
+            self.logger.info(
+                f"Telescope slew done, took {slew_duration:.1f} sec, off by {abs(slew_duration - est_slew_time):.1f} sec."
+            )
+
+            # check our alignment against the starfield
+            # is_aligned = self.hardware_adapter.perform_alignment(lead_ra.degrees, lead_dec.degrees)  # type: ignore
+            # if not is_aligned:
+            #     continue  # try again with the new alignment offsets
+
+            # Check angular distance to satellite's current position
+            current_scope_ra, current_scope_dec = self.hardware_adapter.get_telescope_direction()
+            current_satellite_position = self.get_target_radec_and_rates(satellite_data)
+            current_angular_distance_deg = self.hardware_adapter.angular_distance(
+                current_scope_ra,
+                current_scope_dec,
+                current_satellite_position[0].degrees,  # type: ignore
+                current_satellite_position[1].degrees,  # type: ignore
+            )
+            self.logger.info(f"Current angular distance to satellite is {current_angular_distance_deg:.3f} degrees.")
+            if current_angular_distance_deg <= max_angular_distance_deg:
+                self.logger.info("Telescope is within acceptable range of target.")
+                break
+
+    def estimate_lead_position(
+        self,
+        satellite_data: dict,
+        max_iterations: int = 5,
+        tolerance: float = 0.1,
+    ):
+        """
+        Iteratively estimate the future RA/Dec where the satellite will be when the telescope finishes slewing.
+
+        Args:
+            satellite_data: Satellite data dict.
+            max_iterations: Maximum number of iterations.
+            tolerance: Convergence threshold in seconds.
+
+        Returns:
+            Tuple of (target_ra, target_dec, estimated_slew_time)
+        """
+        # Get initial estimate
+        est_slew_time = self.predict_slew_time_seconds(satellite_data)
+        for _ in range(max_iterations):
+            future_radec = self.get_target_radec_and_rates(satellite_data, est_slew_time)
+            try:
+                new_slew_time = self.predict_slew_time_seconds(satellite_data, est_slew_time)
+            except TypeError:
+                # Fallback for legacy predict_slew_time_seconds signature
+                new_slew_time = self.predict_slew_time_seconds(satellite_data)
+            if abs(new_slew_time - est_slew_time) < tolerance:
+                break
+            est_slew_time = new_slew_time
+        return future_radec[0], future_radec[1], est_slew_time

citrascope/tasks/scope/static_telescope_task.py

@@ -0,0 +1,16 @@
+import time
+
+from citrascope.tasks.scope.base_telescope_task import AbstractBaseTelescopeTask
+
+
+class StaticTelescopeTask(AbstractBaseTelescopeTask):
+    def execute(self):
+
+        satellite_data = self.fetch_satellite()
+        if not satellite_data or satellite_data.get("most_recent_elset") is None:
+            raise ValueError("Could not fetch valid satellite data or TLE.")
+        self.point_to_lead_position(satellite_data)
+
+        # Take the image
+        filepath = self.hardware_adapter.take_image(self.task.id, 2.0)  # 2 second exposure
+        return self.upload_image_and_mark_complete(filepath)

citrascope/tasks/scope/tracking_telescope_task.py

@@ -0,0 +1,28 @@
+import time
+
+from citrascope.tasks.scope.base_telescope_task import AbstractBaseTelescopeTask
+
+
+class TrackingTelescopeTask(AbstractBaseTelescopeTask):
+    def execute(self):
+
+        satellite_data = self.fetch_satellite()
+        if not satellite_data or satellite_data.get("most_recent_elset") is None:
+            raise ValueError("Could not fetch valid satellite data or TLE.")
+
+        self.point_to_lead_position(satellite_data)
+
+        # determine appropriate tracking rates based on satellite motion
+        _, _, target_ra_rate, target_dec_rate = self.get_target_radec_and_rates(satellite_data)
+
+        # Set the telescope tracking rates
+        tracking_set = self.hardware_adapter.set_custom_tracking_rate(
+            target_ra_rate.arcseconds.per_second, target_dec_rate.arcseconds.per_second
+        )
+        if not tracking_set:
+            self.logger.error("Failed to set tracking rates on telescope.")
+            return False
+
+        # Take the image
+        filepath = self.hardware_adapter.take_image(self.task.id, 20.0)  # 20 second exposure
+        return self.upload_image_and_mark_complete(filepath)

citrascope/tasks/task.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Task:
+    id: str
+    type: str
+    status: str
+    creationEpoch: str
+    updateEpoch: str
+    taskStart: str
+    taskStop: str
+    userId: str
+    username: str
+    satelliteId: str
+    satelliteName: str
+    telescopeId: str
+    telescopeName: str
+    groundStationId: str
+    groundStationName: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Task":
+        return cls(
+            id=data.get("id"),
+            type=data.get("type", ""),
+            status=data.get("status"),
+            creationEpoch=data.get("creationEpoch", ""),
+            updateEpoch=data.get("updateEpoch", ""),
+            taskStart=data.get("taskStart", ""),
+            taskStop=data.get("taskStop", ""),
+            userId=data.get("userId", ""),
+            username=data.get("username", ""),
+            satelliteId=data.get("satelliteId", ""),
+            satelliteName=data.get("satelliteName", ""),
+            telescopeId=data.get("telescopeId", ""),
+            telescopeName=data.get("telescopeName", ""),
+            groundStationId=data.get("groundStationId", ""),
+            groundStationName=data.get("groundStationName", ""),
+        )
+
+    def __repr__(self):
+        return f"<Task {self.id} {self.type} {self.status}>"

citrascope-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: citrascope
+Version: 0.1.0
+Summary: Remotely control a telescope while it polls for tasks, collects and edge processes data, and delivers results and data for further processing.
+Author-email: Christopher Stevens <chris@citra.space>
+License-Expression: MIT
+Requires-Python: >=3.9
+Requires-Dist: click
+Requires-Dist: httpx
+Requires-Dist: pixelemon
+Requires-Dist: pydantic-settings
+Requires-Dist: pyindi-client
+Requires-Dist: pytest-cov
+Requires-Dist: python-dateutil
+Requires-Dist: python-json-logger
+Requires-Dist: requests
+Requires-Dist: skyfield
+Requires-Dist: types-python-dateutil
+Provides-Extra: build
+Requires-Dist: build; extra == 'build'
+Provides-Extra: deploy
+Requires-Dist: twine; extra == 'deploy'
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: flake8-pytest-style; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mockito; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
+Requires-Dist: sphinx-markdown-builder; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: mockito; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Description-Content-Type: text/markdown
+
+# CitraScope
+[![Pytest](https://github.com/citra-space/citrascope/actions/workflows/pytest.yml/badge.svg)](https://github.com/citra-space/citrascope/actions/workflows/pytest.yml) [![Build and Push Docker Image](https://github.com/citra-space/citrascope/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/citra-space/citrascope/actions/workflows/docker-publish.yml)
+
+Remotely control a telescope while it polls for tasks, collects observations, and delivers data for further processing.
+
+## Features
+
+- Connects to Citra.space's API and identifies itself as an online telescope
+- Connects to configured INDI telescope and camera hardware
+- Acts as a task daemon carrying out and remitting photography tasks
+
+## Installation
+
+Install CitraScope from PyPI:
+
+```sh
+pip install citrascope
+```
+
+This provides the `citrascope` command-line tool. To see available commands:
+
+```sh
+citrascope --help
+```
+
+## Usage
+
+Run the CLI tool:
+
+```sh
+citrascope start
+```
+
+To connect to the Citra Dev server:
+
+```sh
+citrascope start --dev
+```
+
+## Configuration
+
+Settings are managed via environment variables with the prefix `CITRASCOPE_`. You must configure your personal access token and telescope ID, as well as INDI server details. You can set these variables in your shell or in a `.env` file at the project root.
+
+Example `.env` file:
+
+```env
+CITRASCOPE_PERSONAL_ACCESS_TOKEN=citra_pat_xxx
+CITRASCOPE_TELESCOPE_ID=xxx
+# CITRASCOPE_INDI_SERVER_URL=127.0.0.1
+CITRASCOPE_INDI_SERVER_URL=host.docker.internal  # use with devcontainer for accessing a localhost indi server
+CITRASCOPE_INDI_SERVER_PORT=7624
+CITRASCOPE_INDI_TELESCOPE_NAME=Telescope Simulator
+```
+
+**Variable descriptions:**
+
+- `CITRASCOPE_PERSONAL_ACCESS_TOKEN`: Your CitraScope personal access token (required)
+- `CITRASCOPE_TELESCOPE_ID`: Your telescope ID (required)
+- `CITRASCOPE_INDI_SERVER_URL`: Hostname or IP address of the INDI server (default: `host.docker.internal` for devcontainers, or `127.0.0.1` for local)
+- `CITRASCOPE_INDI_SERVER_PORT`: Port for the INDI server (default: `7624`)
+- `CITRASCOPE_INDI_TELESCOPE_NAME`: Name of the INDI telescope device (default: `Telescope Simulator`)
+
+You can copy `.env.example` to `.env` and tweak your values.
+
+## Developer Setup
+
+If you are developing on macOS or Windows, use the provided [VS Code Dev Container](https://code.visualstudio.com/docs/devcontainers/containers) setup. The devcontainer provides a full Linux environment, which is required for the `pyindi-client` dependency to work. This is necessary because `pyindi-client` only works on Linux, and will not function natively on Mac or Windows.
+
+By opening this project in VS Code and choosing "Reopen in Container" (or using the Dev Containers extension), you can develop and run the project seamlessly, regardless of your host OS.
+
+The devcontainer also ensures all required system dependencies (like `cmake`) are installed automatically.
+
+### Installing Development Dependencies
+
+To install development dependencies (for code style, linting, and pre-commit hooks):
+
+```sh
+pip install '.[dev]'
+```
+
+### Setting up Pre-commit Hooks
+
+This project uses [pre-commit](https://pre-commit.com/) to run code quality checks (like Flake8, Black, isort, etc.) automatically before each commit.
+
+After installing the dev dependencies, enable the hooks with:
+
+```sh
+pre-commit install
+```
+
+You can manually run all pre-commit checks on all files with:
+
+```sh
+pre-commit run --all-files
+```
+
+This ensures code style and quality checks are enforced for all contributors.
+
+### Running and Debugging with VS Code
+
+If you are using Visual Studio Code, you can run or debug the project directly using the pre-configured launch options in `.vscode/launch.json`:
+
+- **Python: citrascope dev start** — Runs the main entry point with development options.
+- **Python: citrascope dev start DEBUG logging** — Runs with development options and sets log level to DEBUG for more detailed output.
+
+To use these, open the Run and Debug panel in VS Code, select the desired configuration, and click the Run or Debug button. This is a convenient way to start or debug the app without manually entering commands.
+
+## Running Tests
+
+This project uses [pytest](https://pytest.org/) for unit testing. All tests are located in the `tests/` directory.
+
+To run tests manually:
+
+```bash
+pytest
+```

citrascope-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+citrascope/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+citrascope/__main__.py,sha256=MlIzMVRL_tnvd8vJcZXENIglepirST3KDPfVpN7V9bE,673
+citrascope/citra_scope_daemon.py,sha256=rQ4U7r2q5n9FSxM7E7xTdhpJjYCT7Mv_3PhUPkWwMTc,4073
+citrascope/api/abstract_api_client.py,sha256=FG386RwHZtsCNaGGx0bhwxajyj_0B6SxU3p2w0R4tYU,472
+citrascope/api/citra_api_client.py,sha256=7T7woGN-cjTYF8CNkGSjWXCKO-q0ufnBLGrdT2pdY3w,4173
+citrascope/hardware/abstract_astro_hardware_adapter.py,sha256=JOw0PDoFrgicB5qZrurlLrVcDsjQNjHcxyFJ6674KJ8,3748
+citrascope/hardware/indi_adapter.py,sha256=57AvH-AzthqXyefUgMq21GfcFfNh9WcGoara03NiJkg,12564
+citrascope/logging/__init__.py,sha256=bXX2PX6MZelEX3fi_-lmT51uZCfN9WnLPZfx5_RswAA,101
+citrascope/logging/_citrascope_logger.py,sha256=-KZ3ufQc3VOSlP1I3KC1YFDU7o880-O0iu3URlzRGlM,1056
+citrascope/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+citrascope/settings/_citrascope_settings.py,sha256=JpuVFroZERPjbx58ZCw9BM9xr41qW6MNxm3sYGjYS14,1386
+citrascope/tasks/runner.py,sha256=pUyQlrQkSNbM_SKl6AUFY8QSV2NzZfGvybGlzV7Q-BU,7320
+citrascope/tasks/task.py,sha256=0u0oN56E6KaNz19ba_7WuY43Sk4CTXc8UPT7sdUpRXo,1287
+citrascope/tasks/scope/base_telescope_task.py,sha256=He8W9OSHDL2tp56sY5dPdtYDswzp5HDMMeWpSNYNcgY,9198
+citrascope/tasks/scope/static_telescope_task.py,sha256=DTrKZiOJ3ZPSDPvmMbyWkW50kS4I6Li6qC6SyrpWbaI,612
+citrascope/tasks/scope/tracking_telescope_task.py,sha256=k5LEmEi_xnFHNjqPNYb8_tqDdCFD3YGe25Wh_brJXHk,1130
+docs/index.md,sha256=YQDeVrN9AcbRzo88Jc4iRCO70gAh_4GSgImrJMwcSCo,1402
+citrascope-0.1.0.dist-info/METADATA,sha256=u7Uc7lN6PZz78TUNFqmYe3IWBgxPdfudIpg31kuuVX0,5817
+citrascope-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+citrascope-0.1.0.dist-info/entry_points.txt,sha256=fP22Lt8bNZ_whBowDnOWSADf_FUrgAWnIhqqPf5Xo2g,55
+citrascope-0.1.0.dist-info/RECORD,,

citrascope-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any