citrascope 0.4.0__tar.gz → 0.5.0__tar.gz

{citrascope-0.4.0 → citrascope-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: citrascope
-Version: 0.4.0
+Version: 0.5.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: Patrick McDavid <patrick@citra.space>
 License-Expression: MIT

{citrascope-0.4.0 → citrascope-0.5.0}/citrascope/citra_scope_daemon.py

@@ -35,6 +35,7 @@ class CitraScopeDaemon:
         self.ground_station = None
         self.telescope_record = None
         self.configuration_error: Optional[str] = None
+        self._autofocus_in_progress = False
 
         # Create web server instance (always enabled)
         self.web_server = CitraScopeWebServer(daemon=self, host="0.0.0.0", port=self.settings.web_port)
@@ -177,6 +178,9 @@ class CitraScopeDaemon:
                 f"Hardware connected. Slew rate: {self.hardware_adapter.scope_slew_rate_degrees_per_second} deg/sec"
             )
 
+            # Save filter configuration if adapter supports it
+            self._save_filter_config()
+
             self.task_manager = TaskManager(
                 self.api_client,
                 citra_telescope_record,
@@ -196,6 +200,83 @@ class CitraScopeDaemon:
             CITRASCOPE_LOGGER.error(error_msg, exc_info=True)
             return False, error_msg
 
+    def is_autofocus_in_progress(self) -> bool:
+        """Check if autofocus routine is currently running.
+
+        Returns:
+            bool: True if autofocus is in progress, False otherwise
+        """
+        return self._autofocus_in_progress
+
+    def _save_filter_config(self):
+        """Save filter configuration from adapter to settings if supported.
+
+        This method is called:
+        - After hardware initialization to save discovered filters
+        - After autofocus to save updated focus positions
+        - After manual filter focus updates via web API
+
+        Thread safety: This modifies self.settings and writes to disk.
+        Should be called from main daemon thread or properly synchronized.
+        """
+        if not self.hardware_adapter or not self.hardware_adapter.supports_filter_management():
+            return
+
+        try:
+            filter_config = self.hardware_adapter.get_filter_config()
+            if filter_config:
+                self.settings.adapter_settings["filters"] = filter_config
+                self.settings.save()
+                CITRASCOPE_LOGGER.info(f"Saved filter configuration with {len(filter_config)} filters")
+        except Exception as e:
+            CITRASCOPE_LOGGER.warning(f"Failed to save filter configuration: {e}")
+
+    def trigger_autofocus(self) -> tuple[bool, Optional[str]]:
+        """Trigger autofocus routine on the hardware adapter.
+
+        Requires task processing to be manually paused before running.
+        Checks that both:
+        1. Task processing is paused
+        2. No task is currently in-flight
+
+        Returns:
+            Tuple of (success, error_message)
+        """
+        if not self.hardware_adapter:
+            return False, "No hardware adapter initialized"
+
+        if not self.hardware_adapter.supports_filter_management():
+            return False, "Hardware adapter does not support filter management"
+
+        # Prevent concurrent autofocus operations
+        if self._autofocus_in_progress:
+            return False, "Autofocus already in progress"
+
+        # Require task processing to be manually paused
+        if self.task_manager:
+            if self.task_manager.is_processing_active():
+                return False, "Task processing must be paused before running autofocus"
+
+            if self.task_manager.current_task_id is not None:
+                return False, "A task is currently executing. Please wait for it to complete and try again"
+
+        self._autofocus_in_progress = True
+        try:
+            CITRASCOPE_LOGGER.info("Starting autofocus routine...")
+            self.hardware_adapter.do_autofocus()
+
+            # Save updated filter configuration after autofocus
+            self._save_filter_config()
+
+            CITRASCOPE_LOGGER.info("Autofocus routine completed successfully")
+            return True, None
+        except Exception as e:
+            error_msg = f"Autofocus failed: {str(e)}"
+            CITRASCOPE_LOGGER.error(error_msg, exc_info=True)
+            return False, error_msg
+        finally:
+            self._autofocus_in_progress = False
+
     def run(self):
         # Start web server FIRST, so users can monitor/configure
         # The web interface will remain available even if configuration is incomplete

{citrascope-0.4.0 → citrascope-0.5.0}/citrascope/hardware/abstract_astro_hardware_adapter.py

@@ -20,6 +20,18 @@ class SettingSchemaEntry(TypedDict, total=False):
     options: list[str]  # List of valid options for select/dropdown inputs
 
 
+class FilterConfig(TypedDict):
+    """Type definition for filter configuration.
+
+    Attributes:
+        name: Human-readable filter name (e.g., 'Luminance', 'Red', 'Ha')
+        focus_position: Focuser position for this filter in steps
+    """
+
+    name: str
+    focus_position: int
+
+
 class ObservationStrategy(Enum):
     MANUAL = 1
     SEQUENCE_TO_CONTROLLER = 2
@@ -176,3 +188,52 @@ class AbstractAstroHardwareAdapter(ABC):
             bool: True if alignment was successful, False otherwise.
         """
         pass
+
+    def do_autofocus(self) -> None:
+        """Perform autofocus routine for all filters.
+
+        This is an optional method for adapters that support filter management.
+        Default implementation raises NotImplementedError. Override in subclasses
+        that support autofocus.
+
+        Raises:
+            NotImplementedError: If the adapter doesn't support autofocus
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support autofocus")
+
+    def supports_filter_management(self) -> bool:
+        """Indicates whether this adapter supports filter/focus management.
+
+        Returns:
+            bool: True if the adapter manages filters and focus positions, False otherwise.
+        """
+        return False
+
+    def get_filter_config(self) -> dict[str, FilterConfig]:
+        """Get the current filter configuration including focus positions.
+
+        Returns:
+            dict: Dictionary mapping filter IDs (as strings) to FilterConfig.
+                  Each FilterConfig contains:
+                  - name (str): Filter name
+                  - focus_position (int): Focuser position for this filter
+
+        Example:
+            {
+                "1": {"name": "Luminance", "focus_position": 9000},
+                "2": {"name": "Red", "focus_position": 9050}
+            }
+        """
+        return {}
+
+    def update_filter_focus(self, filter_id: str, focus_position: int) -> bool:
+        """Update the focus position for a specific filter.
+
+        Args:
+            filter_id: Filter ID as string
+            focus_position: New focus position in steps
+
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
+        return False

{citrascope-0.4.0 → citrascope-0.5.0}/citrascope/hardware/nina_adv_http_adapter.py

@@ -5,16 +5,16 @@ import os
 import sys
 import time
 from pathlib import Path
+from typing import Any
 
-import platformdirs
 import requests
 
 from citrascope.hardware.abstract_astro_hardware_adapter import (
     AbstractAstroHardwareAdapter,
+    FilterConfig,
     ObservationStrategy,
     SettingSchemaEntry,
 )
-from citrascope.settings.citrascope_settings import APP_AUTHOR, APP_NAME
 
 
 class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
@@ -32,47 +32,17 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
     def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
         super().__init__(images_dir=images_dir)
         self.logger: logging.Logger = logger
-        self._data_dir = Path(platformdirs.user_data_dir(APP_NAME, appauthor=APP_AUTHOR))
-        self._focus_positions_file = self._data_dir / "nina_focus_positions.json"
         self.nina_api_path = kwargs.get("nina_api_path", "http://nina:1888/v2/api")
-        self.bypass_autofocus = kwargs.get("bypass_autofocus", False)
 
         self.filter_map = {}
-        self._load_focus_positions()
-
-    def _load_focus_positions(self):
-        """Load focus positions from file if available."""
-        try:
-            if self._focus_positions_file.exists():
-                with open(self._focus_positions_file, "r") as f:
-                    focus_data = json.load(f)
-                if self.logger:
-                    self.logger.info(f"Loaded focus positions from {self._focus_positions_file}")
-                self._focus_positions_cache = focus_data
-            else:
-                self._focus_positions_cache = {}
-        except Exception as e:
-            if self.logger:
-                self.logger.warning(f"Could not load focus positions file: {e}")
-            self._focus_positions_cache = {}
-
-    def _save_focus_positions(self):
-        """Save current filter_map focus positions to file."""
-        try:
-            # Ensure data directory exists
-            self._data_dir.mkdir(parents=True, exist_ok=True)
-
-            focus_data = {
-                str(fid): {"name": fdata["name"], "focus_position": fdata["focus_position"]}
-                for fid, fdata in self.filter_map.items()
-            }
-            with open(self._focus_positions_file, "w") as f:
-                json.dump(focus_data, f, indent=2)
-            if self.logger:
-                self.logger.info(f"Saved focus positions to {self._focus_positions_file}")
-        except Exception as e:
-            if self.logger:
-                self.logger.warning(f"Could not save focus positions file: {e}")
+        # Load filter configuration from settings if available
+        saved_filters = kwargs.get("filters", {})
+        for filter_id, filter_data in saved_filters.items():
+            # Convert string keys back to int for internal use
+            try:
+                self.filter_map[int(filter_id)] = filter_data
+            except (ValueError, TypeError) as e:
+                self.logger.warning(f"Invalid filter ID '{filter_id}' in settings, skipping: {e}")
 
     @classmethod
     def get_settings_schema(cls) -> list[SettingSchemaEntry]:
@@ -90,17 +60,20 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "http://localhost:1888/v2/api",
                 "pattern": r"^https?://.*",
             },
-            {
-                "name": "bypass_autofocus",
-                "friendly_name": "Bypass Autofocus",
-                "type": "bool",
-                "default": False,
-                "description": "Skip autofocus routine when initializing, will use cached focus positions if available",
-                "required": False,
-            },
         ]
 
     def do_autofocus(self):
+        """Perform autofocus routine for all filters.
+
+        Slews telescope to Mirach (bright reference star) and runs autofocus
+        for each filter in the filter map, updating focus positions.
+
+        Raises:
+            RuntimeError: If no filters discovered or network requests fail
+        """
+        if not self.filter_map:
+            raise RuntimeError("No filters discovered. Cannot perform autofocus.")
+
         self.logger.info("Performing autofocus routine ...")
         # move telescope to bright star and start autofocus
         # Mirach ra=(1+9/60.+47.45/3600.)*15 dec=(35+37/60.+11.1/3600.)
@@ -108,10 +81,15 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         dec = 35 + 37 / 60.0 + 11.1 / 3600.0
 
         self.logger.info("Slewing to Mirach ...")
-        mount_status = requests.get(
-            self.nina_api_path + self.MOUNT_URL + "slew?ra=" + str(ra) + "&dec=" + str(dec)
-        ).json()
-        self.logger.info(f"Mount {mount_status['Response']}")
+        try:
+            response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}", timeout=30)
+            response.raise_for_status()
+            mount_status = response.json()
+            self.logger.info(f"Mount {mount_status['Response']}")
+        except requests.Timeout:
+            raise RuntimeError("Mount slew request timed out")
+        except requests.RequestException as e:
+            raise RuntimeError(f"Mount slew failed: {e}")
 
         # wait for slew to complete
         while self.telescope_is_moving():
@@ -120,14 +98,13 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         for id, filter in self.filter_map.items():
             self.logger.info(f"Focusing Filter ID: {id}, Name: {filter['name']}")
-            focus_value = self._auto_focus_one_filter(id, filter["name"])
+            # Pass existing focus position to preserve it if autofocus fails
+            existing_focus = filter.get("focus_position", self.DEFAULT_FOCUS_POSITION)
+            focus_value = self._auto_focus_one_filter(id, filter["name"], existing_focus)
             self.filter_map[id]["focus_position"] = focus_value
 
-        # Save focus positions after autofocus
-        self._save_focus_positions()
-
     # autofocus routine
-    def _auto_focus_one_filter(self, filter_id, filter_name) -> int:
+    def _auto_focus_one_filter(self, filter_id: int, filter_name: str, existing_focus_position: int) -> int:
 
         # change to the requested filter
         correct_filter_in_place = False
@@ -165,8 +142,13 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         if not last_completed_autofocus.get("Success"):
             self.logger.error(f"Failed to start autofocus: {last_completed_autofocus.get('Error')}")
-            self.logger.warning("Using default focus position")
-            return starting_focus_position
+            # Preserve existing focus position if it's not the default, otherwise use default
+            if existing_focus_position != self.DEFAULT_FOCUS_POSITION:
+                self.logger.warning(f"Preserving existing focus position: {existing_focus_position}")
+                return existing_focus_position
+            else:
+                self.logger.warning(f"Using default focus position: {self.DEFAULT_FOCUS_POSITION}")
+                return self.DEFAULT_FOCUS_POSITION
 
         while (
             last_completed_autofocus["Response"]["Filter"] != filter_name
@@ -186,13 +168,22 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
     def _do_point_telescope(self, ra: float, dec: float):
         self.logger.info(f"Slewing to RA: {ra}, Dec: {dec}")
-        slew_response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}").json()
+        try:
+            response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}", timeout=30)
+            response.raise_for_status()
+            slew_response = response.json()
 
-        if slew_response.get("Success"):
-            self.logger.info(f"Mount slew initiated: {slew_response['Response']}")
-            return True
-        else:
-            self.logger.error(f"Failed to slew mount: {slew_response.get('Error')}")
+            if slew_response.get("Success"):
+                self.logger.info(f"Mount slew initiated: {slew_response['Response']}")
+                return True
+            else:
+                self.logger.error(f"Failed to slew mount: {slew_response.get('Error')}")
+                return False
+        except requests.Timeout:
+            self.logger.error("Mount slew request timed out")
+            return False
+        except requests.RequestException as e:
+            self.logger.error(f"Mount slew request failed: {e}")
             return False
 
     def connect(self) -> bool:
@@ -240,12 +231,8 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 return False
             self.logger.info(f"Mount Unparked!")
 
-            # make a map of available filters and their focus positions
+            # Discover available filters (focus positions loaded from saved settings)
             self.discover_filters()
-            if not self.bypass_autofocus:
-                self.do_autofocus()
-            else:
-                self.logger.info("Bypassing autofocus routine as requested")
 
             return True
         except Exception as e:
@@ -263,16 +250,58 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         for filter in filters:
             filter_id = filter["Id"]
             filter_name = filter["Name"]
-            # Try to load focus position from cache, fallback to default
-            focus_position = self._focus_positions_cache.get(str(filter_id), {}).get(
-                "focus_position", self.DEFAULT_FOCUS_POSITION
-            )
+            # Use existing focus position if filter already in map, otherwise use default
+            if filter_id in self.filter_map:
+                focus_position = self.filter_map[filter_id].get("focus_position", self.DEFAULT_FOCUS_POSITION)
+                self.logger.info(
+                    f"Discovered filter: {filter_name} with ID: {filter_id}, using saved focus position: {focus_position}"
+                )
+            else:
+                focus_position = self.DEFAULT_FOCUS_POSITION
+                self.logger.info(
+                    f"Discovered new filter: {filter_name} with ID: {filter_id}, using default focus position: {focus_position}"
+                )
+
             self.filter_map[filter_id] = {"name": filter_name, "focus_position": focus_position}
-            self.logger.info(f"Discovered filter: {filter_name} with ID: {filter_id}, focus position: {focus_position}")
 
     def disconnect(self):
         pass
 
+    def supports_filter_management(self) -> bool:
+        """Indicates that NINA adapter supports filter/focus management."""
+        return True
+
+    def get_filter_config(self) -> dict[str, FilterConfig]:
+        """Get current filter configuration with focus positions.
+
+        Returns:
+            dict: Filter configuration mapping filter ID strings to FilterConfig
+        """
+        return {
+            str(filter_id): {"name": filter_data["name"], "focus_position": filter_data["focus_position"]}
+            for filter_id, filter_data in self.filter_map.items()
+        }
+
+    def update_filter_focus(self, filter_id: str, focus_position: int) -> bool:
+        """Update the focus position for a specific filter.
+
+        Args:
+            filter_id: Filter ID as string
+            focus_position: New focus position in steps
+
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
+        try:
+            filter_id_int = int(filter_id)
+            if filter_id_int in self.filter_map:
+                self.filter_map[filter_id_int]["focus_position"] = focus_position
+                self.logger.info(f"Updated filter {filter_id} focus position to {focus_position}")
+                return True
+            return False
+        except (ValueError, KeyError):
+            return False
+
     def is_telescope_connected(self) -> bool:
         """Check if telescope is connected and responsive."""
         try:

{citrascope-0.4.0 → citrascope-0.5.0}/citrascope/settings/citrascope_settings.py

@@ -42,8 +42,12 @@ class CitraScopeSettings:
         # Hardware adapter selection
         self.hardware_adapter: str = config.get("hardware_adapter", "")
 
-        # Hardware adapter-specific settings stored as dict
-        self.adapter_settings: Dict[str, Any] = config.get("adapter_settings", {})
+        # Hardware adapter-specific settings stored as nested dict per adapter
+        # Format: {"adapter_name": {"setting_key": value, ...}, ...}
+        self._all_adapter_settings: Dict[str, Dict[str, Any]] = config.get("adapter_settings", {})
+
+        # Current adapter's settings slice
+        self.adapter_settings: Dict[str, Any] = self._all_adapter_settings.get(self.hardware_adapter, {})
 
         # Runtime settings (all loaded from config file, configurable via web UI)
         self.log_level: str = config.get("log_level", "INFO")
@@ -95,7 +99,7 @@ class CitraScopeSettings:
             "personal_access_token": self.personal_access_token,
             "telescope_id": self.telescope_id,
             "hardware_adapter": self.hardware_adapter,
-            "adapter_settings": self.adapter_settings,
+            "adapter_settings": self._all_adapter_settings,
             "log_level": self.log_level,
             "keep_images": self.keep_images,
             "web_port": self.web_port,
@@ -108,33 +112,23 @@ class CitraScopeSettings:
 
     def save(self) -> None:
         """Save current settings to JSON config file."""
+        # Update nested dict with current adapter's settings before saving
+        if self.hardware_adapter:
+            self._all_adapter_settings[self.hardware_adapter] = self.adapter_settings
+
         self.config_manager.save_config(self.to_dict())
         CITRASCOPE_LOGGER.info(f"Configuration saved to {self.config_manager.get_config_path()}")
 
-    @classmethod
-    def from_dict(cls, config: Dict[str, Any]) -> "CitraScopeSettings":
-        """Create settings instance from dictionary.
+    def update_and_save(self, config: Dict[str, Any]) -> None:
+        """Update settings from dict and save, preserving other adapters' settings.
 
         Args:
-            config: Dictionary of configuration values.
-
-        Returns:
-            New CitraScopeSettings instance.
+            config: Configuration dict with flat adapter_settings for current adapter.
         """
-        settings = cls()
-        settings.host = config.get("host", settings.host)
-        settings.port = config.get("port", settings.port)
-        settings.use_ssl = config.get("use_ssl", settings.use_ssl)
-        settings.personal_access_token = config.get("personal_access_token", "")
-        settings.telescope_id = config.get("telescope_id", "")
-        settings.hardware_adapter = config.get("hardware_adapter", "")
-        settings.adapter_settings = config.get("adapter_settings", {})
-        settings.log_level = config.get("log_level", "INFO")
-        settings.keep_images = config.get("keep_images", False)
-        settings.web_port = config.get("web_port", DEFAULT_WEB_PORT)
-        settings.max_task_retries = config.get("max_task_retries", 3)
-        settings.initial_retry_delay_seconds = config.get("initial_retry_delay_seconds", 30)
-        settings.max_retry_delay_seconds = config.get("max_retry_delay_seconds", 300)
-        settings.file_logging_enabled = config.get("file_logging_enabled", True)
-        settings.log_retention_days = config.get("log_retention_days", 30)
-        return settings
+        # Nest incoming adapter_settings under hardware_adapter key
+        adapter = config.get("hardware_adapter", self.hardware_adapter)
+        if adapter:
+            self._all_adapter_settings[adapter] = config.get("adapter_settings", {})
+        config["adapter_settings"] = self._all_adapter_settings
+
+        self.config_manager.save_config(config)

{citrascope-0.4.0 → citrascope-0.5.0}/citrascope/tasks/runner.py

@@ -40,6 +40,9 @@ class TaskManager:
         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
+        # Task processing control (always starts active)
+        self._processing_active = True
+        self._processing_lock = threading.Lock()
 
     def poll_tasks(self):
         while not self._stop_event.is_set():
@@ -130,6 +133,14 @@ class TaskManager:
 
     def task_runner(self):
         while not self._stop_event.is_set():
+            # Check if task processing is paused
+            with self._processing_lock:
+                is_paused = not self._processing_active
+
+            if is_paused:
+                self._stop_event.wait(1)
+                continue
+
             try:
                 now = int(time.time())
                 completed = 0
@@ -243,6 +254,25 @@ class TaskManager:
                 summary += "No tasks scheduled."
             return summary
 
+    def pause(self) -> bool:
+        """Pause task processing. Returns new state (False)."""
+        with self._processing_lock:
+            self._processing_active = False
+            self.logger.info("Task processing paused")
+            return self._processing_active
+
+    def resume(self) -> bool:
+        """Resume task processing. Returns new state (True)."""
+        with self._processing_lock:
+            self._processing_active = True
+            self.logger.info("Task processing resumed")
+            return self._processing_active
+
+    def is_processing_active(self) -> bool:
+        """Check if task processing is currently active."""
+        with self._processing_lock:
+            return self._processing_active
+
     def start(self):
         self._stop_event.clear()
         self.poll_thread = threading.Thread(target=self.poll_tasks, daemon=True)