citrascope 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

citrascope/time/time_sources.py

@@ -1,11 +1,14 @@
 """Time source implementations for CitraScope."""
 
+import subprocess
 import time
 from abc import ABC, abstractmethod
 from typing import Optional
 
 import ntplib
 
+from citrascope.logging import CITRASCOPE_LOGGER
+
 
 class AbstractTimeSource(ABC):
     """Abstract base class for time sources."""
@@ -25,6 +28,15 @@ class AbstractTimeSource(ABC):
         """Get the name of this time source."""
         pass
 
+    def get_metadata(self) -> Optional[dict]:
+        """
+        Get optional metadata about the time source.
+
+        Returns:
+            Dictionary with metadata, or None if not applicable.
+        """
+        return None
+
 
 class NTPTimeSource(AbstractTimeSource):
     """NTP-based time source using pool.ntp.org."""
@@ -60,3 +72,190 @@ class NTPTimeSource(AbstractTimeSource):
     def get_source_name(self) -> str:
         """Get the name of this time source."""
         return "ntp"
+
+
+def _get_gpsd_metadata() -> Optional[dict]:
+    """
+    Query gpsd for satellite count and fix quality using gpspipe command.
+
+    Returns:
+        Dictionary with 'satellites' and 'fix_mode' keys, or None if unavailable.
+    """
+    try:
+        import json
+
+        # Use gpspipe to get JSON output from gpsd (cleaner than sockets)
+        # Request 10 messages to ensure we get both TPV (fix mode) and SKY (satellite count)
+        result = subprocess.run(
+            ["gpspipe", "-w", "-n", "10"],
+            capture_output=True,
+            timeout=3,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            return None
+
+        # Parse JSON lines to extract TPV (fix mode) and SKY (satellite count)
+        fix_mode = 0
+        satellites = 0
+
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+
+            try:
+                data = json.loads(line)
+                msg_class = data.get("class")
+
+                # Extract fix mode from TPV message
+                if msg_class == "TPV" and "mode" in data:
+                    fix_mode = data["mode"]
+
+                # Extract satellite count from SKY message
+                if msg_class == "SKY":
+                    # Prefer uSat (used satellites) if available
+                    if "uSat" in data:
+                        satellites = data["uSat"]
+                    # Fall back to counting satellites array
+                    elif "satellites" in data:
+                        satellites = len([s for s in data["satellites"] if s.get("used", False)])
+
+            except json.JSONDecodeError:
+                continue
+
+        return {"satellites": satellites, "fix_mode": fix_mode}
+
+    except (FileNotFoundError, OSError):
+        # gpspipe not available or gpsd not running
+        return None
+    except Exception as e:
+        CITRASCOPE_LOGGER.debug(f"Could not query gpsd: {e}")
+        return None
+
+
+class ChronyTimeSource(AbstractTimeSource):
+    """Chrony-based time source that detects GPS references."""
+
+    def __init__(self, timeout: int = 5):
+        """
+        Initialize Chrony time source.
+
+        Args:
+            timeout: Command timeout in seconds
+        """
+        self.timeout = timeout
+        self._gps_metadata: Optional[dict] = None
+        self._source_name: str = "chrony"
+
+    def is_available(self) -> bool:
+        """
+        Check if chrony is available and running.
+
+        Returns:
+            True if chronyc command succeeds, False otherwise.
+        """
+        try:
+            result = subprocess.run(
+                ["chronyc", "-c", "tracking"],
+                capture_output=True,
+                timeout=self.timeout,
+                text=True,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def get_offset_ms(self) -> Optional[float]:
+        """
+        Query chrony for clock offset and detect GPS reference.
+
+        Returns:
+            Clock offset in milliseconds, or None if query fails.
+        """
+        try:
+            # Get tracking info for offset
+            tracking_result = subprocess.run(
+                ["chronyc", "-c", "tracking"],
+                capture_output=True,
+                timeout=self.timeout,
+                text=True,
+                check=True,
+            )
+
+            # Parse CSV output: field index 4 is "System time" in seconds
+            tracking_fields = tracking_result.stdout.strip().split(",")
+            if len(tracking_fields) > 4:
+                offset_seconds = float(tracking_fields[4])
+                offset_ms = offset_seconds * 1000.0
+            else:
+                return None
+
+            # Get sources to detect GPS reference
+            sources_result = subprocess.run(
+                ["chronyc", "-c", "sources"],
+                capture_output=True,
+                timeout=self.timeout,
+                text=True,
+                check=True,
+            )
+
+            # Parse sources to detect GPS
+            gps_detected = False
+            for line in sources_result.stdout.strip().split("\n"):
+                if not line:
+                    continue
+
+                fields = line.split(",")
+                if len(fields) < 3:
+                    continue
+
+                mode = fields[0]  # '#' = local reference
+                state = fields[1]  # '*' = currently selected
+                name = fields[2].upper()
+
+                # Check if this is a selected GPS reference
+                if "*" in state and "#" in mode:
+                    # Check for GPS-related names
+                    gps_keywords = ["GPS", "SHM", "PPS", "SOCK", "NMEA"]
+                    if any(keyword in name for keyword in gps_keywords):
+                        gps_detected = True
+                        break
+
+            # If GPS detected, query gpsd for metadata
+            if gps_detected:
+                self._source_name = "gps"
+                CITRASCOPE_LOGGER.info("GPS reference detected in chrony sources")
+                self._gps_metadata = _get_gpsd_metadata()
+                if self._gps_metadata:
+                    CITRASCOPE_LOGGER.info(
+                        f"GPS lock acquired: {self._gps_metadata['satellites']} satellites, "
+                        f"fix mode {self._gps_metadata['fix_mode']}"
+                    )
+                else:
+                    CITRASCOPE_LOGGER.warning(
+                        "GPS reference active in chrony but gpsd metadata unavailable "
+                        "(gpsd/gpspipe may not be available)"
+                    )
+            else:
+                self._source_name = "chrony"
+                self._gps_metadata = None
+                CITRASCOPE_LOGGER.warning("No GPS reference detected in chrony sources - using NTP/other time source")
+
+            return offset_ms
+
+        except Exception:
+            return None
+
+    def get_source_name(self) -> str:
+        """Get the name of this time source."""
+        return self._source_name
+
+    def get_metadata(self) -> Optional[dict]:
+        """
+        Get GPS metadata if available.
+
+        Returns:
+            Dictionary with GPS metadata, or None.
+        """
+        return self._gps_metadata

citrascope/web/app.py

@@ -8,10 +8,11 @@ from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel
 
 from citrascope.constants import (
@@ -28,6 +29,7 @@ class SystemStatus(BaseModel):
 
     telescope_connected: bool = False
     camera_connected: bool = False
+    supports_direct_camera_control: bool = False
     current_task: Optional[str] = None
     tasks_pending: int = 0
     processing_active: bool = True
@@ -126,6 +128,16 @@ class CitraScopeWebApp:
         if static_dir.exists():
             self.app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
 
+        # Mount images directory for camera captures (read-only access)
+        if daemon and hasattr(daemon, "settings"):
+            images_dir = daemon.settings.get_images_dir()
+            if images_dir.exists():
+                self.app.mount("/images", StaticFiles(directory=str(images_dir)), name="images")
+
+        # Initialize Jinja2 templates
+        templates_dir = Path(__file__).parent / "templates"
+        self.templates = Jinja2Templates(directory=str(templates_dir))
+
         # Register routes
         self._setup_routes()
 
@@ -137,15 +149,9 @@ class CitraScopeWebApp:
         """Setup all API routes."""
 
         @self.app.get("/", response_class=HTMLResponse)
-        async def root():
+        async def root(request: Request):
             """Serve the main dashboard page."""
-            template_path = Path(__file__).parent / "templates" / "dashboard.html"
-            if template_path.exists():
-                return template_path.read_text()
-            else:
-                return HTMLResponse(
-                    content="<h1>CitraScope Dashboard</h1><p>Template file not found</p>", status_code=500
-                )
+            return self.templates.TemplateResponse("dashboard.html", {"request": request})
 
         @self.app.get("/api/status")
         async def get_status():
@@ -185,6 +191,8 @@ class CitraScopeWebApp:
                 "adapter_settings": settings._all_adapter_settings,
                 "log_level": settings.log_level,
                 "keep_images": settings.keep_images,
+                "file_logging_enabled": settings.file_logging_enabled,
+                "log_retention_days": settings.log_retention_days,
                 "max_task_retries": settings.max_task_retries,
                 "initial_retry_delay_seconds": settings.initial_retry_delay_seconds,
                 "max_retry_delay_seconds": settings.max_retry_delay_seconds,
@@ -633,6 +641,12 @@ class CitraScopeWebApp:
             if not self.daemon.hardware_adapter:
                 return JSONResponse({"error": "Hardware adapter not available"}, status_code=503)
 
+            # Check if adapter supports direct camera control
+            if not self.daemon.hardware_adapter.supports_direct_camera_control():
+                return JSONResponse(
+                    {"error": "Hardware adapter does not support direct camera control"}, status_code=400
+                )
+
             try:
                 duration = request.get("duration", 0.1)
 
@@ -713,6 +727,14 @@ class CitraScopeWebApp:
                 except Exception:
                     self.status.camera_connected = False
 
+                # Check adapter capabilities
+                try:
+                    self.status.supports_direct_camera_control = (
+                        self.daemon.hardware_adapter.supports_direct_camera_control()
+                    )
+                except Exception:
+                    self.status.supports_direct_camera_control = False
+
             if hasattr(self.daemon, "task_manager") and self.daemon.task_manager:
                 task_manager = self.daemon.task_manager
                 self.status.current_task = task_manager.current_task_id