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

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/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