citrascope 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

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

@@ -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
@@ -97,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.
         """
@@ -110,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",
@@ -119,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",
@@ -128,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",
@@ -137,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",
@@ -148,6 +139,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1.0",
                 "min": 0.001,
                 "max": 300.0,
+                "group": "Imaging",
             },
             {
                 "name": "frame_count",
@@ -159,6 +151,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 100,
+                "group": "Imaging",
             },
             {
                 "name": "binning_x",
@@ -170,6 +163,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "binning_y",
@@ -181,6 +175,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "1",
                 "min": 1,
                 "max": 4,
+                "group": "Imaging",
             },
             {
                 "name": "image_format",
@@ -191,6 +186,7 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
                 "required": False,
                 "placeholder": "Mono",
                 "options": ["Mono", "RGGB", "RGB"],
+                "group": "Imaging",
             },
         ]
 
@@ -236,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.
 
@@ -244,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
@@ -254,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)
@@ -274,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
@@ -324,30 +322,31 @@ class KStarsDBusAdapter(AbstractAstroHardwareAdapter):
 
         jobs = []
 
-        if self.filter_map:
-            # Multi-filter mode: create one job per discovered filter
-            self.logger.info(
-                f"Generating {len(self.filter_map)} jobs for filters: "
-                f"{[f['name'] for f in self.filter_map.values()]}"
-            )
-            for filter_idx in sorted(self.filter_map.keys()):
-                filter_info = self.filter_map[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
+        # 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 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,
@@ -424,13 +423,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()
 
@@ -529,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:
@@ -558,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}")
@@ -568,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
@@ -858,14 +859,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 +876,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 +892,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