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

citrascope/settings/citrascope_settings.py

@@ -65,6 +65,22 @@ class CitraScopeSettings:
         self.file_logging_enabled: bool = config.get("file_logging_enabled", True)
         self.log_retention_days: int = config.get("log_retention_days", 30)
 
+        # Autofocus configuration (top-level/global settings)
+        self.scheduled_autofocus_enabled: bool = config.get("scheduled_autofocus_enabled", False)
+        self.autofocus_interval_minutes: int = config.get("autofocus_interval_minutes", 60)
+        self.last_autofocus_timestamp: Optional[int] = config.get("last_autofocus_timestamp")
+
+        # Validate autofocus interval
+        if (
+            not isinstance(self.autofocus_interval_minutes, int)
+            or self.autofocus_interval_minutes < 1
+            or self.autofocus_interval_minutes > 1439
+        ):
+            CITRASCOPE_LOGGER.warning(
+                f"Invalid autofocus_interval_minutes ({self.autofocus_interval_minutes}). Setting to default 60 minutes."
+            )
+            self.autofocus_interval_minutes = 60
+
     def get_images_dir(self) -> Path:
         """Get the path to the images directory.
 
@@ -107,6 +123,9 @@ class CitraScopeSettings:
             "max_retry_delay_seconds": self.max_retry_delay_seconds,
             "file_logging_enabled": self.file_logging_enabled,
             "log_retention_days": self.log_retention_days,
+            "scheduled_autofocus_enabled": self.scheduled_autofocus_enabled,
+            "autofocus_interval_minutes": self.autofocus_interval_minutes,
+            "last_autofocus_timestamp": self.last_autofocus_timestamp,
         }
 
     def save(self) -> None:

citrascope/tasks/runner.py

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

citrascope/web/app.py

@@ -37,6 +37,9 @@ class SystemStatus(BaseModel):
     ground_station_id: Optional[str] = None
     ground_station_name: Optional[str] = None
     ground_station_url: Optional[str] = None
+    autofocus_requested: bool = False
+    last_autofocus_timestamp: Optional[int] = None
+    next_autofocus_minutes: Optional[int] = None
     last_update: str = ""
 
 
@@ -182,6 +185,9 @@ class CitraScopeWebApp:
                 "max_task_retries": settings.max_task_retries,
                 "initial_retry_delay_seconds": settings.initial_retry_delay_seconds,
                 "max_retry_delay_seconds": settings.max_retry_delay_seconds,
+                "scheduled_autofocus_enabled": settings.scheduled_autofocus_enabled,
+                "autofocus_interval_minutes": settings.autofocus_interval_minutes,
+                "last_autofocus_timestamp": settings.last_autofocus_timestamp,
                 "app_url": app_url,
                 "config_file_path": config_path,
                 "log_file_path": log_file_path,
@@ -241,13 +247,6 @@ class CitraScopeWebApp:
                 if not self.daemon:
                     return JSONResponse({"error": "Daemon not available"}, status_code=503)
 
-                # Block config changes during autofocus
-                if self.daemon.is_autofocus_in_progress():
-                    return JSONResponse(
-                        {"error": "Cannot save configuration while autofocus is running. Check logs for progress."},
-                        status_code=409,
-                    )
-
                 # Validate required fields
                 required_fields = ["personal_access_token", "telescope_id", "hardware_adapter"]
                 for field in required_fields:
@@ -392,13 +391,6 @@ class CitraScopeWebApp:
             if not self.daemon or not self.daemon.task_manager:
                 return JSONResponse({"error": "Task manager not available"}, status_code=503)
 
-            # Block resume during autofocus
-            if self.daemon.is_autofocus_in_progress():
-                return JSONResponse(
-                    {"error": "Cannot resume task processing during autofocus. Check logs for progress."},
-                    status_code=409,
-                )
-
             self.daemon.task_manager.resume()
             await self.broadcast_status()
 
@@ -422,7 +414,8 @@ class CitraScopeWebApp:
 
         @self.app.patch("/api/adapter/filters/{filter_id}")
         async def update_filter(filter_id: str, update: dict):
-            """Update focus position for a specific filter."""
+            """Update focus position and/or enabled state for a specific filter."""
+
             if not self.daemon or not self.daemon.hardware_adapter:
                 return JSONResponse({"error": "Hardware adapter not available"}, status_code=503)
 
@@ -430,31 +423,50 @@ class CitraScopeWebApp:
                 return JSONResponse({"error": "Adapter does not support filter management"}, status_code=404)
 
             try:
-                # Validate focus_position is provided and is a valid integer within hardware limits
-                if "focus_position" not in update:
-                    return JSONResponse({"error": "focus_position is required"}, status_code=400)
-
-                focus_position = update["focus_position"]
-                if not isinstance(focus_position, int):
-                    return JSONResponse({"error": "focus_position must be an integer"}, status_code=400)
-
-                # Typical focuser range is 0-65535 (16-bit unsigned)
-                if focus_position < 0 or focus_position > 65535:
-                    return JSONResponse({"error": "focus_position must be between 0 and 65535"}, status_code=400)
-
                 # Get current filter config
                 filter_config = self.daemon.hardware_adapter.get_filter_config()
                 if filter_id not in filter_config:
                     return JSONResponse({"error": f"Filter {filter_id} not found"}, status_code=404)
 
-                # Update via adapter interface
-                if not self.daemon.hardware_adapter.update_filter_focus(filter_id, focus_position):
-                    return JSONResponse({"error": "Failed to update filter in adapter"}, status_code=500)
+                # Validate focus_position if provided
+                if "focus_position" in update:
+                    focus_position = update["focus_position"]
+                    if not isinstance(focus_position, int):
+                        return JSONResponse({"error": "focus_position must be an integer"}, status_code=400)
+
+                    # Typical focuser range is 0-65535 (16-bit unsigned)
+                    if focus_position < 0 or focus_position > 65535:
+                        return JSONResponse({"error": "focus_position must be between 0 and 65535"}, status_code=400)
+
+                    # Update focus position via adapter interface
+                    if not self.daemon.hardware_adapter.update_filter_focus(filter_id, focus_position):
+                        return JSONResponse({"error": "Failed to update filter focus in adapter"}, status_code=500)
+
+                # Validate and update enabled state if provided
+                if "enabled" in update:
+                    enabled = update["enabled"]
+                    if not isinstance(enabled, bool):
+                        return JSONResponse({"error": "enabled must be a boolean"}, status_code=400)
+
+                    # Belt and suspenders: Ensure at least one filter remains enabled
+                    if not enabled:
+                        enabled_count = sum(1 for f in filter_config.values() if f.get("enabled", True))
+                        if enabled_count <= 1:
+                            return JSONResponse(
+                                {
+                                    "error": "Cannot disable last enabled filter. At least one filter must remain enabled."
+                                },
+                                status_code=400,
+                            )
+
+                    # Update enabled state via adapter interface
+                    if not self.daemon.hardware_adapter.update_filter_enabled(filter_id, enabled):
+                        return JSONResponse({"error": "Failed to update filter enabled state"}, status_code=500)
 
                 # Save to settings
                 self.daemon._save_filter_config()
 
-                return {"success": True, "filter_id": filter_id, "focus_position": focus_position}
+                return {"success": True, "filter_id": filter_id, "updated": update}
             except ValueError:
                 return JSONResponse({"error": "Invalid filter_id format"}, status_code=400)
             except Exception as e:
@@ -463,7 +475,7 @@ class CitraScopeWebApp:
 
         @self.app.post("/api/adapter/autofocus")
         async def trigger_autofocus():
-            """Trigger autofocus routine."""
+            """Request autofocus to run between tasks."""
             if not self.daemon:
                 return JSONResponse({"error": "Daemon not available"}, status_code=503)
 
@@ -471,15 +483,26 @@ class CitraScopeWebApp:
                 return JSONResponse({"error": "Filter management not supported"}, status_code=404)
 
             try:
-                # Run autofocus in a separate thread to avoid blocking the async event loop
-                # Autofocus can take several minutes (slewing + focusing multiple filters)
-                success, error = await asyncio.to_thread(self.daemon.trigger_autofocus)
+                success, error = self.daemon.trigger_autofocus()
                 if success:
-                    return {"success": True, "message": "Autofocus completed successfully"}
+                    return {"success": True, "message": "Autofocus queued - will run between tasks"}
                 else:
                     return JSONResponse({"error": error}, status_code=500)
             except Exception as e:
-                CITRASCOPE_LOGGER.error(f"Error triggering autofocus: {e}", exc_info=True)
+                CITRASCOPE_LOGGER.error(f"Error queueing autofocus: {e}", exc_info=True)
+                return JSONResponse({"error": str(e)}, status_code=500)
+
+        @self.app.post("/api/adapter/autofocus/cancel")
+        async def cancel_autofocus():
+            """Cancel pending autofocus request."""
+            if not self.daemon:
+                return JSONResponse({"error": "Daemon not available"}, status_code=503)
+
+            try:
+                was_cancelled = self.daemon.cancel_autofocus()
+                return {"success": was_cancelled}
+            except Exception as e:
+                CITRASCOPE_LOGGER.error(f"Error cancelling autofocus: {e}", exc_info=True)
                 return JSONResponse({"error": str(e)}, status_code=500)
 
         @self.app.websocket("/ws")
@@ -533,9 +556,31 @@ class CitraScopeWebApp:
             if hasattr(self.daemon, "task_manager") and self.daemon.task_manager:
                 task_manager = self.daemon.task_manager
                 self.status.current_task = task_manager.current_task_id
+                self.status.autofocus_requested = task_manager.is_autofocus_requested()
                 with task_manager.heap_lock:
                     self.status.tasks_pending = len(task_manager.task_heap)
 
+            # Get autofocus timing information
+            if self.daemon.settings:
+                settings = self.daemon.settings
+                self.status.last_autofocus_timestamp = settings.last_autofocus_timestamp
+
+                # Calculate next autofocus time if scheduled is enabled
+                if settings.scheduled_autofocus_enabled:
+                    last_ts = settings.last_autofocus_timestamp
+                    interval_minutes = settings.autofocus_interval_minutes
+                    if last_ts is not None:
+                        import time
+
+                        elapsed_minutes = (int(time.time()) - last_ts) / 60
+                        remaining = max(0, interval_minutes - elapsed_minutes)
+                        self.status.next_autofocus_minutes = int(remaining)
+                    else:
+                        # Never run - will trigger immediately
+                        self.status.next_autofocus_minutes = 0
+                else:
+                    self.status.next_autofocus_minutes = None
+
             # Get ground station information from daemon (available after API validation)
             if hasattr(self.daemon, "ground_station") and self.daemon.ground_station:
                 gs_record = self.daemon.ground_station

citrascope/web/static/app.js

@@ -393,6 +393,89 @@ function updateStatus(status) {
     if (status.processing_active !== undefined) {
         updateProcessingState(status.processing_active);
     }
+
+    // Update autofocus status
+    updateAutofocusStatus(status);
+}
+
+function updateAutofocusStatus(status) {
+    // Update autofocus button state
+    const button = document.getElementById('runAutofocusButton');
+    const buttonText = document.getElementById('autofocusButtonText');
+
+    if (button && buttonText && status.autofocus_requested !== undefined) {
+        if (status.autofocus_requested) {
+            buttonText.textContent = 'Cancel Autofocus';
+            button.dataset.action = 'cancel';
+            button.classList.remove('btn-outline-primary');
+            button.classList.add('btn-outline-warning');
+        } else {
+            buttonText.textContent = 'Run Autofocus';
+            button.dataset.action = 'request';
+            button.classList.remove('btn-outline-warning');
+            button.classList.add('btn-outline-primary');
+        }
+    }
+
+    // Update last autofocus display
+    const lastAutofocusDisplay = document.getElementById('lastAutofocusDisplay');
+    if (lastAutofocusDisplay) {
+        if (status.last_autofocus_timestamp) {
+            const timestamp = status.last_autofocus_timestamp * 1000; // Convert to milliseconds
+            const now = Date.now();
+            const elapsed = now - timestamp;
+            lastAutofocusDisplay.textContent = formatElapsedTime(elapsed);
+        } else {
+            lastAutofocusDisplay.textContent = 'Never';
+        }
+    }
+
+    // Update next autofocus display
+    const nextAutofocusDisplay = document.getElementById('nextAutofocusDisplay');
+    const nextAutofocusTime = document.getElementById('nextAutofocusTime');
+
+    if (nextAutofocusDisplay && nextAutofocusTime) {
+        if (status.next_autofocus_minutes !== null && status.next_autofocus_minutes !== undefined) {
+            nextAutofocusDisplay.style.display = 'block';
+            if (status.next_autofocus_minutes === 0) {
+                nextAutofocusTime.textContent = 'now (overdue)';
+            } else {
+                nextAutofocusTime.textContent = formatMinutes(status.next_autofocus_minutes);
+            }
+        } else {
+            nextAutofocusDisplay.style.display = 'none';
+        }
+    }
+}
+
+function formatElapsedTime(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (days > 0) {
+        return `${days} day${days !== 1 ? 's' : ''} ago`;
+    } else if (hours > 0) {
+        return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
+    } else if (minutes > 0) {
+        return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
+    } else {
+        return 'just now';
+    }
+}
+
+function formatMinutes(minutes) {
+    const hours = Math.floor(minutes / 60);
+    const mins = Math.floor(minutes % 60);
+
+    if (hours > 0) {
+        if (mins > 0) {
+            return `${hours}h ${mins}m`;
+        }
+        return `${hours}h`;
+    }
+    return `${mins}m`;
 }
 
 function updateProcessingState(isActive) {