citrascope 0.8.0__tar.gz → 0.9.1__tar.gz

{citrascope-0.8.0 → citrascope-0.9.1}/.gitignore

@@ -137,3 +137,5 @@ citra_image.fits
 hip_main.dat
 nina_sequence_*.json
 nina_focus_positions.json
+
+citrascope-env/

{citrascope-0.8.0 → citrascope-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: citrascope
-Version: 0.8.0
+Version: 0.9.1
 Summary: Remotely control a telescope while it polls for tasks, collects and edge processes data, and delivers results and data for further processing.
 Project-URL: Homepage, https://citra.space
 Project-URL: Documentation, https://docs.citra.space/citrascope/
@@ -25,6 +25,7 @@ Requires-Python: <3.13,>=3.10
 Requires-Dist: click
 Requires-Dist: fastapi>=0.104.0
 Requires-Dist: httpx
+Requires-Dist: jinja2>=3.1.0
 Requires-Dist: ntplib>=0.4.0
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: python-dateutil
@@ -202,7 +203,7 @@ This ensures code style and quality checks are enforced for all contributors.
 
 ### Releasing a New Version
 
-To bump the version and create a release:
+To bump the version and create a release from in the venv:
 
 ```sh
 bump-my-version bump patch  # 0.1.3 → 0.1.4

{citrascope-0.8.0 → citrascope-0.9.1}/README.md

@@ -120,7 +120,7 @@ This ensures code style and quality checks are enforced for all contributors.
 
 ### Releasing a New Version
 
-To bump the version and create a release:
+To bump the version and create a release from in the venv:
 
 ```sh
 bump-my-version bump patch  # 0.1.3 → 0.1.4

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/abstract_astro_hardware_adapter.py

@@ -234,6 +234,23 @@ class AbstractAstroHardwareAdapter(ABC):
         """
         return False
 
+    def supports_direct_camera_control(self) -> bool:
+        """Indicates whether this adapter supports direct camera control.
+
+        Direct camera control allows manual test captures and camera operations
+        from the UI. Remote scheduler adapters (NINA, KStars) typically do not
+        support this, as camera control is managed by the external software.
+
+        Returns:
+            bool: True if the adapter supports expose_camera() and manual captures
+        """
+        # Remote schedulers never support direct control
+        if self.get_observation_strategy() == ObservationStrategy.SEQUENCE_TO_CONTROLLER:
+            return False
+
+        # MANUAL adapters might - check for the method
+        return hasattr(self, "expose_camera") and callable(getattr(self, "expose_camera"))
+
     def is_hyperspectral(self) -> bool:
         """Indicates whether this adapter uses a hyperspectral camera.
 

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/adapter_registry.py

@@ -38,6 +38,11 @@ REGISTERED_ADAPTERS: Dict[str, Dict[str, str]] = {
         "class_name": "DirectHardwareAdapter",
         "description": "Direct Hardware Control - Composable device adapters for cameras, mounts, etc.",
     },
+    "dummy": {
+        "module": "citrascope.hardware.dummy_adapter",
+        "class_name": "DummyAdapter",
+        "description": "Dummy Adapter - Fake hardware for testing without real devices",
+    },
 }
 
 

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/devices/camera/abstract_camera.py

@@ -100,3 +100,15 @@ class AbstractCamera(AbstractHardwareDevice):
             bool: True if hyperspectral camera, False otherwise (default)
         """
         return False
+
+    def get_preferred_file_extension(self) -> str:
+        """Get the preferred file extension for saved images.
+
+        This method allows each camera to define what file format it wants
+        to use, without the hardware adapter needing to know camera internals.
+
+        Returns:
+            File extension string without the dot (e.g., 'fits', 'png', 'jpg')
+        """
+        # Default implementation: use output_format if available, otherwise FITS
+        return getattr(self, "output_format", "fits")

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/devices/camera/usb_camera.py

@@ -118,20 +118,21 @@ class UsbCamera(AbstractCamera):
             try:
                 from cv2_enumerate_cameras import enumerate_cameras
 
-                for camera_info in enumerate_cameras():
-                    index = camera_info.index
-                    name = camera_info.name or f"Camera {index}"
-                    backend = camera_info.backend or ""
+                # Get fancy camera names from enumerate_cameras
+                # Assumption: enumerate_cameras() returns cameras in the same order as OpenCV detection
+                camera_infos = list(enumerate_cameras())
 
-                    # Get resolution
-                    cap = cv2.VideoCapture(index)
-                    if cap.isOpened():
-                        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-                        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-                        cap.release()
+                logging.debug(f"cv2_enumerate_cameras found {len(camera_infos)} cameras")
 
-                        backend_str = f" ({backend})" if backend else ""
-                        cameras.append({"value": index, "label": f"{name} - {width}x{height}{backend_str}"})
+                # Use the actual device index from camera_info for OpenCV compatibility
+                # Don't actually open cameras here - too wasteful
+                for camera_info in enumerate_cameras():
+                    name = camera_info.name or f"Camera {camera_info.index}"
+
+                    # Note: We're NOT opening cameras to verify or get resolution
+                    # Use camera_info.index (the actual OpenCV device index) not enumerate position
+                    cameras.append({"value": camera_info.index, "label": name})
+                    logging.debug(f"Found camera with device_id {camera_info.index}: {name}")
 
             except ImportError:
                 # cv2-enumerate-cameras not installed, use basic detection
@@ -297,12 +298,16 @@ class UsbCamera(AbstractCamera):
                 new_size = (width // binning, height // binning)
                 frame = self._cv2_module.resize(frame, new_size, interpolation=self._cv2_module.INTER_AREA)
 
+            # Determine format from file extension (if save_path provided) or configured output_format
+            file_extension = save_path.suffix.lower().lstrip(".")
+            format_to_use = file_extension if file_extension in ["fits", "png", "jpg", "jpeg"] else self.output_format
+
             # Save based on format
-            if self.output_format == "fits":
+            if format_to_use == "fits":
                 self._save_as_fits(frame, save_path)
-            elif self.output_format == "png":
+            elif format_to_use == "png":
                 self._cv2_module.imwrite(str(save_path), frame)
-            elif self.output_format == "jpg":
+            elif format_to_use in ["jpg", "jpeg"]:
                 self._cv2_module.imwrite(str(save_path), frame, [self._cv2_module.IMWRITE_JPEG_QUALITY, 95])
 
             self.logger.info(f"Image saved to {save_path}")

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/devices/camera/ximea_camera.py

@@ -20,9 +20,11 @@ class XimeaHyperspectralCamera(AbstractCamera):
         default_gain (float): Default gain in dB
         default_exposure_ms (float): Default exposure time in milliseconds
         spectral_bands (int): Number of spectral bands (e.g., 16 for SM4X4, 25 for SM5X5)
-        output_format (str): Output format - 'raw' (2D mosaic) or 'datacube' (3D bands)
+        data_mode (str): Data structure - 'raw' (2D mosaic) or 'datacube' (3D separated bands)
         vertical_flip (bool): Flip image vertically
         horizontal_flip (bool): Flip image horizontally
+
+    Note: Always outputs FITS format files regardless of data_mode.
     """
 
     @classmethod
@@ -98,11 +100,11 @@ class XimeaHyperspectralCamera(AbstractCamera):
                 "group": "Camera",
             },
             {
-                "name": "output_format",
-                "friendly_name": "Output Format",
+                "name": "data_mode",
+                "friendly_name": "Data Mode",
                 "type": "str",
                 "default": "raw",
-                "description": "Output format: raw (2D mosaic) or datacube (3D separated bands)",
+                "description": "Data structure: raw (2D mosaic) or datacube (3D separated bands)",
                 "required": False,
                 "options": ["raw", "datacube"],
                 "group": "Camera",
@@ -151,7 +153,7 @@ class XimeaHyperspectralCamera(AbstractCamera):
         self.default_gain: float = kwargs.get("default_gain", 0.0)
         self.default_exposure_ms: float = kwargs.get("default_exposure_ms", 100.0)
         self.spectral_bands: int = kwargs.get("spectral_bands", 25)
-        self.output_format: str = kwargs.get("output_format", "raw")
+        self.data_mode: str = kwargs.get("data_mode", "raw")  # raw mosaic or datacube
         self.vertical_flip: bool = kwargs.get("vertical_flip", False)
         self.horizontal_flip: bool = kwargs.get("horizontal_flip", False)
 
@@ -375,7 +377,7 @@ class XimeaHyperspectralCamera(AbstractCamera):
                 timestamp = time.strftime("%Y%m%d_%H%M%S")
                 save_path = Path(f"ximea_hyperspectral_{timestamp}.tiff")
 
-            # Save image (format depends on output_format setting)
+            # Save image (data structure depends on data_mode setting)
             self.logger.debug(f"Saving image to: {save_path}")
             self._save_hyperspectral_image(img, save_path)
 
@@ -458,6 +460,16 @@ class XimeaHyperspectralCamera(AbstractCamera):
         """
         return True
 
+    def get_preferred_file_extension(self) -> str:
+        """Get the preferred file extension for saved images.
+
+        Ximea hyperspectral cameras always output FITS format.
+
+        Returns:
+            'fits' - FITS format with hyperspectral metadata
+        """
+        return "fits"
+
     def get_camera_info(self) -> dict:
         """Get camera capabilities and information.
 
@@ -552,8 +564,8 @@ class XimeaHyperspectralCamera(AbstractCamera):
         # Get image data as numpy array
         data = img.get_image_data_numpy()
 
-        # Process based on output_format setting
-        if self.output_format == "datacube":
+        # Process based on data_mode setting
+        if self.data_mode == "datacube":
             # Create 3D datacube by demosaicing the spectral mosaic
             datacube = self._demosaic_to_datacube(data)
 
@@ -568,7 +580,7 @@ class XimeaHyperspectralCamera(AbstractCamera):
                 # Hyperspectral metadata
                 primary_hdu.header["HIERARCH SPECTRAL_TYPE"] = "hyperspectral"
                 primary_hdu.header["HIERARCH SPECTRAL_BANDS"] = self.spectral_bands
-                primary_hdu.header["HIERARCH OUTPUT_FORMAT"] = "datacube"
+                primary_hdu.header["HIERARCH DATA_MODE"] = "datacube"
                 primary_hdu.header["HIERARCH SENSOR_TYPE"] = "snapshot_mosaic"
 
                 # Capture metadata
@@ -636,7 +648,7 @@ class XimeaHyperspectralCamera(AbstractCamera):
                 # Hyperspectral metadata
                 hdu.header["HIERARCH SPECTRAL_TYPE"] = "hyperspectral"
                 hdu.header["HIERARCH SPECTRAL_BANDS"] = self.spectral_bands
-                hdu.header["HIERARCH OUTPUT_FORMAT"] = "raw"
+                hdu.header["HIERARCH DATA_MODE"] = "raw"
                 hdu.header["HIERARCH SENSOR_TYPE"] = "snapshot_mosaic"
 
                 # Capture metadata

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/hardware/direct_hardware_adapter.py

@@ -444,6 +444,21 @@ class DirectHardwareAdapter(AbstractAstroHardwareAdapter):
             return (0.0, 0.0)
         return self.mount.get_radec()
 
+    def _get_camera_file_extension(self) -> str:
+        """Get the preferred file extension from the camera.
+
+        Delegates to the camera's get_preferred_file_extension() method,
+        which allows each camera type to define its own file format logic.
+
+        Returns:
+            File extension string (e.g., 'fits', 'png', 'jpg')
+        """
+        if not self.camera:
+            return "fits"
+
+        # Let the camera decide its preferred file extension
+        return self.camera.get_preferred_file_extension()
+
     def expose_camera(
         self,
         exposure_time: float,
@@ -473,9 +488,10 @@ class DirectHardwareAdapter(AbstractAstroHardwareAdapter):
             if count > 1:
                 self.logger.info(f"Exposure {i+1}/{count}")
 
-            # Generate save path
+            # Generate save path with camera's preferred file extension
             timestamp = time.strftime("%Y%m%d_%H%M%S")
-            save_path = self.images_dir / f"direct_capture_{timestamp}_{i:03d}.fits"
+            output_ext = self._get_camera_file_extension()
+            save_path = self.images_dir / f"direct_capture_{timestamp}_{i:03d}.{output_ext}"
 
             # Take exposure
             image_path = self.camera.take_exposure(
@@ -720,7 +736,9 @@ class DirectHardwareAdapter(AbstractAstroHardwareAdapter):
 
         # Generate save path with task ID
         timestamp = time.strftime("%Y%m%d_%H%M%S")
-        save_path = self.images_dir / f"task_{task_id}_{timestamp}.fits"
+        # Use camera's preferred file extension
+        output_ext = self._get_camera_file_extension()
+        save_path = self.images_dir / f"task_{task_id}_{timestamp}.{output_ext}"
 
         return str(
             self.camera.take_exposure(

citrascope-0.9.1/citrascope/hardware/dummy_adapter.py

@@ -0,0 +1,202 @@
+"""Dummy hardware adapter for testing without real hardware."""
+
+import logging
+import time
+from pathlib import Path
+
+from citrascope.hardware.abstract_astro_hardware_adapter import (
+    AbstractAstroHardwareAdapter,
+    ObservationStrategy,
+    SettingSchemaEntry,
+)
+
+
+class DummyAdapter(AbstractAstroHardwareAdapter):
+    """
+    Dummy hardware adapter that simulates hardware without requiring real devices.
+
+    Perfect for testing, development, and demonstrations. All operations are logged
+    and return realistic fake data.
+    """
+
+    def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
+        """Initialize dummy adapter.
+
+        Args:
+            logger: Logger instance
+            images_dir: Path to images directory
+            **kwargs: Additional settings including 'simulate_slow_operations'
+        """
+        super().__init__(images_dir, **kwargs)
+        self.logger = logger
+        self.simulate_slow = kwargs.get("simulate_slow_operations", False)
+        self.slow_delay = kwargs.get("slow_delay_seconds", 2.0)
+
+        # Fake hardware state
+        self._connected = False
+        self._telescope_connected = False
+        self._camera_connected = False
+        self._current_ra = 0.0  # degrees
+        self._current_dec = 0.0  # degrees
+        self._is_moving = False
+        self._tracking_rate = (15.041, 0.0)  # arcsec/sec (sidereal rate)
+
+        self.logger.info("DummyAdapter initialized")
+
+    @classmethod
+    def get_settings_schema(cls, **kwargs) -> list[SettingSchemaEntry]:
+        """Return configuration schema for dummy adapter."""
+        return [
+            {
+                "name": "simulate_slow_operations",
+                "friendly_name": "Simulate Slow Operations",
+                "type": "bool",
+                "default": False,
+                "description": "Add artificial delays to simulate slow hardware responses",
+                "required": False,
+                "group": "Testing",
+            },
+            {
+                "name": "slow_delay_seconds",
+                "friendly_name": "Delay Duration (seconds)",
+                "type": "float",
+                "default": 2.0,
+                "min": 0.1,
+                "max": 10.0,
+                "description": "Duration of artificial delays when slow simulation is enabled",
+                "required": False,
+                "group": "Testing",
+            },
+        ]
+
+    def get_observation_strategy(self) -> ObservationStrategy:
+        """Dummy adapter uses manual strategy."""
+        return ObservationStrategy.MANUAL
+
+    def perform_observation_sequence(self, task, satellite_data) -> str:
+        """Not used for manual strategy."""
+        raise NotImplementedError("DummyAdapter uses MANUAL strategy")
+
+    def connect(self) -> bool:
+        """Simulate connection."""
+        self.logger.info("DummyAdapter: Connecting...")
+        self._simulate_delay()
+        self._connected = True
+        self._telescope_connected = True
+        self._camera_connected = True
+        self.logger.info("DummyAdapter: Connected successfully")
+        return True
+
+    def disconnect(self):
+        """Simulate disconnection."""
+        self.logger.info("DummyAdapter: Disconnecting...")
+        self._connected = False
+        self._telescope_connected = False
+        self._camera_connected = False
+        self.logger.info("DummyAdapter: Disconnected")
+
+    def is_telescope_connected(self) -> bool:
+        """Check fake telescope connection."""
+        return self._telescope_connected
+
+    def is_camera_connected(self) -> bool:
+        """Check fake camera connection."""
+        return self._camera_connected
+
+    def list_devices(self) -> list[str]:
+        """Return list of fake devices."""
+        return ["Dummy Telescope", "Dummy Camera", "Dummy Filter Wheel", "Dummy Focuser"]
+
+    def select_telescope(self, device_name: str) -> bool:
+        """Simulate telescope selection."""
+        self.logger.info(f"DummyAdapter: Selected telescope '{device_name}'")
+        self._telescope_connected = True
+        return True
+
+    def _do_point_telescope(self, ra: float, dec: float):
+        """Simulate telescope slew."""
+        self.logger.info(f"DummyAdapter: Slewing to RA={ra:.4f}°, Dec={dec:.4f}°")
+        self._is_moving = True
+        self._simulate_delay()
+        self._current_ra = ra
+        self._current_dec = dec
+        self._is_moving = False
+        self.logger.info("DummyAdapter: Slew complete")
+
+    def get_telescope_direction(self) -> tuple[float, float]:
+        """Return current fake telescope position."""
+        return (self._current_ra, self._current_dec)
+
+    def telescope_is_moving(self) -> bool:
+        """Check if fake telescope is moving."""
+        return self._is_moving
+
+    def select_camera(self, device_name: str) -> bool:
+        """Simulate camera selection."""
+        self.logger.info(f"DummyAdapter: Selected camera '{device_name}'")
+        self._camera_connected = True
+        return True
+
+    def take_image(self, task_id: str, exposure_duration_seconds=1.0) -> str:
+        """Simulate image capture."""
+        self.logger.info(f"DummyAdapter: Starting {exposure_duration_seconds}s exposure for task {task_id}")
+        self._simulate_delay(exposure_duration_seconds)
+
+        # Create dummy image file
+        timestamp = int(time.time())
+        filename = f"dummy_{task_id}_{timestamp}.fits"
+        filepath = self.images_dir / filename
+
+        # Create empty file to simulate image
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        filepath.write_text(f"DUMMY FITS IMAGE\nTask: {task_id}\nExposure: {exposure_duration_seconds}s\n")
+
+        self.logger.info(f"DummyAdapter: Image saved to {filepath}")
+        return str(filepath)
+
+    def set_custom_tracking_rate(self, ra_rate: float, dec_rate: float):
+        """Simulate setting tracking rate."""
+        self.logger.info(f"DummyAdapter: Setting tracking rate RA={ra_rate} arcsec/s, Dec={dec_rate} arcsec/s")
+        self._tracking_rate = (ra_rate, dec_rate)
+
+    def get_tracking_rate(self) -> tuple[float, float]:
+        """Return current fake tracking rate."""
+        return self._tracking_rate
+
+    def perform_alignment(self, target_ra: float, target_dec: float) -> bool:
+        """Simulate plate solving alignment."""
+        self.logger.info(f"DummyAdapter: Performing alignment to RA={target_ra}°, Dec={target_dec}°")
+        self._simulate_delay()
+        # Simulate small correction
+        self._current_ra = target_ra + 0.001
+        self._current_dec = target_dec + 0.001
+        self.logger.info("DummyAdapter: Alignment successful")
+        return True
+
+    def supports_autofocus(self) -> bool:
+        """Dummy adapter supports autofocus."""
+        return True
+
+    def do_autofocus(self) -> None:
+        """Simulate autofocus routine."""
+        self.logger.info("DummyAdapter: Starting autofocus...")
+        self._simulate_delay(3.0)
+        self.logger.info("DummyAdapter: Autofocus complete")
+
+    def supports_filter_management(self) -> bool:
+        """Dummy adapter supports filter management."""
+        return True
+
+    def supports_direct_camera_control(self) -> bool:
+        """Dummy adapter supports direct camera control."""
+        return True
+
+    def expose_camera(self, exposure_seconds: float = 1.0) -> str:
+        """Simulate manual camera exposure."""
+        return self.take_image("manual_test", exposure_seconds)
+
+    def _simulate_delay(self, override_delay: float = None):
+        """Add artificial delay if slow simulation is enabled."""
+        if self.simulate_slow:
+            delay = override_delay if override_delay is not None else self.slow_delay
+            time.sleep(delay)

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/time/__init__.py

@@ -2,12 +2,13 @@
 
 from citrascope.time.time_health import TimeHealth, TimeStatus
 from citrascope.time.time_monitor import TimeMonitor
-from citrascope.time.time_sources import AbstractTimeSource, NTPTimeSource
+from citrascope.time.time_sources import AbstractTimeSource, ChronyTimeSource, NTPTimeSource
 
 __all__ = [
     "TimeHealth",
     "TimeStatus",
     "TimeMonitor",
     "AbstractTimeSource",
+    "ChronyTimeSource",
     "NTPTimeSource",
 ]

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/time/time_health.py

@@ -24,11 +24,14 @@ class TimeHealth:
     """Current time sync status level."""
 
     source: str
-    """Time source used (ntp, unknown)."""
+    """Time source used (ntp, gps, chrony, unknown)."""
 
     message: Optional[str] = None
     """Optional status message or error description."""
 
+    metadata: Optional[dict] = None
+    """Optional metadata (e.g., GPS satellite count, fix mode)."""
+
     @staticmethod
     def calculate_status(
         offset_ms: Optional[float],
@@ -61,6 +64,7 @@ class TimeHealth:
         source: str,
         pause_threshold: float,
         message: Optional[str] = None,
+        metadata: Optional[dict] = None,
     ) -> "TimeHealth":
         """
         Create TimeHealth from offset and pause threshold.
@@ -70,6 +74,7 @@ class TimeHealth:
             source: Time source identifier
             pause_threshold: Threshold that triggers task pause
             message: Optional status message
+            metadata: Optional metadata dict
 
         Returns:
             TimeHealth instance
@@ -80,6 +85,7 @@ class TimeHealth:
             status=status,
             source=source,
             message=message,
+            metadata=metadata,
         )
 
     def should_pause_observations(self) -> bool:
@@ -93,4 +99,5 @@ class TimeHealth:
             "status": self.status.value,
             "source": self.source,
             "message": self.message,
+            "metadata": self.metadata,
         }

{citrascope-0.8.0 → citrascope-0.9.1}/citrascope/time/time_monitor.py

@@ -6,7 +6,7 @@ from typing import Callable, Optional
 
 from citrascope.logging import CITRASCOPE_LOGGER
 from citrascope.time.time_health import TimeHealth, TimeStatus
-from citrascope.time.time_sources import AbstractTimeSource, NTPTimeSource
+from citrascope.time.time_sources import AbstractTimeSource, ChronyTimeSource, NTPTimeSource
 
 
 class TimeMonitor:
@@ -36,9 +36,8 @@ class TimeMonitor:
         self.pause_threshold_ms = pause_threshold_ms
         self.pause_callback = pause_callback
 
-        # Initialize NTP time source
-        self.time_source: AbstractTimeSource = NTPTimeSource()
-        CITRASCOPE_LOGGER.info("Time monitor initialized with NTP source")
+        # Detect and initialize best available time source
+        self.time_source: AbstractTimeSource = self._detect_best_source()
 
         # Thread control
         self._stop_event = threading.Event()
@@ -76,6 +75,25 @@ class TimeMonitor:
         with self._lock:
             return self._current_health
 
+    def _detect_best_source(self) -> AbstractTimeSource:
+        """
+        Detect and return the best available time source.
+
+        Priority order: Chrony > NTP
+
+        Returns:
+            The best available time source instance.
+        """
+        # Try ChronyTimeSource
+        chrony_source = ChronyTimeSource()
+        if chrony_source.is_available():
+            CITRASCOPE_LOGGER.info("Time monitor initialized with Chrony source")
+            return chrony_source
+
+        # Fall back to NTP
+        CITRASCOPE_LOGGER.info("Time monitor initialized with NTP source")
+        return NTPTimeSource()
+
     def _monitor_loop(self) -> None:
         """Main monitoring loop (runs in background thread)."""
         # Perform initial check immediately
@@ -94,14 +112,18 @@ class TimeMonitor:
     def _check_time_sync(self) -> None:
         """Perform a single time synchronization check."""
         try:
-            # Query NTP for offset
+            # Query time source for offset
             offset_ms = self.time_source.get_offset_ms()
 
+            # Get metadata if available (e.g., GPS satellite info)
+            metadata = self.time_source.get_metadata()
+
             # Calculate health status
             health = TimeHealth.from_offset(
                 offset_ms=offset_ms,
                 source=self.time_source.get_source_name(),
                 pause_threshold=self.pause_threshold_ms,
+                metadata=metadata,
             )
 
             # Store current health (thread-safe)