citrascope 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

citrascope/web/app.py

@@ -30,6 +30,7 @@ class SystemStatus(BaseModel):
     camera_connected: bool = False
     current_task: Optional[str] = None
     tasks_pending: int = 0
+    processing_active: bool = True
     hardware_adapter: str = "unknown"
     telescope_ra: Optional[float] = None
     telescope_dec: Optional[float] = None
@@ -240,6 +241,13 @@ 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:
@@ -310,11 +318,7 @@ class CitraScopeWebApp:
                                         status_code=400,
                                     )
 
-                # Save configuration to file
-                from citrascope.settings.settings_file_manager import SettingsFileManager
-
-                config_manager = SettingsFileManager()
-                config_manager.save_config(config)
+                self.daemon.settings.update_and_save(config)
 
                 # Trigger hot-reload
                 success, error = self.daemon.reload_configuration()
@@ -371,6 +375,113 @@ class CitraScopeWebApp:
                 return {"logs": logs}
             return {"logs": []}
 
+        @self.app.post("/api/tasks/pause")
+        async def pause_tasks():
+            """Pause task processing."""
+            if not self.daemon or not self.daemon.task_manager:
+                return JSONResponse({"error": "Task manager not available"}, status_code=503)
+
+            self.daemon.task_manager.pause()
+            await self.broadcast_status()
+
+            return {"status": "paused", "message": "Task processing paused"}
+
+        @self.app.post("/api/tasks/resume")
+        async def resume_tasks():
+            """Resume task processing."""
+            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()
+
+            return {"status": "active", "message": "Task processing resumed"}
+
+        @self.app.get("/api/adapter/filters")
+        async def get_filters():
+            """Get current filter configuration."""
+            if not self.daemon or not self.daemon.hardware_adapter:
+                return JSONResponse({"error": "Hardware adapter not available"}, status_code=503)
+
+            if not self.daemon.hardware_adapter.supports_filter_management():
+                return JSONResponse({"error": "Adapter does not support filter management"}, status_code=404)
+
+            try:
+                filter_config = self.daemon.hardware_adapter.get_filter_config()
+                return {"filters": filter_config}
+            except Exception as e:
+                CITRASCOPE_LOGGER.error(f"Error getting filter config: {e}", exc_info=True)
+                return JSONResponse({"error": str(e)}, status_code=500)
+
+        @self.app.patch("/api/adapter/filters/{filter_id}")
+        async def update_filter(filter_id: str, update: dict):
+            """Update focus position for a specific filter."""
+            if not self.daemon or not self.daemon.hardware_adapter:
+                return JSONResponse({"error": "Hardware adapter not available"}, status_code=503)
+
+            if not self.daemon.hardware_adapter.supports_filter_management():
+                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)
+
+                # Save to settings
+                self.daemon._save_filter_config()
+
+                return {"success": True, "filter_id": filter_id, "focus_position": focus_position}
+            except ValueError:
+                return JSONResponse({"error": "Invalid filter_id format"}, status_code=400)
+            except Exception as e:
+                CITRASCOPE_LOGGER.error(f"Error updating filter: {e}", exc_info=True)
+                return JSONResponse({"error": str(e)}, status_code=500)
+
+        @self.app.post("/api/adapter/autofocus")
+        async def trigger_autofocus():
+            """Trigger autofocus routine."""
+            if not self.daemon:
+                return JSONResponse({"error": "Daemon not available"}, status_code=503)
+
+            if not self.daemon.hardware_adapter or not self.daemon.hardware_adapter.supports_filter_management():
+                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)
+                if success:
+                    return {"success": True, "message": "Autofocus completed successfully"}
+                else:
+                    return JSONResponse({"error": error}, status_code=500)
+            except Exception as e:
+                CITRASCOPE_LOGGER.error(f"Error triggering autofocus: {e}", exc_info=True)
+                return JSONResponse({"error": str(e)}, status_code=500)
+
         @self.app.websocket("/ws")
         async def websocket_endpoint(websocket: WebSocket):
             """WebSocket endpoint for real-time updates."""
@@ -439,6 +550,10 @@ class CitraScopeWebApp:
                 self.status.ground_station_name = gs_name
                 self.status.ground_station_url = f"{base_url}/ground-stations/{gs_id}" if gs_id else None
 
+            # Update task processing state
+            if hasattr(self.daemon, "task_manager") and self.daemon.task_manager:
+                self.status.processing_active = self.daemon.task_manager.is_processing_active()
+
             self.status.last_update = datetime.now().isoformat()
 
         except Exception as e:

citrascope/web/static/app.js

@@ -1,6 +1,6 @@
 // CitraScope Dashboard - Main Application
 import { connectWebSocket } from './websocket.js';
-import { initConfig, currentConfig } from './config.js';
+import { initConfig, currentConfig, initFilterConfig, setupAutofocusButton } from './config.js';
 import { getTasks, getLogs } from './api.js';
 
 function updateAppUrlLinks() {
@@ -13,7 +13,154 @@ function updateAppUrlLinks() {
     });
 }
 
-// Global state for countdown
+// --- Version Checking ---
+
+/**
+ * Compare two semantic version strings
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+    // Strip 'v' prefix if present
+    v1 = v1.replace(/^v/, '');
+    v2 = v2.replace(/^v/, '');
+
+    const parts1 = v1.split('.').map(n => parseInt(n) || 0);
+    const parts2 = v2.split('.').map(n => parseInt(n) || 0);
+
+    const maxLen = Math.max(parts1.length, parts2.length);
+
+    for (let i = 0; i < maxLen; i++) {
+        const num1 = parts1[i] || 0;
+        const num2 = parts2[i] || 0;
+
+        if (num1 > num2) return 1;
+        if (num1 < num2) return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Fetch and display current version
+ */
+async function fetchVersion() {
+    try {
+        const response = await fetch('/api/version');
+        const data = await response.json();
+
+        // Update header version
+        const headerVersionEl = document.getElementById('headerVersion');
+
+        if (headerVersionEl && data.version) {
+            // Show "dev" for development, "v" prefix for releases
+            if (data.version === 'development') {
+                headerVersionEl.textContent = 'dev';
+            } else {
+                headerVersionEl.textContent = 'v' + data.version;
+            }
+        }
+    } catch (error) {
+        console.error('Error fetching version:', error);
+        const headerVersionEl = document.getElementById('headerVersion');
+
+        if (headerVersionEl) {
+            headerVersionEl.textContent = 'v?';
+        }
+    }
+}
+
+/**
+ * Check for available updates from GitHub
+ * Returns the check result for modal display
+ */
+async function checkForUpdates() {
+    try {
+        // Get current version
+        const versionResponse = await fetch('/api/version');
+        const versionData = await versionResponse.json();
+        const currentVersion = versionData.version;
+
+        // Check GitHub for latest release
+        const githubResponse = await fetch('https://api.github.com/repos/citra-space/citrascope/releases/latest');
+        if (!githubResponse.ok) {
+            return { status: 'error', currentVersion };
+        }
+
+        const releaseData = await githubResponse.json();
+        const latestVersion = releaseData.tag_name.replace(/^v/, '');
+        const releaseUrl = releaseData.html_url;
+
+        // Skip comparison for development versions
+        if (currentVersion === 'development' || currentVersion === 'unknown') {
+            return { status: 'up-to-date', currentVersion };
+        }
+
+        // Compare versions
+        if (compareVersions(latestVersion, currentVersion) > 0) {
+            // Update available - show indicator badge with version
+            const indicator = document.getElementById('updateIndicator');
+            if (indicator) {
+                indicator.textContent = `${latestVersion} Available!`;
+                indicator.style.display = 'inline-block';
+            }
+
+            return {
+                status: 'update-available',
+                currentVersion,
+                latestVersion,
+                releaseUrl
+            };
+        } else {
+            // Up to date - hide indicator badge
+            const indicator = document.getElementById('updateIndicator');
+            if (indicator) {
+                indicator.style.display = 'none';
+            }
+
+            return { status: 'up-to-date', currentVersion };
+        }
+    } catch (error) {
+        // Network error
+        console.debug('Update check failed:', error);
+        return { status: 'error', currentVersion: 'unknown' };
+    }
+}
+
+/**
+ * Show version check modal with results
+ */
+async function showVersionModal() {
+    const modal = new bootstrap.Modal(document.getElementById('versionModal'));
+    modal.show();
+
+    // Show loading state
+    document.getElementById('versionCheckLoading').style.display = 'block';
+    document.getElementById('versionCheckUpToDate').style.display = 'none';
+    document.getElementById('versionCheckUpdateAvailable').style.display = 'none';
+    document.getElementById('versionCheckError').style.display = 'none';
+
+    // Perform check
+    const result = await checkForUpdates();
+
+    // Hide loading
+    document.getElementById('versionCheckLoading').style.display = 'none';
+
+    // Show appropriate result
+    if (result.status === 'update-available') {
+        document.getElementById('modalCurrentVersion').textContent = 'v' + result.currentVersion;
+        document.getElementById('modalLatestVersion').textContent = 'v' + result.latestVersion;
+        document.getElementById('releaseNotesLink').href = result.releaseUrl;
+        document.getElementById('versionCheckUpdateAvailable').style.display = 'block';
+    } else if (result.status === 'up-to-date') {
+        document.getElementById('modalCurrentVersionUpToDate').textContent = result.currentVersion === 'development' ? 'development' : 'v' + result.currentVersion;
+        document.getElementById('versionCheckUpToDate').style.display = 'block';
+    } else {
+        document.getElementById('modalCurrentVersionError').textContent = result.currentVersion === 'development' ? 'development' : result.currentVersion;
+        document.getElementById('versionCheckError').style.display = 'block';
+    }
+}
+
+// --- Task Management ---
 let nextTaskStartTime = null;
 let countdownInterval = null;
 let isTaskActive = false;
@@ -139,6 +286,11 @@ function initNavigation() {
                 const section = link.getAttribute('data-section');
                 activateNav(link);
                 showSection(section);
+
+                // Reload filter config when config section is shown
+                if (section === 'config') {
+                    initFilterConfig();
+                }
             }
         });
 
@@ -207,7 +359,9 @@ function updateStatus(status) {
     }
     // If isTaskActive is already false, don't touch the display (countdown is updating it)
 
-    document.getElementById('tasksPending').textContent = status.tasks_pending || '0';
+    if (status.tasks_pending !== undefined) {
+        document.getElementById('tasksPending').textContent = status.tasks_pending || '0';
+    }
 
     if (status.telescope_ra !== null) {
         document.getElementById('telescopeRA').textContent = status.telescope_ra.toFixed(4) + '°';
@@ -217,20 +371,45 @@ function updateStatus(status) {
     }
 
     // Update ground station information
-    const gsNameEl = document.getElementById('groundStationName');
-    const taskScopeButton = document.getElementById('taskScopeButton');
-
-    if (status.ground_station_name && status.ground_station_url) {
-        gsNameEl.innerHTML = `<a href="${status.ground_station_url}" target="_blank" class="ground-station-link">${status.ground_station_name} ↗</a>`;
-        // Update the Task My Scope button
-        taskScopeButton.href = status.ground_station_url;
-        taskScopeButton.style.display = 'inline-block';
-    } else if (status.ground_station_name) {
-        gsNameEl.textContent = status.ground_station_name;
-        taskScopeButton.style.display = 'none';
+    if (status.ground_station_name !== undefined || status.ground_station_url !== undefined) {
+        const gsNameEl = document.getElementById('groundStationName');
+        const taskScopeButton = document.getElementById('taskScopeButton');
+
+        if (status.ground_station_name && status.ground_station_url) {
+            gsNameEl.innerHTML = `<a href="${status.ground_station_url}" target="_blank" class="ground-station-link">${status.ground_station_name} ↗</a>`;
+            // Update the Task My Scope button
+            taskScopeButton.href = status.ground_station_url;
+            taskScopeButton.style.display = 'inline-block';
+        } else if (status.ground_station_name) {
+            gsNameEl.textContent = status.ground_station_name;
+            taskScopeButton.style.display = 'none';
+        } else {
+            gsNameEl.textContent = '-';
+            taskScopeButton.style.display = 'none';
+        }
+    }
+
+    // Update task processing state
+    if (status.processing_active !== undefined) {
+        updateProcessingState(status.processing_active);
+    }
+}
+
+function updateProcessingState(isActive) {
+    const statusEl = document.getElementById('processingStatus');
+    const button = document.getElementById('toggleProcessingButton');
+    const icon = document.getElementById('processingButtonIcon');
+
+    if (!statusEl || !button || !icon) return;
+
+    if (isActive) {
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-success">Active</span>';
+        icon.textContent = 'Pause';
+        button.title = 'Pause task processing';
     } else {
-        gsNameEl.textContent = '-';
-        taskScopeButton.style.display = 'none';
+        statusEl.innerHTML = '<span class="badge rounded-pill bg-warning text-dark">Paused</span>';
+        icon.textContent = 'Resume';
+        button.title = 'Resume task processing';
     }
 }
 
@@ -485,9 +664,28 @@ document.addEventListener('DOMContentLoaded', async function() {
     // Initialize configuration management (loads config)
     await initConfig();
 
+    // Initialize filter configuration
+    await initFilterConfig();
+
+    // Setup autofocus button (only once)
+    setupAutofocusButton();
+
     // Update app URL links from loaded config
     updateAppUrlLinks();
 
+    // Fetch and display version
+    fetchVersion();
+
+    // Check for updates on load and every hour
+    checkForUpdates();
+    setInterval(checkForUpdates, 3600000); // Check every hour
+
+    // Wire up version click to open modal
+    const headerVersion = document.getElementById('headerVersion');
+    if (headerVersion) {
+        headerVersion.addEventListener('click', showVersionModal);
+    }
+
     // Connect WebSocket with handlers
     connectWebSocket({
         onStatus: updateStatus,
@@ -499,4 +697,33 @@ document.addEventListener('DOMContentLoaded', async function() {
     // Load initial data
     loadTasks();
     loadLogs();
+
+    // Add pause/resume button handler
+    const toggleButton = document.getElementById('toggleProcessingButton');
+    if (toggleButton) {
+        toggleButton.addEventListener('click', async () => {
+            const icon = document.getElementById('processingButtonIcon');
+            const currentlyPaused = icon && icon.textContent === 'Resume';
+            const endpoint = currentlyPaused ? '/api/tasks/resume' : '/api/tasks/pause';
+
+            try {
+                toggleButton.disabled = true;
+                const response = await fetch(endpoint, { method: 'POST' });
+                const result = await response.json();
+
+                if (!response.ok) {
+                    console.error('Failed to toggle processing:', result);
+                    // Show specific error message (e.g., "Cannot resume during autofocus")
+                    alert((result.error || 'Failed to toggle task processing') +
+                          (response.status === 409 ? '' : ' - Unknown error'));
+                }
+                // State will be updated via WebSocket broadcast within 2 seconds
+            } catch (error) {
+                console.error('Error toggling processing:', error);
+                alert('Error toggling task processing');
+            } finally {
+                toggleButton.disabled = false;
+            }
+        });
+    }
 });