citrascope 0.6.1__tar.gz → 0.7.0__tar.gz

{citrascope-0.6.1 → citrascope-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: citrascope
-Version: 0.6.1
+Version: 0.7.0
 Summary: Remotely control a telescope while it polls for tasks, collects and edge processes data, and delivers results and data for further processing.
 Project-URL: Homepage, https://citra.space
 Project-URL: Documentation, https://docs.citra.space/citrascope/

{citrascope-0.6.1 → citrascope-0.7.0}/citrascope/citra_scope_daemon.py

@@ -35,7 +35,6 @@ 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)
@@ -200,14 +199,6 @@ 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.
 
@@ -232,12 +223,7 @@ class CitraScopeDaemon:
             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
+        """Request autofocus to run at next safe point between tasks.
 
         Returns:
             Tuple of (success, error_message)
@@ -248,34 +234,32 @@ class CitraScopeDaemon:
         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"
+        if not self.task_manager:
+            return False, "Task manager not initialized"
 
-        # 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"
+        # Request autofocus - will run between tasks
+        self.task_manager.request_autofocus()
+        return True, None
 
-            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"
+    def cancel_autofocus(self) -> bool:
+        """Cancel pending autofocus request if queued.
 
-        self._autofocus_in_progress = True
-        try:
-            CITRASCOPE_LOGGER.info("Starting autofocus routine...")
-            self.hardware_adapter.do_autofocus()
+        Returns:
+            bool: True if autofocus was cancelled, False if nothing to cancel.
+        """
+        if not self.task_manager:
+            return False
+        return self.task_manager.cancel_autofocus()
 
-            # Save updated filter configuration after autofocus
-            self._save_filter_config()
+    def is_autofocus_requested(self) -> bool:
+        """Check if autofocus is currently queued.
 
-            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
+        Returns:
+            bool: True if autofocus is queued, False otherwise.
+        """
+        if not self.task_manager:
+            return False
+        return self.task_manager.is_autofocus_requested()
 
     def run(self):
         # Start web server FIRST, so users can monitor/configure

{citrascope-0.6.1 → citrascope-0.7.0}/citrascope/hardware/abstract_astro_hardware_adapter.py

@@ -26,10 +26,12 @@ class FilterConfig(TypedDict):
     Attributes:
         name: Human-readable filter name (e.g., 'Luminance', 'Red', 'Ha')
         focus_position: Focuser position for this filter in steps
+        enabled: Whether this filter is enabled for observations (default: True)
     """
 
     name: str
     focus_position: int
+    enabled: bool
 
 
 class ObservationStrategy(Enum):
@@ -43,14 +45,28 @@ class AbstractAstroHardwareAdapter(ABC):
 
     _slew_min_distance_deg: float = 2.0
     scope_slew_rate_degrees_per_second: float = 0.0
+    DEFAULT_FOCUS_POSITION: int = 0  # Default focus position, can be overridden by subclasses
 
-    def __init__(self, images_dir: Path):
-        """Initialize the adapter with images directory.
+    def __init__(self, images_dir: Path, **kwargs):
+        """Initialize the adapter with images directory and optional filter configuration.
 
         Args:
             images_dir: Path to the images directory
+            **kwargs: Additional configuration including 'filters' dict
         """
         self.images_dir = images_dir
+        self.filter_map = {}
+
+        # Load filter configuration from settings if available
+        saved_filters = kwargs.get("filters", {})
+        for filter_id, filter_data in saved_filters.items():
+            try:
+                # Default enabled to True for backward compatibility
+                if "enabled" not in filter_data:
+                    filter_data["enabled"] = True
+                self.filter_map[int(filter_id)] = filter_data
+            except (ValueError, TypeError):
+                pass  # Skip invalid filter IDs
 
     @classmethod
     @abstractmethod
@@ -201,6 +217,14 @@ class AbstractAstroHardwareAdapter(ABC):
         """
         raise NotImplementedError(f"{self.__class__.__name__} does not support autofocus")
 
+    def supports_autofocus(self) -> bool:
+        """Indicates whether this adapter supports autofocus functionality.
+
+        Returns:
+            bool: True if the adapter can perform autofocus, False otherwise.
+        """
+        return False
+
     def supports_filter_management(self) -> bool:
         """Indicates whether this adapter supports filter/focus management.
 
@@ -217,14 +241,22 @@ class AbstractAstroHardwareAdapter(ABC):
                   Each FilterConfig contains:
                   - name (str): Filter name
                   - focus_position (int): Focuser position for this filter
+                  - enabled (bool): Whether filter is enabled for observations
 
         Example:
             {
-                "1": {"name": "Luminance", "focus_position": 9000},
-                "2": {"name": "Red", "focus_position": 9050}
+                "1": {"name": "Luminance", "focus_position": 9000, "enabled": True},
+                "2": {"name": "Red", "focus_position": 9050, "enabled": False}
             }
         """
-        return {}
+        return {
+            str(filter_id): {
+                "name": filter_data["name"],
+                "focus_position": filter_data["focus_position"],
+                "enabled": filter_data.get("enabled", True),
+            }
+            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.
@@ -236,4 +268,30 @@ class AbstractAstroHardwareAdapter(ABC):
         Returns:
             bool: True if update was successful, False otherwise
         """
-        return False
+        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
+                return True
+            return False
+        except (ValueError, KeyError):
+            return False
+
+    def update_filter_enabled(self, filter_id: str, enabled: bool) -> bool:
+        """Update the enabled state for a specific filter.
+
+        Args:
+            filter_id: Filter ID as string
+            enabled: New enabled state
+
+        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]["enabled"] = enabled
+                return True
+            return False
+        except (ValueError, KeyError):
+            return False

{citrascope-0.6.1 → citrascope-0.7.0}/citrascope/hardware/kstars_dbus_adapter.py

@@ -62,7 +62,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             images_dir: Path to the images directory
             **kwargs: Configuration including bus_name, ccd_name, filter_wheel_name
         """
-        super().__init__(images_dir=images_dir)
+        super().__init__(images_dir=images_dir, **kwargs)
         self.logger: logging.Logger = logger
         self.bus_name = kwargs.get("bus_name") or "org.kde.kstars"
         self.ccd_name = kwargs.get("ccd_name") or "CCD Simulator"
@@ -76,19 +76,6 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
         self.binning_y = kwargs.get("binning_y", 1)
         self.image_format = kwargs.get("image_format", "Mono")
 
-        # Filter management
-        self.filter_map: Dict[int, Dict[str, Any]] = {}
-
-        # Pre-populate filter_map from saved settings (if any)
-        # This will be merged with discovered filters in discover_filters()
-        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.bus: dbus.SessionBus | None = None
         self.kstars: dbus.Interface | None = None
         self.ekos: dbus.Interface | None = None
@@ -324,14 +311,17 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
 
         jobs = []
 
-        if self.filter_map:
-            # Multi-filter mode: create one job per discovered filter
+        # Filter to only enabled filters
+        enabled_filters = {fid: fdata for fid, fdata in self.filter_map.items() if fdata.get("enabled", True)}
+
+        if enabled_filters:
+            # Multi-filter mode: create one job per enabled filter
             self.logger.info(
-                f"Generating {len(self.filter_map)} jobs for filters: "
-                f"{[f['name'] for f in self.filter_map.values()]}"
+                f"Generating {len(enabled_filters)} jobs for enabled filters: "
+                f"{[f['name'] for f in enabled_filters.values()]}"
             )
-            for filter_idx in sorted(self.filter_map.keys()):
-                filter_info = self.filter_map[filter_idx]
+            for filter_idx in sorted(enabled_filters.keys()):
+                filter_info = enabled_filters[filter_idx]
                 filter_name = filter_info["name"]
 
                 job_xml = job_template.format(
@@ -424,13 +414,15 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
 
         assert self.bus is not None
 
-        # Calculate expected number of images based on filters
-        expected_filter_count = len(self.filter_map) if self.filter_map else 1
-        expected_total_images = expected_filter_count * self.frame_count
+        # Calculate expected number of images based on enabled filters
+        enabled_filter_count = (
+            sum(1 for f in self.filter_map.values() if f.get("enabled", True)) if self.filter_map else 1
+        )
+        expected_total_images = enabled_filter_count * self.frame_count
 
         self.logger.info(
             f"Waiting for scheduler job completion (timeout: {timeout}s, "
-            f"expecting {expected_total_images} images across {expected_filter_count} filters)..."
+            f"expecting {expected_total_images} images across {enabled_filter_count} filters)..."
         )
         start_time = time.time()
 
@@ -858,14 +850,16 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                     # Use 0-based indexing for filter_map (slot 1 -> index 0)
                     filter_idx = slot_num - 1
 
-                    # If filter already in map (from saved settings), preserve focus position
+                    # If filter already in map (from saved settings), preserve focus position and enabled state
                     if filter_idx in self.filter_map:
                         focus_position = self.filter_map[filter_idx].get("focus_position", 0)
+                        enabled = self.filter_map[filter_idx].get("enabled", True)
                         self.logger.debug(
-                            f"Filter slot {slot_num} ({filter_name}): using saved focus position {focus_position}"
+                            f"Filter slot {slot_num} ({filter_name}): using saved focus position {focus_position}, enabled: {enabled}"
                         )
                     else:
                         focus_position = 0
+                        enabled = True  # Default new filters to enabled
                         self.logger.debug(
                             f"Filter slot {slot_num} ({filter_name}): new filter, using default focus position"
                         )
@@ -873,6 +867,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                     self.filter_map[filter_idx] = {
                         "name": filter_name,
                         "focus_position": focus_position,
+                        "enabled": enabled,
                     }
                 except Exception as e:
                     self.logger.warning(f"Could not read filter slot {slot_num}: {e}")
@@ -888,54 +883,21 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             self.logger.info(f"Filter discovery failed (non-fatal): {e}")
             # Leave filter_map empty, use single-filter mode
 
-    def supports_filter_management(self) -> bool:
-        """Indicates whether this adapter supports filter/focus management.
-
-        Returns:
-            bool: True if filters were discovered, False otherwise.
-        """
-        return bool(self.filter_map)
-
-    def get_filter_config(self) -> Dict[str, Dict[str, Any]]:
-        """Get the current filter configuration including focus positions.
+    def supports_autofocus(self) -> bool:
+        """Indicates that KStars adapter does not support autofocus yet.
 
         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:
-            {
-                "0": {"name": "Red", "focus_position": 9000},
-                "1": {"name": "Green", "focus_position": 9050}
-            }
+            bool: False (autofocus not implemented).
         """
-        # Convert 0-based integer keys to strings for the web interface
-        return {str(k): v for k, v 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.
+        return False
 
-        Args:
-            filter_id: Filter ID as string (0-based index)
-            focus_position: New focus position in steps
+    def supports_filter_management(self) -> bool:
+        """Indicates whether this adapter supports filter/focus management.
 
         Returns:
-            bool: True if update was successful, False otherwise
+            bool: True if filters were discovered, False otherwise.
         """
-        try:
-            idx = int(filter_id)
-            if idx in self.filter_map:
-                self.filter_map[idx]["focus_position"] = focus_position
-                self.logger.info(f"Updated filter '{self.filter_map[idx]['name']}' focus position to {focus_position}")
-                return True
-            else:
-                self.logger.warning(f"Filter ID {filter_id} not found in filter_map")
-                return False
-        except (ValueError, KeyError) as e:
-            self.logger.error(f"Failed to update filter focus: {e}")
-            return False
+        return bool(self.filter_map)
 
     def disconnect(self):
         raise NotImplementedError

{citrascope-0.6.1 → citrascope-0.7.0}/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-0.6.1 → citrascope-0.7.0}/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,