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

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) {