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

citrascope/hardware/dummy_adapter.py

@@ -0,0 +1,202 @@
+"""Dummy hardware adapter for testing without real hardware."""
+
+import logging
+import time
+from pathlib import Path
+
+from citrascope.hardware.abstract_astro_hardware_adapter import (
+    AbstractAstroHardwareAdapter,
+    ObservationStrategy,
+    SettingSchemaEntry,
+)
+
+
+class DummyAdapter(AbstractAstroHardwareAdapter):
+    """
+    Dummy hardware adapter that simulates hardware without requiring real devices.
+
+    Perfect for testing, development, and demonstrations. All operations are logged
+    and return realistic fake data.
+    """
+
+    def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
+        """Initialize dummy adapter.
+
+        Args:
+            logger: Logger instance
+            images_dir: Path to images directory
+            **kwargs: Additional settings including 'simulate_slow_operations'
+        """
+        super().__init__(images_dir, **kwargs)
+        self.logger = logger
+        self.simulate_slow = kwargs.get("simulate_slow_operations", False)
+        self.slow_delay = kwargs.get("slow_delay_seconds", 2.0)
+
+        # Fake hardware state
+        self._connected = False
+        self._telescope_connected = False
+        self._camera_connected = False
+        self._current_ra = 0.0  # degrees
+        self._current_dec = 0.0  # degrees
+        self._is_moving = False
+        self._tracking_rate = (15.041, 0.0)  # arcsec/sec (sidereal rate)
+
+        self.logger.info("DummyAdapter initialized")
+
+    @classmethod
+    def get_settings_schema(cls, **kwargs) -> list[SettingSchemaEntry]:
+        """Return configuration schema for dummy adapter."""
+        return [
+            {
+                "name": "simulate_slow_operations",
+                "friendly_name": "Simulate Slow Operations",
+                "type": "bool",
+                "default": False,
+                "description": "Add artificial delays to simulate slow hardware responses",
+                "required": False,
+                "group": "Testing",
+            },
+            {
+                "name": "slow_delay_seconds",
+                "friendly_name": "Delay Duration (seconds)",
+                "type": "float",
+                "default": 2.0,
+                "min": 0.1,
+                "max": 10.0,
+                "description": "Duration of artificial delays when slow simulation is enabled",
+                "required": False,
+                "group": "Testing",
+            },
+        ]
+
+    def get_observation_strategy(self) -> ObservationStrategy:
+        """Dummy adapter uses manual strategy."""
+        return ObservationStrategy.MANUAL
+
+    def perform_observation_sequence(self, task, satellite_data) -> str:
+        """Not used for manual strategy."""
+        raise NotImplementedError("DummyAdapter uses MANUAL strategy")
+
+    def connect(self) -> bool:
+        """Simulate connection."""
+        self.logger.info("DummyAdapter: Connecting...")
+        self._simulate_delay()
+        self._connected = True
+        self._telescope_connected = True
+        self._camera_connected = True
+        self.logger.info("DummyAdapter: Connected successfully")
+        return True
+
+    def disconnect(self):
+        """Simulate disconnection."""
+        self.logger.info("DummyAdapter: Disconnecting...")
+        self._connected = False
+        self._telescope_connected = False
+        self._camera_connected = False
+        self.logger.info("DummyAdapter: Disconnected")
+
+    def is_telescope_connected(self) -> bool:
+        """Check fake telescope connection."""
+        return self._telescope_connected
+
+    def is_camera_connected(self) -> bool:
+        """Check fake camera connection."""
+        return self._camera_connected
+
+    def list_devices(self) -> list[str]:
+        """Return list of fake devices."""
+        return ["Dummy Telescope", "Dummy Camera", "Dummy Filter Wheel", "Dummy Focuser"]
+
+    def select_telescope(self, device_name: str) -> bool:
+        """Simulate telescope selection."""
+        self.logger.info(f"DummyAdapter: Selected telescope '{device_name}'")
+        self._telescope_connected = True
+        return True
+
+    def _do_point_telescope(self, ra: float, dec: float):
+        """Simulate telescope slew."""
+        self.logger.info(f"DummyAdapter: Slewing to RA={ra:.4f}°, Dec={dec:.4f}°")
+        self._is_moving = True
+        self._simulate_delay()
+        self._current_ra = ra
+        self._current_dec = dec
+        self._is_moving = False
+        self.logger.info("DummyAdapter: Slew complete")
+
+    def get_telescope_direction(self) -> tuple[float, float]:
+        """Return current fake telescope position."""
+        return (self._current_ra, self._current_dec)
+
+    def telescope_is_moving(self) -> bool:
+        """Check if fake telescope is moving."""
+        return self._is_moving
+
+    def select_camera(self, device_name: str) -> bool:
+        """Simulate camera selection."""
+        self.logger.info(f"DummyAdapter: Selected camera '{device_name}'")
+        self._camera_connected = True
+        return True
+
+    def take_image(self, task_id: str, exposure_duration_seconds=1.0) -> str:
+        """Simulate image capture."""
+        self.logger.info(f"DummyAdapter: Starting {exposure_duration_seconds}s exposure for task {task_id}")
+        self._simulate_delay(exposure_duration_seconds)
+
+        # Create dummy image file
+        timestamp = int(time.time())
+        filename = f"dummy_{task_id}_{timestamp}.fits"
+        filepath = self.images_dir / filename
+
+        # Create empty file to simulate image
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        filepath.write_text(f"DUMMY FITS IMAGE\nTask: {task_id}\nExposure: {exposure_duration_seconds}s\n")
+
+        self.logger.info(f"DummyAdapter: Image saved to {filepath}")
+        return str(filepath)
+
+    def set_custom_tracking_rate(self, ra_rate: float, dec_rate: float):
+        """Simulate setting tracking rate."""
+        self.logger.info(f"DummyAdapter: Setting tracking rate RA={ra_rate} arcsec/s, Dec={dec_rate} arcsec/s")
+        self._tracking_rate = (ra_rate, dec_rate)
+
+    def get_tracking_rate(self) -> tuple[float, float]:
+        """Return current fake tracking rate."""
+        return self._tracking_rate
+
+    def perform_alignment(self, target_ra: float, target_dec: float) -> bool:
+        """Simulate plate solving alignment."""
+        self.logger.info(f"DummyAdapter: Performing alignment to RA={target_ra}°, Dec={target_dec}°")
+        self._simulate_delay()
+        # Simulate small correction
+        self._current_ra = target_ra + 0.001
+        self._current_dec = target_dec + 0.001
+        self.logger.info("DummyAdapter: Alignment successful")
+        return True
+
+    def supports_autofocus(self) -> bool:
+        """Dummy adapter supports autofocus."""
+        return True
+
+    def do_autofocus(self) -> None:
+        """Simulate autofocus routine."""
+        self.logger.info("DummyAdapter: Starting autofocus...")
+        self._simulate_delay(3.0)
+        self.logger.info("DummyAdapter: Autofocus complete")
+
+    def supports_filter_management(self) -> bool:
+        """Dummy adapter supports filter management."""
+        return True
+
+    def supports_direct_camera_control(self) -> bool:
+        """Dummy adapter supports direct camera control."""
+        return True
+
+    def expose_camera(self, exposure_seconds: float = 1.0) -> str:
+        """Simulate manual camera exposure."""
+        return self.take_image("manual_test", exposure_seconds)
+
+    def _simulate_delay(self, override_delay: float = None):
+        """Add artificial delay if slow simulation is enabled."""
+        if self.simulate_slow:
+            delay = override_delay if override_delay is not None else self.slow_delay
+            time.sleep(delay)

citrascope/hardware/filter_sync.py

@@ -0,0 +1,94 @@
+"""Filter synchronization utilities for syncing hardware filters to backend API."""
+
+
+def extract_enabled_filter_names(filter_config: dict) -> list[str]:
+    """Extract names of enabled filters from hardware configuration.
+
+    Args:
+        filter_config: Dict mapping filter IDs to config dicts with 'name' and 'enabled' keys
+
+    Returns:
+        List of filter names where enabled=True
+    """
+    enabled_names = []
+    for filter_id, config in filter_config.items():
+        if config.get("enabled", False):
+            enabled_names.append(config["name"])
+    return enabled_names
+
+
+def build_spectral_config_from_expanded(expanded_filters: list[dict]) -> tuple[dict, list[str]]:
+    """Build discrete spectral_config from API expanded filter response.
+
+    Args:
+        expanded_filters: List of filter dicts from /filters/expand API response,
+                         each with 'name', 'central_wavelength_nm', 'bandwidth_nm', 'is_known'
+
+    Returns:
+        Tuple of (spectral_config dict, list of unknown filter names)
+    """
+    filter_specs = []
+    unknown_filters = []
+
+    for f in expanded_filters:
+        filter_specs.append(
+            {"name": f["name"], "central_wavelength_nm": f["central_wavelength_nm"], "bandwidth_nm": f["bandwidth_nm"]}
+        )
+        if not f.get("is_known", True):
+            unknown_filters.append(f["name"])
+
+    spectral_config = {"type": "discrete", "filters": filter_specs}
+
+    return spectral_config, unknown_filters
+
+
+def sync_filters_to_backend(api_client, telescope_id: str, filter_config: dict, logger) -> bool:
+    """Sync enabled filters from hardware to backend API.
+
+    Extracts enabled filter names, expands them via filter library API,
+    builds spectral_config, and updates telescope record.
+
+    Args:
+        api_client: CitraApiClient instance
+        telescope_id: UUID string of telescope to update
+        filter_config: Hardware filter configuration dict
+        logger: Logger instance for output
+
+    Returns:
+        True if sync succeeded, False otherwise
+    """
+    if not filter_config:
+        logger.debug("No filter configuration to sync")
+        return False
+
+    # Extract enabled filter names
+    enabled_filter_names = extract_enabled_filter_names(filter_config)
+
+    if not enabled_filter_names:
+        logger.debug("No enabled filters to sync")
+        return False
+
+    logger.info(f"Syncing {len(enabled_filter_names)} enabled filters to backend: {enabled_filter_names}")
+
+    # Expand filter names to full spectral specs via API
+    expand_response = api_client.expand_filters(enabled_filter_names)
+    if not expand_response or "filters" not in expand_response:
+        logger.warning("Failed to expand filter names - API returned no data")
+        return False
+
+    # Build spectral_config from expanded filters
+    expanded_filters = expand_response["filters"]
+    spectral_config, unknown_filters = build_spectral_config_from_expanded(expanded_filters)
+
+    if unknown_filters:
+        logger.warning(f"Unknown filters (using defaults): {unknown_filters}")
+
+    # Update telescope spectral_config via PATCH
+    update_response = api_client.update_telescope_spectral_config(telescope_id, spectral_config)
+
+    if update_response:
+        logger.info(f"Successfully synced {len(spectral_config['filters'])} filters to backend")
+        return True
+    else:
+        logger.warning("Failed to update telescope spectral_config on backend")
+        return False

citrascope/hardware/indi_adapter.py

@@ -47,7 +47,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
         # TetraSolver.high_memory()
 
     @classmethod
-    def get_settings_schema(cls) -> list[SettingSchemaEntry]:
+    def get_settings_schema(cls, **kwargs) -> list[SettingSchemaEntry]:
         """
         Return a schema describing configurable settings for the INDI adapter.
         """
@@ -60,6 +60,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
                 "description": "INDI server hostname or IP address",
                 "required": True,
                 "placeholder": "localhost or 192.168.1.100",
+                "group": "Connection",
             },
             {
                 "name": "port",
@@ -71,6 +72,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
                 "placeholder": "7624",
                 "min": 1,
                 "max": 65535,
+                "group": "Connection",
             },
             {
                 "name": "telescope_name",
@@ -80,6 +82,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
                 "description": "Name of the telescope device (leave empty to auto-detect)",
                 "required": False,
                 "placeholder": "Telescope Simulator",
+                "group": "Devices",
             },
             {
                 "name": "camera_name",
@@ -89,6 +92,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
                 "description": "Name of the camera device (leave empty to auto-detect)",
                 "required": False,
                 "placeholder": "CCD Simulator",
+                "group": "Devices",
             },
         ]
 
@@ -726,5 +730,5 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
     def get_observation_strategy(self) -> ObservationStrategy:
         return ObservationStrategy.MANUAL
 
-    def perform_observation_sequence(self, task_id, satellite_data) -> str:
+    def perform_observation_sequence(self, task, satellite_data) -> str:
         raise NotImplementedError

citrascope/hardware/kstars_dbus_adapter.py

@@ -84,7 +84,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
         self.scheduler: dbus.Interface | None = None
 
     @classmethod
-    def get_settings_schema(cls) -> list[SettingSchemaEntry]:
+    def get_settings_schema(cls, **kwargs) -> list[SettingSchemaEntry]:
         """
         Return a schema describing configurable settings for the KStars DBus adapter.
         """
@@ -97,6 +97,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "description": "D-Bus service name for KStars (default: org.kde.kstars)",
                 "required": False,
                 "placeholder": "org.kde.kstars",
+                "group": "Connection",
             },
             {
                 "name": "ccd_name",
@@ -106,6 +107,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "description": "Name of the camera device in your Ekos profile (check Ekos logs on connect for available devices)",
                 "required": False,
                 "placeholder": "CCD Simulator",
+                "group": "Devices",
             },
             {
                 "name": "filter_wheel_name",
@@ -115,6 +117,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "description": "Name of the filter wheel device (leave empty if no filter wheel)",
                 "required": False,
                 "placeholder": "Filter Simulator",
+                "group": "Devices",
             },
             {
                 "name": "optical_train_name",
@@ -124,6 +127,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "description": "Name of the optical train in your Ekos profile (check Ekos logs on connect for available trains)",
                 "required": False,
                 "placeholder": "Primary",
+                "group": "Devices",
             },
             {
                 "name": "exposure_time",
@@ -135,6 +139,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1.0",
                 "min": 0.001,
                 "max": 300.0,
+                "group": "Imaging",
             },
             {
                 "name": "frame_count",
@@ -146,6 +151,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 100,
+                "group": "Imaging",
             },
             {
                 "name": "binning_x",
@@ -157,6 +163,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "binning_y",
@@ -168,6 +175,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "image_format",
@@ -178,6 +186,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "required": False,
                 "placeholder": "Mono",
                 "options": ["Mono", "RGGB", "RGB"],
+                "group": "Imaging",
             },
         ]
 
@@ -223,7 +232,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             raise FileNotFoundError(f"Template not found: {template_path}")
         return template_path.read_text()
 
-    def _create_sequence_file(self, task_id: str, satellite_data: dict, output_dir: Path) -> Path:
+    def _create_sequence_file(self, task_id: str, satellite_data: dict, output_dir: Path, task=None) -> Path:
         """
         Create an ESQ sequence file from template.
 
@@ -231,6 +240,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             task_id: Unique task identifier
             satellite_data: Dictionary containing target information
             output_dir: Base output directory for captures
+            task: Optional task object containing filter assignment
 
         Returns:
             Path to the created sequence file
@@ -241,7 +251,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
         target_name = satellite_data.get("name", "Unknown").replace(" ", "_")
 
         # Generate job blocks based on filter configuration
-        jobs_xml = self._generate_job_blocks(output_dir)
+        jobs_xml = self._generate_job_blocks(output_dir, task)
 
         # Replace placeholders
         sequence_content = template.replace("{{JOBS}}", jobs_xml)
@@ -261,13 +271,14 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
         self.logger.info(f"Created sequence file: {sequence_file}")
         return sequence_file
 
-    def _generate_job_blocks(self, output_dir: Path) -> str:
+    def _generate_job_blocks(self, output_dir: Path, task=None) -> str:
         """
         Generate XML job blocks for each filter in filter_map.
         If no filters discovered, generates single job with no filter.
 
         Args:
             output_dir: Base output directory for captures
+            task: Optional task object containing filter assignment
 
         Returns:
             XML string containing one or more <Job> blocks
@@ -311,33 +322,31 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
 
         jobs = []
 
-        # Filter to only enabled filters
-        enabled_filters = {fid: fdata for fid, fdata in self.filter_map.items() if fdata.get("enabled", True)}
+        # Select filters to use for this task (allow_no_filter for KStars '--' fallback)
+        filters_to_use = self.select_filters_for_task(task, allow_no_filter=True)
 
-        if enabled_filters:
-            # Multi-filter mode: create one job per enabled filter
-            self.logger.info(
-                f"Generating {len(enabled_filters)} jobs for enabled filters: "
-                f"{[f['name'] for f in enabled_filters.values()]}"
-            )
-            for filter_idx in sorted(enabled_filters.keys()):
-                filter_info = enabled_filters[filter_idx]
-                filter_name = filter_info["name"]
-
-                job_xml = job_template.format(
-                    exposure=self.exposure_time,
-                    format=self.image_format,
-                    binning_x=self.binning_x,
-                    binning_y=self.binning_y,
-                    filter_name=filter_name,
-                    count=self.frame_count,
-                    output_dir=str(output_dir),
-                )
-                jobs.append(job_xml)
-        else:
-            # Single-filter mode: use '--' for no filter
+        if filters_to_use is None:
+            # No filters available - use '--' for no filter wheel
             filter_name = "--" if not self.filter_wheel_name else "Luminance"
-            self.logger.info(f"Generating single job with filter: {filter_name}")
+            task_id_str = task.id if task else "unknown"
+            self.logger.info(f"Using fallback filter '{filter_name}' for task {task_id_str}")
+
+            job_xml = job_template.format(
+                exposure=self.exposure_time,
+                format=self.image_format,
+                binning_x=self.binning_x,
+                binning_y=self.binning_y,
+                filter_name=filter_name,
+                count=self.frame_count,
+                output_dir=str(output_dir),
+            )
+            jobs.append(job_xml)
+            return "\n".join(jobs)
+
+        # Generate jobs for selected filters
+        for filter_idx in sorted(filters_to_use.keys()):
+            filter_info = filters_to_use[filter_idx]
+            filter_name = filter_info["name"]
 
             job_xml = job_template.format(
                 exposure=self.exposure_time,
@@ -521,12 +530,12 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
 
         return matching_files
 
-    def perform_observation_sequence(self, task_id: str, satellite_data: dict) -> list[str]:
+    def perform_observation_sequence(self, task, satellite_data: dict) -> list[str]:
         """
         Execute a complete observation sequence using Ekos Scheduler.
 
         Args:
-            task_id: Unique task identifier
+            task: Task object containing id and filter assignment
             satellite_data: Dictionary with keys: 'name', and either 'ra'/'dec' or TLE data
 
         Returns:
@@ -550,7 +559,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             output_dir.mkdir(exist_ok=True, parents=True)
 
             # Clear task-specific directory to prevent Ekos from thinking job is already done
-            task_output_dir = output_dir / task_id
+            task_output_dir = output_dir / task.id
             if task_output_dir.exists():
                 shutil.rmtree(task_output_dir)
                 self.logger.info(f"Cleared existing output directory: {task_output_dir}")
@@ -560,20 +569,20 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
             self.logger.info(f"Output directory: {task_output_dir}")
 
             # Create sequence and scheduler job files (use task-specific directory)
-            sequence_file = self._create_sequence_file(task_id, satellite_data, task_output_dir)
-            job_file = self._create_scheduler_job(task_id, satellite_data, sequence_file)
+            sequence_file = self._create_sequence_file(task.id, satellite_data, task_output_dir, task)
+            job_file = self._create_scheduler_job(task.id, satellite_data, sequence_file)
 
             # Ensure temp files are cleaned up even on failure
             try:
-                self._execute_observation(task_id, output_dir, sequence_file, job_file)
+                self._execute_observation(task.id, output_dir, sequence_file, job_file)
             finally:
                 # Cleanup temp files
                 self._cleanup_temp_files(sequence_file, job_file)
 
             # Retrieve and return captured images
-            image_paths = self._retrieve_captured_images(task_id, output_dir)
+            image_paths = self._retrieve_captured_images(task.id, output_dir)
             if not image_paths:
-                raise RuntimeError(f"No images captured for task {task_id}")
+                raise RuntimeError(f"No images captured for task {task.id}")
 
             self.logger.info(f"Observation sequence complete: {len(image_paths)} images captured")
             return image_paths

citrascope/hardware/nina_adv_http_adapter.py

@@ -39,7 +39,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         self.autofocus_binning = kwargs.get("autofocus_binning", 1)
 
     @classmethod
-    def get_settings_schema(cls) -> list[SettingSchemaEntry]:
+    def get_settings_schema(cls, **kwargs) -> list[SettingSchemaEntry]:
         """
         Return a schema describing configurable settings for the NINA Advanced HTTP adapter.
         """
@@ -53,6 +53,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "required": True,
                 "placeholder": "http://localhost:1888/v2/api",
                 "pattern": r"^https?://.*",
+                "group": "Connection",
             },
             {
                 "name": "autofocus_binning",
@@ -64,6 +65,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "binning_x",
@@ -75,6 +77,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "binning_y",
@@ -86,6 +89,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
         ]
 
@@ -440,11 +444,11 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
             for item in data:
                 self._update_all_ids(item, id_counter)
 
-    def perform_observation_sequence(self, task_id, satellite_data) -> str | list[str]:
+    def perform_observation_sequence(self, task, satellite_data) -> str | list[str]:
         """Create and execute a NINA sequence for the given satellite.
 
         Args:
-            task_id: Unique identifier for this observation task
+            task: Task object containing id and filter assignment
             satellite_data: Satellite data including TLE information
 
         Returns:
@@ -459,7 +463,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         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}"
+        nina_sequence_name = f"Citra Target: {satellite_data['name']}, Task: {task.id}"
 
         # Replace basic placeholders (use \r\n for Windows NINA compatibility)
         tle_data = f"{elset['tle'][0]}\r\n{elset['tle'][1]}"
@@ -496,12 +500,10 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         id_counter = [base_id]  # Use list so it can be modified in nested function
 
-        # 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")
+        # Select filters to use for this task
+        filters_to_use = self.select_filters_for_task(task, allow_no_filter=False)
 
-        for filter_id, filter_info in enabled_filters.items():
+        for filter_id, filter_info in filters_to_use.items():
             filter_name = filter_info["name"]
             focus_position = filter_info["focus_position"]
 
@@ -521,7 +523,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
             # Add this triplet to the sequence
             new_items.extend(filter_triplet)
 
-            self.logger.info(f"Added filter {filter_name} (ID: {filter_id}) with focus position {focus_position}")
+            self.logger.debug(f"Added filter {filter_name} (ID: {filter_id}) with focus position {focus_position}")
 
         # Update the items list
         tle_items.clear()
@@ -580,7 +582,7 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
             raise RuntimeError("Failed to get images list from NINA")
 
         images_to_download = []
-        expected_image_count = len(enabled_filters)  # One image per enabled filter
+        expected_image_count = len(filters_to_use)  # One image per filter in sequence
         images_found = len(images_response["Response"])
         self.logger.info(
             f"Found {images_found} images in NINA image history, considering the last {expected_image_count}"