citrascope 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

citrascope/settings/citrascope_settings.py

@@ -10,6 +10,7 @@ import platformdirs
 APP_NAME = "citrascope"
 APP_AUTHOR = "citra-space"
 
+from citrascope.constants import DEFAULT_API_PORT, DEFAULT_WEB_PORT, PROD_API_HOST
 from citrascope.logging import CITRASCOPE_LOGGER
 from citrascope.settings.settings_file_manager import SettingsFileManager
 
@@ -17,18 +18,11 @@ from citrascope.settings.settings_file_manager import SettingsFileManager
 class CitraScopeSettings:
     """Settings for CitraScope loaded from JSON configuration file."""
 
-    def __init__(
-        self,
-        dev: bool = False,
-        log_level: str = "INFO",
-        keep_images: bool = False,
-    ):
+    def __init__(self, web_port: int = DEFAULT_WEB_PORT):
         """Initialize settings from JSON config file.
 
         Args:
-            dev: If True, use development API endpoint
-            log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
-            keep_images: If True, preserve captured images
+            web_port: Port for web interface (default: 24872) - bootstrap option only
         """
         self.config_manager = SettingsFileManager()
 
@@ -38,9 +32,9 @@ class CitraScopeSettings:
         # Application data directories
         self._images_dir = Path(platformdirs.user_data_dir(APP_NAME, appauthor=APP_AUTHOR)) / "images"
 
-        # API Settings
-        self.host: str = config.get("host", "dev.api.citra.space" if dev else "api.citra.space")
-        self.port: int = config.get("port", 443)
+        # API Settings (all loaded from config file)
+        self.host: str = config.get("host", PROD_API_HOST)
+        self.port: int = config.get("port", DEFAULT_API_PORT)
         self.use_ssl: bool = config.get("use_ssl", True)
         self.personal_access_token: str = config.get("personal_access_token", "")
         self.telescope_id: str = config.get("telescope_id", "")
@@ -48,12 +42,19 @@ class CitraScopeSettings:
         # Hardware adapter selection
         self.hardware_adapter: str = config.get("hardware_adapter", "")
 
-        # Hardware adapter-specific settings stored as dict
-        self.adapter_settings: Dict[str, Any] = config.get("adapter_settings", {})
+        # Hardware adapter-specific settings stored as nested dict per adapter
+        # Format: {"adapter_name": {"setting_key": value, ...}, ...}
+        self._all_adapter_settings: Dict[str, Dict[str, Any]] = config.get("adapter_settings", {})
 
-        # Runtime settings (can be overridden by CLI flags)
-        self.log_level: str = log_level if log_level != "INFO" else config.get("log_level", "INFO")
-        self.keep_images: bool = keep_images if keep_images else config.get("keep_images", False)
+        # Current adapter's settings slice
+        self.adapter_settings: Dict[str, Any] = self._all_adapter_settings.get(self.hardware_adapter, {})
+
+        # Runtime settings (all loaded from config file, configurable via web UI)
+        self.log_level: str = config.get("log_level", "INFO")
+        self.keep_images: bool = config.get("keep_images", False)
+
+        # Web port: CLI override if non-default, otherwise use config file
+        self.web_port: int = web_port if web_port != DEFAULT_WEB_PORT else config.get("web_port", DEFAULT_WEB_PORT)
 
         # Task retry configuration
         self.max_task_retries: int = config.get("max_task_retries", 3)
@@ -64,10 +65,6 @@ class CitraScopeSettings:
         self.file_logging_enabled: bool = config.get("file_logging_enabled", True)
         self.log_retention_days: int = config.get("log_retention_days", 30)
 
-        if dev:
-            self.host = "dev.api.citra.space"
-            CITRASCOPE_LOGGER.info("Using development API endpoint.")
-
     def get_images_dir(self) -> Path:
         """Get the path to the images directory.
 
@@ -102,9 +99,10 @@ class CitraScopeSettings:
             "personal_access_token": self.personal_access_token,
             "telescope_id": self.telescope_id,
             "hardware_adapter": self.hardware_adapter,
-            "adapter_settings": self.adapter_settings,
+            "adapter_settings": self._all_adapter_settings,
             "log_level": self.log_level,
             "keep_images": self.keep_images,
+            "web_port": self.web_port,
             "max_task_retries": self.max_task_retries,
             "initial_retry_delay_seconds": self.initial_retry_delay_seconds,
             "max_retry_delay_seconds": self.max_retry_delay_seconds,
@@ -114,32 +112,23 @@ class CitraScopeSettings:
 
     def save(self) -> None:
         """Save current settings to JSON config file."""
+        # Update nested dict with current adapter's settings before saving
+        if self.hardware_adapter:
+            self._all_adapter_settings[self.hardware_adapter] = self.adapter_settings
+
         self.config_manager.save_config(self.to_dict())
         CITRASCOPE_LOGGER.info(f"Configuration saved to {self.config_manager.get_config_path()}")
 
-    @classmethod
-    def from_dict(cls, config: Dict[str, Any]) -> "CitraScopeSettings":
-        """Create settings instance from dictionary.
+    def update_and_save(self, config: Dict[str, Any]) -> None:
+        """Update settings from dict and save, preserving other adapters' settings.
 
         Args:
-            config: Dictionary of configuration values.
-
-        Returns:
-            New CitraScopeSettings instance.
+            config: Configuration dict with flat adapter_settings for current adapter.
         """
-        settings = cls()
-        settings.host = config.get("host", settings.host)
-        settings.port = config.get("port", settings.port)
-        settings.use_ssl = config.get("use_ssl", settings.use_ssl)
-        settings.personal_access_token = config.get("personal_access_token", "")
-        settings.telescope_id = config.get("telescope_id", "")
-        settings.hardware_adapter = config.get("hardware_adapter", "")
-        settings.adapter_settings = config.get("adapter_settings", {})
-        settings.log_level = config.get("log_level", "INFO")
-        settings.keep_images = config.get("keep_images", False)
-        settings.max_task_retries = config.get("max_task_retries", 3)
-        settings.initial_retry_delay_seconds = config.get("initial_retry_delay_seconds", 30)
-        settings.max_retry_delay_seconds = config.get("max_retry_delay_seconds", 300)
-        settings.file_logging_enabled = config.get("file_logging_enabled", True)
-        settings.log_retention_days = config.get("log_retention_days", 30)
-        return settings
+        # Nest incoming adapter_settings under hardware_adapter key
+        adapter = config.get("hardware_adapter", self.hardware_adapter)
+        if adapter:
+            self._all_adapter_settings[adapter] = config.get("adapter_settings", {})
+        config["adapter_settings"] = self._all_adapter_settings
+
+        self.config_manager.save_config(config)

citrascope/tasks/runner.py

@@ -11,6 +11,9 @@ from citrascope.tasks.scope.static_telescope_task import StaticTelescopeTask
 from citrascope.tasks.scope.tracking_telescope_task import TrackingTelescopeTask
 from citrascope.tasks.task import Task
 
+# Task polling interval in seconds
+TASK_POLL_INTERVAL_SECONDS = 15
+
 
 class TaskManager:
     def __init__(
@@ -37,6 +40,9 @@ class TaskManager:
         self.keep_images = keep_images
         self.task_retry_counts = {}  # Track retry attempts per task ID
         self.task_last_failure = {}  # Track last failure timestamp per task ID
+        # Task processing control (always starts active)
+        self._processing_active = True
+        self._processing_lock = threading.Lock()
 
     def poll_tasks(self):
         while not self._stop_event.is_set():
@@ -44,8 +50,9 @@ class TaskManager:
                 self._report_online()
                 tasks = self.api_client.get_telescope_tasks(self.telescope_record["id"])
 
-                # If API call failed (timeout, network error, etc.), skip this poll iteration
+                # If API call failed (timeout, network error, etc.), wait before retrying
                 if tasks is None:
+                    self._stop_event.wait(TASK_POLL_INTERVAL_SECONDS)
                     continue
 
                 added = 0
@@ -113,7 +120,7 @@ class TaskManager:
             except Exception as e:
                 self.logger.error(f"Exception in poll_tasks loop: {e}", exc_info=True)
                 time.sleep(5)  # avoid tight error loop
-            self._stop_event.wait(15)
+            self._stop_event.wait(TASK_POLL_INTERVAL_SECONDS)
 
     def _report_online(self):
         """
@@ -126,6 +133,14 @@ class TaskManager:
 
     def task_runner(self):
         while not self._stop_event.is_set():
+            # Check if task processing is paused
+            with self._processing_lock:
+                is_paused = not self._processing_active
+
+            if is_paused:
+                self._stop_event.wait(1)
+                continue
+
             try:
                 now = int(time.time())
                 completed = 0
@@ -239,6 +254,25 @@ class TaskManager:
                 summary += "No tasks scheduled."
             return summary
 
+    def pause(self) -> bool:
+        """Pause task processing. Returns new state (False)."""
+        with self._processing_lock:
+            self._processing_active = False
+            self.logger.info("Task processing paused")
+            return self._processing_active
+
+    def resume(self) -> bool:
+        """Resume task processing. Returns new state (True)."""
+        with self._processing_lock:
+            self._processing_active = True
+            self.logger.info("Task processing resumed")
+            return self._processing_active
+
+    def is_processing_active(self) -> bool:
+        """Check if task processing is currently active."""
+        with self._processing_lock:
+            return self._processing_active
+
     def start(self):
         self._stop_event.clear()
         self.poll_thread = threading.Thread(target=self.poll_tasks, daemon=True)

citrascope/web/app.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import os
 from datetime import datetime, timezone
+from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -13,15 +14,14 @@ from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
+from citrascope.constants import (
+    DEV_API_HOST,
+    DEV_APP_URL,
+    PROD_API_HOST,
+    PROD_APP_URL,
+)
 from citrascope.logging import CITRASCOPE_LOGGER
 
-# ============================================================================
-# URL CONSTANTS - Single source of truth for Citra web URLs
-# ============================================================================
-PROD_APP_URL = "https://app.citra.space"
-DEV_APP_URL = "https://dev.app.citra.space"
-# ============================================================================
-
 
 class SystemStatus(BaseModel):
     """Current system status."""
@@ -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
@@ -155,7 +156,7 @@ class CitraScopeWebApp:
 
             settings = self.daemon.settings
             # Determine app URL based on API host
-            app_url = DEV_APP_URL if "dev." in settings.host else PROD_APP_URL
+            app_url = DEV_APP_URL if settings.host == DEV_API_HOST else PROD_APP_URL
 
             # Get config file path
             config_path = str(settings.config_manager.get_config_path())
@@ -198,6 +199,15 @@ class CitraScopeWebApp:
                 "error": getattr(self.daemon, "configuration_error", None),
             }
 
+        @self.app.get("/api/version")
+        async def get_version():
+            """Get CitraScope version."""
+            try:
+                pkg_version = version("citrascope")
+                return {"version": pkg_version}
+            except PackageNotFoundError:
+                return {"version": "development"}
+
         @self.app.get("/api/hardware-adapters")
         async def get_hardware_adapters():
             """Get list of available hardware adapters."""
@@ -231,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:
@@ -301,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()
@@ -362,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."""
@@ -430,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/server.py

@@ -7,13 +7,14 @@ import time
 
 import uvicorn
 
+from citrascope.constants import DEFAULT_WEB_PORT
 from citrascope.logging import CITRASCOPE_LOGGER, WebLogHandler
 
 
 class CitraScopeWebServer:
     """Manages the web server and its configuration."""
 
-    def __init__(self, daemon, host: str = "0.0.0.0", port: int = 24872):
+    def __init__(self, daemon, host: str = "0.0.0.0", port: int = DEFAULT_WEB_PORT):
         self.daemon = daemon
         self.host = host
         self.port = port
@@ -101,6 +102,14 @@ class CitraScopeWebServer:
             asyncio.create_task(self._status_broadcast_loop())
 
             await server.serve()
+        except OSError as e:
+            if e.errno == 48:  # Address already in use
+                CITRASCOPE_LOGGER.error(
+                    f"Port {self.port} is already in use. Please stop any other services using this port "
+                    f"or use --web-port to specify a different port."
+                )
+            else:
+                CITRASCOPE_LOGGER.error(f"Web server OS error: {e}", exc_info=True)
         except Exception as e:
             CITRASCOPE_LOGGER.error(f"Web server error: {e}", exc_info=True)