citrascope 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

citrascope/settings/settings_file_manager.py

@@ -0,0 +1,126 @@
+"""Settings file manager for CitraScope.
+
+Handles reading and writing JSON settings files using platformdirs
+for cross-platform settings directory management.
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import platformdirs
+
+from citrascope.settings.citrascope_settings import APP_AUTHOR, APP_NAME
+
+
+class SettingsFileManager:
+    """Manages settings file storage and retrieval."""
+
+    def __init__(self):
+        """Initialize the config file manager with the standard config directory."""
+        self.config_dir = Path(platformdirs.user_config_dir(APP_NAME, appauthor=APP_AUTHOR))
+        self.config_file = self.config_dir / "config.json"
+        self.log_dir = Path(platformdirs.user_log_dir(APP_NAME, appauthor=APP_AUTHOR))
+
+    def ensure_config_directory(self) -> None:
+        """Create config directory with proper permissions if it doesn't exist."""
+        if not self.config_dir.exists():
+            self.config_dir.mkdir(parents=True, mode=0o700)
+        else:
+            # Ensure proper permissions on existing directory
+            os.chmod(self.config_dir, 0o700)
+
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from JSON file.
+
+        Returns:
+            Dict containing configuration, or empty dict if file doesn't exist.
+        """
+        if not self.config_file.exists():
+            return {}
+
+        try:
+            with open(self.config_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            # Log error but return empty config to allow recovery
+            print(f"Error loading config file: {e}")
+            return {}
+
+    def save_config(self, config: Dict[str, Any]) -> None:
+        """Save configuration to JSON file with proper permissions.
+
+        Args:
+            config: Dictionary of configuration values to save.
+        """
+        self.ensure_config_directory()
+
+        # Write to temp file first, then atomic rename
+        temp_file = self.config_file.with_suffix(".json.tmp")
+        try:
+            with open(temp_file, "w") as f:
+                json.dump(config, f, indent=2)
+            # Set restrictive permissions before moving into place
+            os.chmod(temp_file, 0o600)
+            temp_file.rename(self.config_file)
+        except Exception as e:
+            # Clean up temp file on error
+            if temp_file.exists():
+                temp_file.unlink()
+            raise IOError(f"Failed to save config: {e}")
+
+    def get_config_path(self) -> Path:
+        """Get the path to the config file.
+
+        Returns:
+            Path object pointing to the config file location.
+        """
+        return self.config_file
+
+    def config_exists(self) -> bool:
+        """Check if a config file exists.
+
+        Returns:
+            True if config file exists, False otherwise.
+        """
+        return self.config_file.exists()
+
+    def validate_config(self, config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+        """Validate configuration structure.
+
+        Args:
+            config: Configuration dictionary to validate.
+
+        Returns:
+            Tuple of (is_valid, error_message).
+        """
+        # Basic validation - check that it's a dict
+        if not isinstance(config, dict):
+            return False, "Configuration must be a dictionary"
+
+        # Could add more validation here for required fields, types, etc.
+        return True, None
+
+    def ensure_log_directory(self) -> None:
+        """Create log directory if it doesn't exist."""
+        if not self.log_dir.exists():
+            self.log_dir.mkdir(parents=True)
+
+    def get_log_dir(self) -> Path:
+        """Get the path to the log directory.
+
+        Returns:
+            Path object pointing to the log directory.
+        """
+        return self.log_dir
+
+    def get_current_log_path(self) -> Path:
+        """Get the path to the current log file (dated for today).
+
+        Returns:
+            Path object pointing to today's log file.
+        """
+        today = datetime.now().strftime("%Y-%m-%d")
+        return self.log_dir / f"citrascope-{today}.log"

citrascope/tasks/runner.py

@@ -2,7 +2,7 @@ import heapq
 import os
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 
 from dateutil import parser as dtparser
 
@@ -20,58 +20,110 @@ class TaskManager:
         ground_station_record,
         logger,
         hardware_adapter: AbstractAstroHardwareAdapter,
+        keep_images: bool = False,
+        settings=None,
     ):
         self.api_client = api_client
         self.telescope_record = telescope_record
         self.ground_station_record = ground_station_record
         self.logger = logger
+        self.settings = settings
         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
+        self.keep_images = keep_images
+        self.task_retry_counts = {}  # Track retry attempts per task ID
+        self.task_last_failure = {}  # Track last failure timestamp per task ID
 
     def poll_tasks(self):
         while not self._stop_event.is_set():
             try:
+                self._report_online()
                 tasks = self.api_client.get_telescope_tasks(self.telescope_record["id"])
+
+                # If API call failed (timeout, network error, etc.), skip this poll iteration
+                if tasks is None:
+                    continue
+
                 added = 0
+                removed = 0
                 now = int(time.time())
                 with self.heap_lock:
+                    # Build a map of current valid tasks from the API
+                    api_task_map = {}
                     for task_dict in tasks:
                         try:
                             task = Task.from_dict(task_dict)
                             tid = task.id
+                            if tid and task.status in ["Pending", "Scheduled"]:
+                                api_task_map[tid] = task
+                        except Exception as e:
+                            self.logger.error(f"Error parsing task from API: {e}", exc_info=True)
+
+                    # Remove tasks from heap that are no longer valid (cancelled, completed, or not in API response)
+                    new_heap = []
+                    for start_epoch, stop_epoch, tid, task in self.task_heap:
+                        # Keep task if it's still in the API response with a valid status
+                        # Don't remove currently executing task
+                        if tid == self.current_task_id or tid in api_task_map:
+                            new_heap.append((start_epoch, stop_epoch, tid, task))
+                        else:
+                            self.logger.info(f"Removing task {tid} from queue (cancelled or status changed)")
+                            self.task_ids.discard(tid)
+                            # Clean up retry tracking
+                            self.task_retry_counts.pop(tid, None)
+                            self.task_last_failure.pop(tid, None)
+                            removed += 1
+
+                    # Rebuild heap if we removed anything
+                    if removed > 0:
+                        self.task_heap = new_heap
+                        heapq.heapify(self.task_heap)
+
+                    # Add new tasks that aren't already in the heap
+                    for tid, task in api_task_map.items():
+                        # Skip if task is in heap or is currently being executed
+                        if tid not in self.task_ids and tid != self.current_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"))
+                            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
+                            heapq.heappush(self.task_heap, (start_epoch, stop_epoch, tid, task))
+                            self.task_ids.add(tid)
+                            added += 1
+
+                    if added > 0 or removed > 0:
+                        action = []
+                        if added > 0:
+                            action.append(f"Added {added}")
+                        if removed > 0:
+                            action.append(f"Removed {removed}")
+                        self.logger.info(self._heap_summary(f"{', '.join(action)} 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 _report_online(self):
+        """
+        PUT to /telescopes to report this telescope as online.
+        """
+        telescope_id = self.telescope_record["id"]
+        iso_timestamp = datetime.now(timezone.utc).isoformat()
+        self.api_client.put_telescope_status([{"id": telescope_id, "last_connection_epoch": iso_timestamp}])
+        self.logger.debug(f"Reported online status for telescope {telescope_id} at {iso_timestamp}")
+
     def task_runner(self):
         while not self._stop_event.is_set():
             try:
@@ -98,9 +150,49 @@ class TaskManager:
                             self.logger.info(f"Completed observation task {tid} successfully.")
                             heapq.heappop(self.task_heap)
                             self.task_ids.discard(tid)
+                            # Clean up retry tracking for successful task
+                            self.task_retry_counts.pop(tid, None)
+                            self.task_last_failure.pop(tid, None)
                             completed += 1
                         else:
-                            self.logger.error(f"Observation task {tid} failed.")
+                            # Task failed - implement retry logic with exponential backoff
+                            retry_count = self.task_retry_counts.get(tid, 0)
+                            max_retries = self.settings.max_task_retries if self.settings else 3
+
+                            if retry_count >= max_retries:
+                                # Max retries exceeded - permanently fail the task
+                                self.logger.error(
+                                    f"Observation task {tid} failed after {retry_count} retries. Permanently failing."
+                                )
+                                heapq.heappop(self.task_heap)
+                                self.task_ids.discard(tid)
+                                # Clean up retry tracking
+                                self.task_retry_counts.pop(tid, None)
+                                self.task_last_failure.pop(tid, None)
+                                # Mark task as failed in API
+                                try:
+                                    self.api_client.mark_task_failed(tid)
+                                except Exception as e:
+                                    self.logger.error(f"Failed to mark task {tid} as failed in API: {e}")
+                            else:
+                                # Retry with exponential backoff
+                                self.task_retry_counts[tid] = retry_count + 1
+                                self.task_last_failure[tid] = now
+
+                                # Calculate backoff delay: initial_delay * 2^retry_count, capped at max_delay
+                                initial_delay = self.settings.initial_retry_delay_seconds if self.settings else 30
+                                max_delay = self.settings.max_retry_delay_seconds if self.settings else 300
+                                backoff_delay = min(initial_delay * (2**retry_count), max_delay)
+
+                                # Update task start time in heap to retry after backoff delay
+                                _, stop_epoch, _, task = heapq.heappop(self.task_heap)
+                                new_start_time = now + backoff_delay
+                                heapq.heappush(self.task_heap, (new_start_time, stop_epoch, tid, task))
+
+                                self.logger.warning(
+                                    f"Observation task {tid} failed (attempt {retry_count + 1}/{max_retries}). "
+                                    f"Retrying in {backoff_delay} seconds at {datetime.fromtimestamp(new_start_time).isoformat()}"
+                                )
 
                 if completed > 0:
                     self.logger.info(self._heap_summary("Completed tasks"))
@@ -113,7 +205,13 @@ class TaskManager:
 
         # stake a still
         static_task = StaticTelescopeTask(
-            self.api_client, self.hardware_adapter, self.logger, self.telescope_record, self.ground_station_record, task
+            self.api_client,
+            self.hardware_adapter,
+            self.logger,
+            self.telescope_record,
+            self.ground_station_record,
+            task,
+            self.keep_images,
         )
         return static_task.execute()
 
@@ -137,9 +235,7 @@ class TaskManager:
             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:
+            if not next_tasks:
                 summary += "No tasks scheduled."
             return summary
 

citrascope/tasks/scope/base_telescope_task.py

@@ -17,6 +17,7 @@ class AbstractBaseTelescopeTask(ABC):
         telescope_record,
         ground_station_record,
         task,
+        keep_images: bool = False,
     ):
         self.api_client = api_client
         self.hardware_adapter: AbstractAstroHardwareAdapter = hardware_adapter
@@ -24,6 +25,7 @@ class AbstractBaseTelescopeTask(ABC):
         self.telescope_record = telescope_record
         self.ground_station_record = ground_station_record
         self.task = task
+        self.keep_images = keep_images
 
     def fetch_satellite(self) -> dict | None:
         satellite_data = self.api_client.get_satellite(self.task.satelliteId)
@@ -55,17 +57,30 @@ class AbstractBaseTelescopeTask(ABC):
         )
         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}")
+    def upload_image_and_mark_complete(self, filepath: str | list[str]) -> bool:
+
+        if isinstance(filepath, str):
+            filepaths = [filepath]
         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}")
+            filepaths = filepath
+
+        for filepath in filepaths:
+            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 {filepath}")
+            else:
+                self.logger.error(f"Failed to upload image {filepath}")
+                return False
+
+            if not self.keep_images:
+                try:
+                    os.remove(filepath)
+                    self.logger.debug(f"Deleted local image file {filepath} after upload.")
+                except Exception as e:
+                    self.logger.error(f"Failed to delete local image file {filepath}: {e}")
+            else:
+                self.logger.info(f"Keeping local image file {filepath} (--keep-images flag set).")
+
         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"])

citrascope/tasks/scope/static_telescope_task.py

@@ -1,5 +1,6 @@
 import time
 
+from citrascope.hardware.abstract_astro_hardware_adapter import ObservationStrategy
 from citrascope.tasks.scope.base_telescope_task import AbstractBaseTelescopeTask
 
 
@@ -9,8 +10,15 @@ class StaticTelescopeTask(AbstractBaseTelescopeTask):
         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)
+
+        filepath = None
+        if self.hardware_adapter.get_observation_strategy() == ObservationStrategy.MANUAL:
+            self.point_to_lead_position(satellite_data)
+            filepaths = self.hardware_adapter.take_image(self.task.id, 2.0)  # 2 second exposure
+
+        if self.hardware_adapter.get_observation_strategy() == ObservationStrategy.SEQUENCE_TO_CONTROLLER:
+            # Assume the hardware adapter has already pointed the telescope and started tracking
+            filepaths = self.hardware_adapter.perform_observation_sequence(self.task.id, 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)
+        return self.upload_image_and_mark_complete(filepaths)

citrascope/web/__init__.py

@@ -0,0 +1 @@
+# Web interface module for CitraScope