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

citrascope/__main__.py

@@ -1,24 +1,21 @@
 import click
 
 from citrascope.citra_scope_daemon import CitraScopeDaemon
+from citrascope.constants import DEFAULT_WEB_PORT
 from citrascope.settings.citrascope_settings import CitraScopeSettings
 
 
-@click.group()
-@click.option("--dev", is_flag=True, default=False, help="Use the development API (dev.app.citra.space)")
-@click.option("--log-level", default="INFO", help="Set logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
-@click.option("--keep-images", is_flag=True, default=False, help="Keep image files after upload (do not delete)")
-@click.pass_context
-def cli(ctx, dev, log_level, keep_images):
-    ctx.obj = {"settings": CitraScopeSettings(dev=dev, log_level=log_level, keep_images=keep_images)}
-
-
-@cli.command("start")
-@click.option("--web-host", default="0.0.0.0", help="Web server host address (default: 0.0.0.0)")
-@click.option("--web-port", default=24872, type=int, help="Web server port (default: 24872)")
-@click.pass_context
-def start(ctx, web_host, web_port):
-    daemon = CitraScopeDaemon(ctx.obj["settings"], enable_web=True, web_host=web_host, web_port=web_port)
+@click.command()
+@click.option(
+    "--web-port",
+    default=DEFAULT_WEB_PORT,
+    type=int,
+    help=f"Web server port (default: {DEFAULT_WEB_PORT})",
+)
+def cli(web_port):
+    """CitraScope daemon - configure via web UI at http://localhost:24872"""
+    settings = CitraScopeSettings(web_port=web_port)
+    daemon = CitraScopeDaemon(settings)
     daemon.run()
 
 

citrascope/api/citra_api_client.py

@@ -41,7 +41,19 @@ class CitraApiClient(AbstractCitraApiClient):
             return resp.json()
         except httpx.HTTPStatusError as e:
             if self.logger:
-                self.logger.error(f"HTTP error: {e.response.status_code} {e.response.text}")
+                # Check if response is HTML (e.g., Cloudflare error pages)
+                content_type = e.response.headers.get("content-type", "")
+                response_text = e.response.text
+
+                if "text/html" in content_type or response_text.strip().startswith("<"):
+                    # Log only status and a brief message for HTML responses, sometimes we get Cloudflare error pages
+                    self.logger.error(
+                        f"HTTP error: {e.response.status_code} - "
+                        f"Received HTML error page (likely Cloudflare or server error) for {method} {endpoint}"
+                    )
+                else:
+                    # Log full response for non-HTML errors (JSON, plain text, etc.)
+                    self.logger.error(f"HTTP error: {e.response.status_code} {response_text}")
             return None
         except Exception as e:
             if self.logger:

citrascope/citra_scope_daemon.py

@@ -17,9 +17,6 @@ class CitraScopeDaemon:
         settings: CitraScopeSettings,
         api_client: Optional[AbstractCitraApiClient] = None,
         hardware_adapter: Optional[AbstractAstroHardwareAdapter] = None,
-        enable_web: bool = True,
-        web_host: str = "0.0.0.0",
-        web_port: int = 24872,
     ):
         self.settings = settings
         CITRASCOPE_LOGGER.setLevel(self.settings.log_level)
@@ -33,16 +30,15 @@ class CitraScopeDaemon:
 
         self.api_client = api_client
         self.hardware_adapter = hardware_adapter
-        self.enable_web = enable_web
         self.web_server = None
         self.task_manager = None
         self.ground_station = None
         self.telescope_record = None
         self.configuration_error: Optional[str] = None
+        self._autofocus_in_progress = False
 
-        # Create web server instance if enabled (always start web server)
-        if self.enable_web:
-            self.web_server = CitraScopeWebServer(daemon=self, host=web_host, port=web_port)
+        # Create web server instance (always enabled)
+        self.web_server = CitraScopeWebServer(daemon=self, host="0.0.0.0", port=self.settings.web_port)
 
     def _create_hardware_adapter(self) -> AbstractAstroHardwareAdapter:
         """Factory method to create the appropriate hardware adapter based on settings."""
@@ -73,12 +69,8 @@ class CitraScopeDaemon:
         try:
             if reload_settings:
                 CITRASCOPE_LOGGER.info("Reloading configuration...")
-                # Reload settings from file
-                new_settings = CitraScopeSettings(
-                    dev=("dev.api" in self.settings.host),
-                    log_level=self.settings.log_level,
-                    keep_images=self.settings.keep_images,
-                )
+                # Reload settings from file (preserving web_port)
+                new_settings = CitraScopeSettings(web_port=self.settings.web_port)
                 self.settings = new_settings
                 CITRASCOPE_LOGGER.setLevel(self.settings.log_level)
 
@@ -186,6 +178,9 @@ class CitraScopeDaemon:
                 f"Hardware connected. Slew rate: {self.hardware_adapter.scope_slew_rate_degrees_per_second} deg/sec"
             )
 
+            # Save filter configuration if adapter supports it
+            self._save_filter_config()
+
             self.task_manager = TaskManager(
                 self.api_client,
                 citra_telescope_record,
@@ -205,12 +200,88 @@ 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.
+
+        This method is called:
+        - After hardware initialization to save discovered filters
+        - After autofocus to save updated focus positions
+        - After manual filter focus updates via web API
+
+        Thread safety: This modifies self.settings and writes to disk.
+        Should be called from main daemon thread or properly synchronized.
+        """
+        if not self.hardware_adapter or not self.hardware_adapter.supports_filter_management():
+            return
+
+        try:
+            filter_config = self.hardware_adapter.get_filter_config()
+            if filter_config:
+                self.settings.adapter_settings["filters"] = filter_config
+                self.settings.save()
+                CITRASCOPE_LOGGER.info(f"Saved filter configuration with {len(filter_config)} filters")
+        except Exception as e:
+            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
+
+        Returns:
+            Tuple of (success, error_message)
+        """
+        if not self.hardware_adapter:
+            return False, "No hardware adapter initialized"
+
+        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"
+
+        # 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"
+
+            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"
+
+        self._autofocus_in_progress = True
+        try:
+            CITRASCOPE_LOGGER.info("Starting autofocus routine...")
+            self.hardware_adapter.do_autofocus()
+
+            # Save updated filter configuration after autofocus
+            self._save_filter_config()
+
+            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
+
     def run(self):
-        # Start web server FIRST if enabled, so users can monitor/configure
+        # Start web server FIRST, so users can monitor/configure
         # The web interface will remain available even if configuration is incomplete
-        if self.enable_web:
-            self.web_server.start()
-            CITRASCOPE_LOGGER.info(f"Web interface available at http://{self.web_server.host}:{self.web_server.port}")
+        self.web_server.start()
+        CITRASCOPE_LOGGER.info(f"Web interface available at http://{self.web_server.host}:{self.web_server.port}")
 
         try:
             # Try to initialize components
@@ -238,6 +309,7 @@ class CitraScopeDaemon:
         """Clean up resources on shutdown."""
         if self.task_manager:
             self.task_manager.stop()
-        if self.enable_web and self.web_server:
+        if self.web_server:
             CITRASCOPE_LOGGER.info("Stopping web server...")
-            self.web_server.stop()
+            if self.web_server.web_log_handler:
+                CITRASCOPE_LOGGER.removeHandler(self.web_server.web_log_handler)

citrascope/constants.py

@@ -0,0 +1,23 @@
+"""Application-wide constants for CitraScope.
+
+This module contains all shared constants used across different parts of the application.
+Centralizing these values prevents duplication and circular import issues.
+"""
+
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+PROD_API_HOST = "api.citra.space"
+DEV_API_HOST = "dev.api.citra.space"
+DEFAULT_API_PORT = 443
+
+# ============================================================================
+# WEB APP URLs
+# ============================================================================
+PROD_APP_URL = "https://app.citra.space"
+DEV_APP_URL = "https://dev.app.citra.space"
+
+# ============================================================================
+# WEB SERVER
+# ============================================================================
+DEFAULT_WEB_PORT = 24872  # "CITRA" on phone keypad

citrascope/hardware/abstract_astro_hardware_adapter.py

@@ -20,6 +20,18 @@ class SettingSchemaEntry(TypedDict, total=False):
     options: list[str]  # List of valid options for select/dropdown inputs
 
 
+class FilterConfig(TypedDict):
+    """Type definition for filter configuration.
+
+    Attributes:
+        name: Human-readable filter name (e.g., 'Luminance', 'Red', 'Ha')
+        focus_position: Focuser position for this filter in steps
+    """
+
+    name: str
+    focus_position: int
+
+
 class ObservationStrategy(Enum):
     MANUAL = 1
     SEQUENCE_TO_CONTROLLER = 2
@@ -176,3 +188,52 @@ class AbstractAstroHardwareAdapter(ABC):
             bool: True if alignment was successful, False otherwise.
         """
         pass
+
+    def do_autofocus(self) -> None:
+        """Perform autofocus routine for all filters.
+
+        This is an optional method for adapters that support filter management.
+        Default implementation raises NotImplementedError. Override in subclasses
+        that support autofocus.
+
+        Raises:
+            NotImplementedError: If the adapter doesn't support autofocus
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support autofocus")
+
+    def supports_filter_management(self) -> bool:
+        """Indicates whether this adapter supports filter/focus management.
+
+        Returns:
+            bool: True if the adapter manages filters and focus positions, False otherwise.
+        """
+        return False
+
+    def get_filter_config(self) -> dict[str, FilterConfig]:
+        """Get the current filter configuration including focus positions.
+
+        Returns:
+            dict: Dictionary mapping filter IDs (as strings) to FilterConfig.
+                  Each FilterConfig contains:
+                  - name (str): Filter name
+                  - focus_position (int): Focuser position for this filter
+
+        Example:
+            {
+                "1": {"name": "Luminance", "focus_position": 9000},
+                "2": {"name": "Red", "focus_position": 9050}
+            }
+        """
+        return {}
+
+    def update_filter_focus(self, filter_id: str, focus_position: int) -> bool:
+        """Update the focus position for a specific filter.
+
+        Args:
+            filter_id: Filter ID as string
+            focus_position: New focus position in steps
+
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
+        return False

citrascope/hardware/nina_adv_http_adapter.py

@@ -5,16 +5,16 @@ import os
 import sys
 import time
 from pathlib import Path
+from typing import Any
 
-import platformdirs
 import requests
 
 from citrascope.hardware.abstract_astro_hardware_adapter import (
     AbstractAstroHardwareAdapter,
+    FilterConfig,
     ObservationStrategy,
     SettingSchemaEntry,
 )
-from citrascope.settings.citrascope_settings import APP_AUTHOR, APP_NAME
 
 
 class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
@@ -32,47 +32,17 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
     def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
         super().__init__(images_dir=images_dir)
         self.logger: logging.Logger = logger
-        self._data_dir = Path(platformdirs.user_data_dir(APP_NAME, appauthor=APP_AUTHOR))
-        self._focus_positions_file = self._data_dir / "nina_focus_positions.json"
         self.nina_api_path = kwargs.get("nina_api_path", "http://nina:1888/v2/api")
-        self.bypass_autofocus = kwargs.get("bypass_autofocus", False)
 
         self.filter_map = {}
-        self._load_focus_positions()
-
-    def _load_focus_positions(self):
-        """Load focus positions from file if available."""
-        try:
-            if self._focus_positions_file.exists():
-                with open(self._focus_positions_file, "r") as f:
-                    focus_data = json.load(f)
-                if self.logger:
-                    self.logger.info(f"Loaded focus positions from {self._focus_positions_file}")
-                self._focus_positions_cache = focus_data
-            else:
-                self._focus_positions_cache = {}
-        except Exception as e:
-            if self.logger:
-                self.logger.warning(f"Could not load focus positions file: {e}")
-            self._focus_positions_cache = {}
-
-    def _save_focus_positions(self):
-        """Save current filter_map focus positions to file."""
-        try:
-            # Ensure data directory exists
-            self._data_dir.mkdir(parents=True, exist_ok=True)
-
-            focus_data = {
-                str(fid): {"name": fdata["name"], "focus_position": fdata["focus_position"]}
-                for fid, fdata in self.filter_map.items()
-            }
-            with open(self._focus_positions_file, "w") as f:
-                json.dump(focus_data, f, indent=2)
-            if self.logger:
-                self.logger.info(f"Saved focus positions to {self._focus_positions_file}")
-        except Exception as e:
-            if self.logger:
-                self.logger.warning(f"Could not save focus positions file: {e}")
+        # Load filter configuration from settings if available
+        saved_filters = kwargs.get("filters", {})
+        for filter_id, filter_data in saved_filters.items():
+            # Convert string keys back to int for internal use
+            try:
+                self.filter_map[int(filter_id)] = filter_data
+            except (ValueError, TypeError) as e:
+                self.logger.warning(f"Invalid filter ID '{filter_id}' in settings, skipping: {e}")
 
     @classmethod
     def get_settings_schema(cls) -> list[SettingSchemaEntry]:
@@ -90,17 +60,20 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 "placeholder": "http://localhost:1888/v2/api",
                 "pattern": r"^https?://.*",
             },
-            {
-                "name": "bypass_autofocus",
-                "friendly_name": "Bypass Autofocus",
-                "type": "bool",
-                "default": False,
-                "description": "Skip autofocus routine when initializing, will use cached focus positions if available",
-                "required": False,
-            },
         ]
 
     def do_autofocus(self):
+        """Perform autofocus routine for all filters.
+
+        Slews telescope to Mirach (bright reference star) and runs autofocus
+        for each filter in the filter map, updating focus positions.
+
+        Raises:
+            RuntimeError: If no filters discovered or network requests fail
+        """
+        if not self.filter_map:
+            raise RuntimeError("No filters discovered. Cannot perform autofocus.")
+
         self.logger.info("Performing autofocus routine ...")
         # move telescope to bright star and start autofocus
         # Mirach ra=(1+9/60.+47.45/3600.)*15 dec=(35+37/60.+11.1/3600.)
@@ -108,10 +81,15 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         dec = 35 + 37 / 60.0 + 11.1 / 3600.0
 
         self.logger.info("Slewing to Mirach ...")
-        mount_status = requests.get(
-            self.nina_api_path + self.MOUNT_URL + "slew?ra=" + str(ra) + "&dec=" + str(dec)
-        ).json()
-        self.logger.info(f"Mount {mount_status['Response']}")
+        try:
+            response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}", timeout=30)
+            response.raise_for_status()
+            mount_status = response.json()
+            self.logger.info(f"Mount {mount_status['Response']}")
+        except requests.Timeout:
+            raise RuntimeError("Mount slew request timed out")
+        except requests.RequestException as e:
+            raise RuntimeError(f"Mount slew failed: {e}")
 
         # wait for slew to complete
         while self.telescope_is_moving():
@@ -120,14 +98,13 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         for id, filter in self.filter_map.items():
             self.logger.info(f"Focusing Filter ID: {id}, Name: {filter['name']}")
-            focus_value = self._auto_focus_one_filter(id, filter["name"])
+            # Pass existing focus position to preserve it if autofocus fails
+            existing_focus = filter.get("focus_position", self.DEFAULT_FOCUS_POSITION)
+            focus_value = self._auto_focus_one_filter(id, filter["name"], existing_focus)
             self.filter_map[id]["focus_position"] = focus_value
 
-        # Save focus positions after autofocus
-        self._save_focus_positions()
-
     # autofocus routine
-    def _auto_focus_one_filter(self, filter_id, filter_name) -> int:
+    def _auto_focus_one_filter(self, filter_id: int, filter_name: str, existing_focus_position: int) -> int:
 
         # change to the requested filter
         correct_filter_in_place = False
@@ -165,8 +142,13 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         if not last_completed_autofocus.get("Success"):
             self.logger.error(f"Failed to start autofocus: {last_completed_autofocus.get('Error')}")
-            self.logger.warning("Using default focus position")
-            return starting_focus_position
+            # Preserve existing focus position if it's not the default, otherwise use default
+            if existing_focus_position != self.DEFAULT_FOCUS_POSITION:
+                self.logger.warning(f"Preserving existing focus position: {existing_focus_position}")
+                return existing_focus_position
+            else:
+                self.logger.warning(f"Using default focus position: {self.DEFAULT_FOCUS_POSITION}")
+                return self.DEFAULT_FOCUS_POSITION
 
         while (
             last_completed_autofocus["Response"]["Filter"] != filter_name
@@ -186,13 +168,22 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
     def _do_point_telescope(self, ra: float, dec: float):
         self.logger.info(f"Slewing to RA: {ra}, Dec: {dec}")
-        slew_response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}").json()
+        try:
+            response = requests.get(f"{self.nina_api_path}{self.MOUNT_URL}slew?ra={ra}&dec={dec}", timeout=30)
+            response.raise_for_status()
+            slew_response = response.json()
 
-        if slew_response.get("Success"):
-            self.logger.info(f"Mount slew initiated: {slew_response['Response']}")
-            return True
-        else:
-            self.logger.error(f"Failed to slew mount: {slew_response.get('Error')}")
+            if slew_response.get("Success"):
+                self.logger.info(f"Mount slew initiated: {slew_response['Response']}")
+                return True
+            else:
+                self.logger.error(f"Failed to slew mount: {slew_response.get('Error')}")
+                return False
+        except requests.Timeout:
+            self.logger.error("Mount slew request timed out")
+            return False
+        except requests.RequestException as e:
+            self.logger.error(f"Mount slew request failed: {e}")
             return False
 
     def connect(self) -> bool:
@@ -240,12 +231,8 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
                 return False
             self.logger.info(f"Mount Unparked!")
 
-            # make a map of available filters and their focus positions
+            # Discover available filters (focus positions loaded from saved settings)
             self.discover_filters()
-            if not self.bypass_autofocus:
-                self.do_autofocus()
-            else:
-                self.logger.info("Bypassing autofocus routine as requested")
 
             return True
         except Exception as e:
@@ -263,16 +250,58 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
         for filter in filters:
             filter_id = filter["Id"]
             filter_name = filter["Name"]
-            # Try to load focus position from cache, fallback to default
-            focus_position = self._focus_positions_cache.get(str(filter_id), {}).get(
-                "focus_position", self.DEFAULT_FOCUS_POSITION
-            )
+            # Use existing focus position if filter already in map, otherwise use default
+            if filter_id in self.filter_map:
+                focus_position = self.filter_map[filter_id].get("focus_position", self.DEFAULT_FOCUS_POSITION)
+                self.logger.info(
+                    f"Discovered filter: {filter_name} with ID: {filter_id}, using saved focus position: {focus_position}"
+                )
+            else:
+                focus_position = self.DEFAULT_FOCUS_POSITION
+                self.logger.info(
+                    f"Discovered new filter: {filter_name} with ID: {filter_id}, using default focus position: {focus_position}"
+                )
+
             self.filter_map[filter_id] = {"name": filter_name, "focus_position": focus_position}
-            self.logger.info(f"Discovered filter: {filter_name} with ID: {filter_id}, focus position: {focus_position}")
 
     def disconnect(self):
         pass
 
+    def supports_filter_management(self) -> bool:
+        """Indicates that NINA adapter supports filter/focus management."""
+        return True
+
+    def get_filter_config(self) -> dict[str, FilterConfig]:
+        """Get current filter configuration with focus positions.
+
+        Returns:
+            dict: Filter configuration mapping filter ID strings to FilterConfig
+        """
+        return {
+            str(filter_id): {"name": filter_data["name"], "focus_position": filter_data["focus_position"]}
+            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.
+
+        Args:
+            filter_id: Filter ID as string
+            focus_position: New focus position in steps
+
+        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]["focus_position"] = focus_position
+                self.logger.info(f"Updated filter {filter_id} focus position to {focus_position}")
+                return True
+            return False
+        except (ValueError, KeyError):
+            return False
+
     def is_telescope_connected(self) -> bool:
         """Check if telescope is connected and responsive."""
         try:
@@ -422,8 +451,8 @@ class NinaAdvancedHttpAdapter(AbstractAstroHardwareAdapter):
 
         nina_sequence_name = f"Citra Target: {satellite_data['name']}, Task: {task_id}"
 
-        # Replace basic placeholders
-        tle_data = f"{elset['tle'][0]}\n{elset['tle'][1]}"
+        # Replace basic placeholders (use \r\n for Windows NINA compatibility)
+        tle_data = f"{elset['tle'][0]}\r\n{elset['tle'][1]}"
         sequence_json["Name"] = nina_sequence_name
 
         # Navigate to the TLE container (ID 20 in the template)

citrascope/logging/web_log_handler.py

@@ -23,14 +23,15 @@ class WebLogHandler(logging.Handler):
     def emit(self, record):
         """Emit a log record."""
         try:
-            # Filter out web-related logs from the web UI
-            # (uvicorn.access, WebSocket messages, HTTP Request logs, etc.)
-            if (
-                record.name.startswith("uvicorn")
-                or "WebSocket" in record.getMessage()
-                or "HTTP Request:" in record.getMessage()
-            ):
-                return
+            # Filter out routine web-related logs from the web UI
+            # but keep ERROR and CRITICAL level messages
+            if record.levelno < logging.ERROR:
+                if (
+                    record.name.startswith("uvicorn")
+                    or "WebSocket" in record.getMessage()
+                    or "HTTP Request:" in record.getMessage()
+                ):
+                    return
 
             # Get the original levelname without color codes
             # Record.levelname might have ANSI codes from ColoredFormatter