citrascope 0.5.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

citrascope/hardware/kstars_scheduler_template.esl

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SchedulerList version="2.6">
+  <Job>
+    <Name>{{JOB_NAME}}</Name>
+    <Group></Group>
+    <Coordinates>
+      <J2000RA>{{TARGET_RA}}</J2000RA>
+      <J2000DE>{{TARGET_DEC}}</J2000DE>
+    </Coordinates>
+    <PositionAngle>-1</PositionAngle>
+    <Sequence>{{SEQUENCE_FILE}}</Sequence>
+    <FITSFILE></FITSFILE>
+    <StartupCondition>
+      <Condition>ASAP</Condition>
+      <CulminationOffset>0</CulminationOffset>
+    </StartupCondition>
+    <Constraints>
+      <Constraint value="{{MIN_ALTITUDE}}">MinimumAltitude</Constraint>
+    </Constraints>
+    <CompletionCondition>
+      <Condition>Repeat</Condition>
+      <Repeat>10</Repeat>
+    </CompletionCondition>
+    <Steps>
+      <Step>Track</Step>
+    </Steps>
+    <Priority>10</Priority>
+    <Enforced>true</Enforced>
+  </Job>
+</SchedulerList>

citrascope/hardware/kstars_sequence_template.esq

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SequenceQueue version='2.6'>
+  <Observer>CitraScope</Observer>
+  <GuideDeviation enabled='false'>2</GuideDeviation>
+  <GuideStartDeviation enabled='false'>2</GuideStartDeviation>
+  <HFRCheck enabled='false'>
+    <HFRDeviation>0.5</HFRDeviation>
+    <HFRCheckAlgorithm>0</HFRCheckAlgorithm>
+    <HFRCheckThreshold>10</HFRCheckThreshold>
+    <HFRCheckFrames>1</HFRCheckFrames>
+  </HFRCheck>
+  <RefocusOnTemperatureDelta enabled='false'>1</RefocusOnTemperatureDelta>
+  <RefocusEveryN enabled='false'>60</RefocusEveryN>
+  <RefocusOnMeridianFlip enabled='false' />
+{{JOBS}}
+</SequenceQueue>

citrascope/hardware/nina_adv_http_adapter.py

@@ -30,19 +30,13 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
     SEQUENCE_URL = "/sequence/"
 
     def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
-        super().__init__(images_dir=images_dir)
+        super().__init__(images_dir=images_dir, **kwargs)
         self.logger: logging.Logger = logger
         self.nina_api_path = kwargs.get("nina_api_path", "http://nina:1888/v2/api")
 
-        self.filter_map = {}
-        # 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}")
+        self.binning_x = kwargs.get("binning_x", 1)
+        self.binning_y = kwargs.get("binning_y", 1)
+        self.autofocus_binning = kwargs.get("autofocus_binning", 1)
 
     @classmethod
     def get_settings_schema(cls) -> list[SettingSchemaEntry]:
@@ -60,21 +54,59 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "http://localhost:1888/v2/api",
                 "pattern": r"^https?://.*",
             },
+            {
+                "name": "autofocus_binning",
+                "friendly_name": "Autofocus Binning",
+                "type": "int",
+                "default": 1,
+                "description": "Pixel binning for autofocus (1=no binning, 2=2x2, etc.)",
+                "required": False,
+                "placeholder": "1",
+                "min": 1,
+                "max": 4,
+            },
+            {
+                "name": "binning_x",
+                "friendly_name": "Binning X",
+                "type": "int",
+                "default": 1,
+                "description": "Horizontal pixel binning for observations (1=no binning, 2=2x2, etc.)",
+                "required": False,
+                "placeholder": "1",
+                "min": 1,
+                "max": 4,
+            },
+            {
+                "name": "binning_y",
+                "friendly_name": "Binning Y",
+                "type": "int",
+                "default": 1,
+                "description": "Vertical pixel binning for observations (1=no binning, 2=2x2, etc.)",
+                "required": False,
+                "placeholder": "1",
+                "min": 1,
+                "max": 4,
+            },
         ]
 
     def do_autofocus(self):
-        """Perform autofocus routine for all filters.
+        """Perform autofocus routine for all enabled filters.
 
         Slews telescope to Mirach (bright reference star) and runs autofocus
-        for each filter in the filter map, updating focus positions.
+        for each enabled filter in the filter map, updating focus positions.
 
         Raises:
-            RuntimeError: If no filters discovered or network requests fail
+            RuntimeError: If no filters discovered or no enabled filters
         """
         if not self.filter_map:
             raise RuntimeError("No filters discovered. Cannot perform autofocus.")
 
-        self.logger.info("Performing autofocus routine ...")
+        # Filter to only enabled filters
+        enabled_filters = {fid: fdata for fid, fdata in self.filter_map.items() if fdata.get("enabled", True)}
+        if not enabled_filters:
+            raise RuntimeError("No enabled filters. Cannot perform autofocus.")
+
+        self.logger.info(f"Performing autofocus routine on {len(enabled_filters)} enabled filter(s) ...")
         # move telescope to bright star and start autofocus
         # Mirach ra=(1+9/60.+47.45/3600.)*15 dec=(35+37/60.+11.1/3600.)
         ra = (1 + 9 / 60.0 + 47.45 / 3600.0) * 15
@@ -96,7 +128,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
             self.logger.info("Waiting for mount to finish slewing...")
             time.sleep(5)
 
-        for id, filter in self.filter_map.items():
+        for id, filter in enabled_filters.items():
             self.logger.info(f"Focusing Filter ID: {id}, Name: {filter['name']}")
             # Pass existing focus position to preserve it if autofocus fails
             existing_focus = filter.get("focus_position", self.DEFAULT_FOCUS_POSITION)
@@ -190,42 +222,42 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         try:
             # start connection to all equipments
             self.logger.info("Connecting camera ...")
-            cam_status = requests.get(self.nina_api_path + self.CAM_URL + "connect").json()
+            cam_status = requests.get(self.nina_api_path + self.CAM_URL + "connect", timeout=5).json()
             if not cam_status["Success"]:
                 self.logger.error(f"Failed to connect camera: {cam_status.get('Error')}")
                 return False
             self.logger.info(f"Camera Connected!")
 
             self.logger.info("Starting camera cooling ...")
-            cool_status = requests.get(self.nina_api_path + self.CAM_URL + "cool").json()
+            cool_status = requests.get(self.nina_api_path + self.CAM_URL + "cool", timeout=5).json()
             if not cool_status["Success"]:
                 self.logger.warning(f"Failed to start camera cooling: {cool_status.get('Error')}")
             else:
                 self.logger.info("Cooler started!")
 
             self.logger.info("Connecting filterwheel ...")
-            filterwheel_status = requests.get(self.nina_api_path + self.FILTERWHEEL_URL + "connect").json()
+            filterwheel_status = requests.get(self.nina_api_path + self.FILTERWHEEL_URL + "connect", timeout=5).json()
             if not filterwheel_status["Success"]:
                 self.logger.warning(f"Failed to connect filterwheel: {filterwheel_status.get('Error')}")
             else:
                 self.logger.info(f"Filterwheel Connected!")
 
             self.logger.info("Connecting focuser ...")
-            focuser_status = requests.get(self.nina_api_path + self.FOCUSER_URL + "connect").json()
+            focuser_status = requests.get(self.nina_api_path + self.FOCUSER_URL + "connect", timeout=5).json()
             if not focuser_status["Success"]:
                 self.logger.warning(f"Failed to connect focuser: {focuser_status.get('Error')}")
             else:
                 self.logger.info(f"Focuser Connected!")
 
             self.logger.info("Connecting mount ...")
-            mount_status = requests.get(self.nina_api_path + self.MOUNT_URL + "connect").json()
+            mount_status = requests.get(self.nina_api_path + self.MOUNT_URL + "connect", timeout=5).json()
             if not mount_status["Success"]:
                 self.logger.error(f"Failed to connect mount: {mount_status.get('Error')}")
                 return False
             self.logger.info(f"Mount Connected!")
 
             self.logger.info("Unparking mount ...")
-            mount_status = requests.get(self.nina_api_path + self.MOUNT_URL + "unpark").json()
+            mount_status = requests.get(self.nina_api_path + self.MOUNT_URL + "unpark", timeout=5).json()
             if not mount_status["Success"]:
                 self.logger.error(f"Failed to unpark mount: {mount_status.get('Error')}")
                 return False
@@ -241,7 +273,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
     def discover_filters(self):
         self.logger.info("Discovering filters ...")
-        filterwheel_info = requests.get(self.nina_api_path + self.FILTERWHEEL_URL + "info").json()
+        filterwheel_info = requests.get(self.nina_api_path + self.FILTERWHEEL_URL + "info", timeout=5).json()
         if not filterwheel_info.get("Success"):
             self.logger.error(f"Failed to get filterwheel info: {filterwheel_info.get('Error')}")
             raise RuntimeError("Failed to get filterwheel info")
@@ -250,58 +282,33 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         for filter in filters:
             filter_id = filter["Id"]
             filter_name = filter["Name"]
-            # Use existing focus position if filter already in map, otherwise use default
+            # Use existing focus position and enabled state if filter already in map
             if filter_id in self.filter_map:
                 focus_position = self.filter_map[filter_id].get("focus_position", self.DEFAULT_FOCUS_POSITION)
+                enabled = self.filter_map[filter_id].get("enabled", True)
                 self.logger.info(
-                    f"Discovered filter: {filter_name} with ID: {filter_id}, using saved focus position: {focus_position}"
+                    f"Discovered filter: {filter_name} with ID: {filter_id}, using saved focus position: {focus_position}, enabled: {enabled}"
                 )
             else:
                 focus_position = self.DEFAULT_FOCUS_POSITION
+                enabled = True  # Default new filters to enabled
                 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.filter_map[filter_id] = {"name": filter_name, "focus_position": focus_position, "enabled": enabled}
 
     def disconnect(self):
         pass
 
+    def supports_autofocus(self) -> bool:
+        """Indicates that NINA adapter supports autofocus."""
+        return True
+
     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:
@@ -445,8 +452,11 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         """
         elset = satellite_data["most_recent_elset"]
 
-        # Load template as JSON
+        # Load template as JSON and replace binning placeholders
         template_str = self._get_sequence_template()
+        template_str = template_str.replace("{binning_x}", str(self.binning_x))
+        template_str = template_str.replace("{binning_y}", str(self.binning_y))
+        template_str = template_str.replace("{autofocus_binning}", str(self.autofocus_binning))
         sequence_json = json.loads(template_str)
 
         nina_sequence_name = f"Citra Target: {satellite_data['name']}, Task: {task_id}"
@@ -486,7 +496,12 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         id_counter = [base_id]  # Use list so it can be modified in nested function
 
-        for filter_id, filter_info in self.filter_map.items():
+        # Filter to only enabled filters for observation
+        enabled_filters = {fid: fdata for fid, fdata in self.filter_map.items() if fdata.get("enabled", True)}
+        if not enabled_filters:
+            raise RuntimeError("No enabled filters available for observation sequence")
+
+        for filter_id, filter_info in enabled_filters.items():
             filter_name = filter_info["name"]
             focus_position = filter_info["focus_position"]
 
@@ -565,7 +580,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
             raise RuntimeError("Failed to get images list from NINA")
 
         images_to_download = []
-        expected_image_count = len(self.filter_map)  # One image per filter
+        expected_image_count = len(enabled_filters)  # One image per enabled filter
         images_found = len(images_response["Response"])
         self.logger.info(
             f"Found {images_found} images in NINA image history, considering the last {expected_image_count}"

citrascope/hardware/nina_adv_http_survey_template.json

@@ -174,8 +174,8 @@
                             "_autoFocusBinning": {
                               "$id": "31",
                               "$type": "NINA.Core.Model.Equipment.BinningMode, NINA.Core",
-                              "X": 1,
-                              "Y": 1
+                              "X": {autofocus_binning},
+                              "Y": {autofocus_binning}
                             },
                             "_autoFocusGain": -1,
                             "_autoFocusOffset": -1
@@ -205,8 +205,8 @@
                           "Binning": {
                             "$id": "34",
                             "$type": "NINA.Core.Model.Equipment.BinningMode, NINA.Core",
-                            "X": 4,
-                            "Y": 4
+                            "X": {binning_x},
+                            "Y": {binning_y}
                           },
                           "ImageType": "LIGHT",
                           "ExposureCount": 130,

citrascope/settings/citrascope_settings.py

@@ -53,8 +53,8 @@ class CitraScopeSettings:
         self.log_level: str = config.get("log_level", "INFO")
         self.keep_images: bool = config.get("keep_images", False)
 
-        # Web port: CLI override if non-default, otherwise use config file
-        self.web_port: int = web_port if web_port != DEFAULT_WEB_PORT else config.get("web_port", DEFAULT_WEB_PORT)
+        # Web port: CLI-only, never loaded from or saved to config file
+        self.web_port: int = web_port
 
         # Task retry configuration
         self.max_task_retries: int = config.get("max_task_retries", 3)
@@ -65,6 +65,22 @@ class CitraScopeSettings:
         self.file_logging_enabled: bool = config.get("file_logging_enabled", True)
         self.log_retention_days: int = config.get("log_retention_days", 30)
 
+        # Autofocus configuration (top-level/global settings)
+        self.scheduled_autofocus_enabled: bool = config.get("scheduled_autofocus_enabled", False)
+        self.autofocus_interval_minutes: int = config.get("autofocus_interval_minutes", 60)
+        self.last_autofocus_timestamp: Optional[int] = config.get("last_autofocus_timestamp")
+
+        # Validate autofocus interval
+        if (
+            not isinstance(self.autofocus_interval_minutes, int)
+            or self.autofocus_interval_minutes < 1
+            or self.autofocus_interval_minutes > 1439
+        ):
+            CITRASCOPE_LOGGER.warning(
+                f"Invalid autofocus_interval_minutes ({self.autofocus_interval_minutes}). Setting to default 60 minutes."
+            )
+            self.autofocus_interval_minutes = 60
+
     def get_images_dir(self) -> Path:
         """Get the path to the images directory.
 
@@ -90,7 +106,7 @@ class CitraScopeSettings:
         """Convert settings to dictionary for serialization.
 
         Returns:
-            Dictionary of all settings.
+            Dictionary of all settings (excluding runtime-only settings like web_port).
         """
         return {
             "host": self.host,
@@ -102,12 +118,14 @@ class CitraScopeSettings:
             "adapter_settings": self._all_adapter_settings,
             "log_level": self.log_level,
             "keep_images": self.keep_images,
-            "web_port": self.web_port,
             "max_task_retries": self.max_task_retries,
             "initial_retry_delay_seconds": self.initial_retry_delay_seconds,
             "max_retry_delay_seconds": self.max_retry_delay_seconds,
             "file_logging_enabled": self.file_logging_enabled,
             "log_retention_days": self.log_retention_days,
+            "scheduled_autofocus_enabled": self.scheduled_autofocus_enabled,
+            "autofocus_interval_minutes": self.autofocus_interval_minutes,
+            "last_autofocus_timestamp": self.last_autofocus_timestamp,
         }
 
     def save(self) -> None:
@@ -125,6 +143,9 @@ class CitraScopeSettings:
         Args:
             config: Configuration dict with flat adapter_settings for current adapter.
         """
+        # Remove runtime-only settings that should never be persisted
+        config.pop("web_port", None)
+
         # Nest incoming adapter_settings under hardware_adapter key
         adapter = config.get("hardware_adapter", self.hardware_adapter)
         if adapter:

citrascope/tasks/runner.py

@@ -43,6 +43,9 @@ class TaskManager:
         # Task processing control (always starts active)
         self._processing_active = True
         self._processing_lock = threading.Lock()
+        # Autofocus request flag (set by manual or scheduled triggers)
+        self._autofocus_requested = False
+        self._autofocus_lock = threading.Lock()
 
     def poll_tasks(self):
         while not self._stop_event.is_set():
@@ -219,6 +222,20 @@ class TaskManager:
             except Exception as e:
                 self.logger.error(f"Exception in task_runner loop: {e}", exc_info=True)
                 time.sleep(5)  # avoid tight error loop
+
+            # Check for autofocus requests between tasks
+            with self._autofocus_lock:
+                should_autofocus = self._autofocus_requested
+                if should_autofocus:
+                    self._autofocus_requested = False  # Clear flag before execution
+                # Also check if scheduled autofocus should run (inside lock to prevent race condition)
+                elif self._should_run_scheduled_autofocus():
+                    should_autofocus = True
+                    self._autofocus_requested = False  # Ensure flag is clear
+
+            if should_autofocus:
+                self._execute_autofocus()
+
             self._stop_event.wait(1)
 
     def _observe_satellite(self, task: Task):
@@ -278,6 +295,92 @@ class TaskManager:
         with self._processing_lock:
             return self._processing_active
 
+    def request_autofocus(self) -> bool:
+        """Request autofocus to run at next safe point between tasks.
+
+        Returns:
+            bool: True indicating request was queued.
+        """
+        with self._autofocus_lock:
+            self._autofocus_requested = True
+            self.logger.info("Autofocus requested - will run between tasks")
+            return True
+
+    def cancel_autofocus(self) -> bool:
+        """Cancel pending autofocus request if still queued.
+
+        Returns:
+            bool: True if autofocus was cancelled, False if nothing to cancel.
+        """
+        with self._autofocus_lock:
+            was_requested = self._autofocus_requested
+            self._autofocus_requested = False
+            if was_requested:
+                self.logger.info("Autofocus request cancelled")
+            return was_requested
+
+    def is_autofocus_requested(self) -> bool:
+        """Check if autofocus is currently requested/queued.
+
+        Returns:
+            bool: True if autofocus is queued, False otherwise.
+        """
+        with self._autofocus_lock:
+            return self._autofocus_requested
+
+    def _should_run_scheduled_autofocus(self) -> bool:
+        """Check if scheduled autofocus should run based on settings.
+
+        Returns:
+            bool: True if autofocus is enabled and interval has elapsed.
+        """
+        if not self.settings:
+            return False
+
+        # Check if scheduled autofocus is enabled (top-level setting)
+        if not self.settings.scheduled_autofocus_enabled:
+            return False
+
+        # Check if adapter supports autofocus
+        if not self.hardware_adapter.supports_autofocus():
+            return False
+
+        interval_minutes = self.settings.autofocus_interval_minutes
+        last_timestamp = self.settings.last_autofocus_timestamp
+
+        # If never run (None), treat as overdue and run immediately
+        if last_timestamp is None:
+            return True
+
+        # Check if interval has elapsed
+        elapsed_minutes = (int(time.time()) - last_timestamp) / 60
+        return elapsed_minutes >= interval_minutes
+
+    def _execute_autofocus(self) -> None:
+        """Execute autofocus routine and update timestamp on both success and failure."""
+        try:
+            self.logger.info("Starting autofocus routine...")
+            self.hardware_adapter.do_autofocus()
+
+            # Save updated filter configuration after autofocus
+            if self.hardware_adapter.supports_filter_management():
+                try:
+                    filter_config = self.hardware_adapter.get_filter_config()
+                    if filter_config and self.settings:
+                        self.settings.adapter_settings["filters"] = filter_config
+                        self.logger.info(f"Saved filter configuration with {len(filter_config)} filters")
+                except Exception as e:
+                    self.logger.warning(f"Failed to save filter configuration after autofocus: {e}")
+
+            self.logger.info("Autofocus routine completed successfully")
+        except Exception as e:
+            self.logger.error(f"Autofocus failed: {str(e)}", exc_info=True)
+        finally:
+            # Always update timestamp to prevent retry spam
+            if self.settings:
+                self.settings.last_autofocus_timestamp = int(time.time())
+                self.settings.save()
+
     def start(self):
         self._stop_event.clear()
         self.poll_thread = threading.Thread(target=self.poll_tasks, daemon=True)

citrascope/tasks/scope/static_telescope_task.py

@@ -17,7 +17,12 @@ class StaticTelescopeTask(AbstractBaseTelescopeTask):
             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
+            # Calculate current satellite position and add to satellite_data
+            target_ra, target_dec, _, _ = self.get_target_radec_and_rates(satellite_data)
+            satellite_data["ra"] = target_ra.degrees
+            satellite_data["dec"] = target_dec.degrees
+
+            # Sequence-based adapters handle pointing and tracking themselves
             filepaths = self.hardware_adapter.perform_observation_sequence(self.task.id, satellite_data)
 
         # Take the image