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

citrascope/hardware/devices/device_registry.py

@@ -0,0 +1,273 @@
+"""Device adapter registry.
+
+This module provides a centralized registry for all device adapters.
+Similar to the hardware adapter registry, but for individual device types.
+"""
+
+import importlib
+from typing import Any, Dict, Type
+
+from citrascope.hardware.devices.camera import AbstractCamera
+from citrascope.hardware.devices.filter_wheel import AbstractFilterWheel
+from citrascope.hardware.devices.focuser import AbstractFocuser
+from citrascope.hardware.devices.mount import AbstractMount
+
+# Registry of available camera devices
+CAMERA_DEVICES: Dict[str, Dict[str, str]] = {
+    "ximea": {
+        "module": "citrascope.hardware.devices.camera.ximea_camera",
+        "class_name": "XimeaHyperspectralCamera",
+        "description": "Ximea Hyperspectral Camera (MQ series)",
+    },
+    "rpi_hq": {
+        "module": "citrascope.hardware.devices.camera.rpi_hq_camera",
+        "class_name": "RaspberryPiHQCamera",
+        "description": "Raspberry Pi High Quality Camera (IMX477)",
+    },
+    "usb_camera": {
+        "module": "citrascope.hardware.devices.camera.usb_camera",
+        "class_name": "UsbCamera",
+        "description": "USB Camera via OpenCV (guide cameras, planetary cameras, etc.)",
+    },
+    # Future cameras:
+    # "zwo": {...},
+    # "ascom": {...},
+    # "qhy": {...},
+}
+
+# Registry of available mount devices
+MOUNT_DEVICES: Dict[str, Dict[str, str]] = {
+    # Future mounts:
+    # "celestron": {...},
+    # "skywatcher": {...},
+    # "ascom": {...},
+}
+
+# Registry of available filter wheel devices
+FILTER_WHEEL_DEVICES: Dict[str, Dict[str, str]] = {
+    # Future filter wheels:
+    # "zwo": {...},
+    # "ascom": {...},
+}
+
+# Registry of available focuser devices
+FOCUSER_DEVICES: Dict[str, Dict[str, str]] = {
+    # Future focusers:
+    # "moonlite": {...},
+    # "ascom": {...},
+}
+
+
+def get_camera_class(camera_type: str) -> Type[AbstractCamera]:
+    """Get the camera class for the given camera type.
+
+    Args:
+        camera_type: The type of camera (e.g., "ximea", "zwo")
+
+    Returns:
+        The camera adapter class
+
+    Raises:
+        ValueError: If the camera type is not registered
+        ImportError: If the camera module cannot be imported
+    """
+    if camera_type not in CAMERA_DEVICES:
+        available = ", ".join(f"'{name}'" for name in CAMERA_DEVICES.keys())
+        raise ValueError(f"Unknown camera type: '{camera_type}'. Valid options are: {available}")
+
+    device_info = CAMERA_DEVICES[camera_type]
+    module = importlib.import_module(device_info["module"])
+    device_class = getattr(module, device_info["class_name"])
+
+    return device_class
+
+
+def get_mount_class(mount_type: str) -> Type[AbstractMount]:
+    """Get the mount class for the given mount type.
+
+    Args:
+        mount_type: The type of mount
+
+    Returns:
+        The mount adapter class
+
+    Raises:
+        ValueError: If the mount type is not registered
+        ImportError: If the mount module cannot be imported
+    """
+    if mount_type not in MOUNT_DEVICES:
+        available = ", ".join(f"'{name}'" for name in MOUNT_DEVICES.keys())
+        raise ValueError(f"Unknown mount type: '{mount_type}'. Valid options are: {available}")
+
+    device_info = MOUNT_DEVICES[mount_type]
+    module = importlib.import_module(device_info["module"])
+    device_class = getattr(module, device_info["class_name"])
+
+    return device_class
+
+
+def get_filter_wheel_class(filter_wheel_type: str) -> Type[AbstractFilterWheel]:
+    """Get the filter wheel class for the given filter wheel type.
+
+    Args:
+        filter_wheel_type: The type of filter wheel
+
+    Returns:
+        The filter wheel adapter class
+
+    Raises:
+        ValueError: If the filter wheel type is not registered
+        ImportError: If the filter wheel module cannot be imported
+    """
+    if filter_wheel_type not in FILTER_WHEEL_DEVICES:
+        available = ", ".join(f"'{name}'" for name in FILTER_WHEEL_DEVICES.keys())
+        raise ValueError(f"Unknown filter wheel type: '{filter_wheel_type}'. Valid options are: {available}")
+
+    device_info = FILTER_WHEEL_DEVICES[filter_wheel_type]
+    module = importlib.import_module(device_info["module"])
+    device_class = getattr(module, device_info["class_name"])
+
+    return device_class
+
+
+def get_focuser_class(focuser_type: str) -> Type[AbstractFocuser]:
+    """Get the focuser class for the given focuser type.
+
+    Args:
+        focuser_type: The type of focuser
+
+    Returns:
+        The focuser adapter class
+
+    Raises:
+        ValueError: If the focuser type is not registered
+        ImportError: If the focuser module cannot be imported
+    """
+    if focuser_type not in FOCUSER_DEVICES:
+        available = ", ".join(f"'{name}'" for name in FOCUSER_DEVICES.keys())
+        raise ValueError(f"Unknown focuser type: '{focuser_type}'. Valid options are: {available}")
+
+    device_info = FOCUSER_DEVICES[focuser_type]
+    module = importlib.import_module(device_info["module"])
+    device_class = getattr(module, device_info["class_name"])
+
+    return device_class
+
+
+def list_devices(device_type: str) -> Dict[str, Dict[str, str]]:
+    """Get a dictionary of all registered devices of a specific type.
+
+    Args:
+        device_type: Type of device ("camera", "mount", "filter_wheel", "focuser")
+
+    Returns:
+        Dict mapping device names to their info including friendly_name
+    """
+    registries = {
+        "camera": CAMERA_DEVICES,
+        "mount": MOUNT_DEVICES,
+        "filter_wheel": FILTER_WHEEL_DEVICES,
+        "focuser": FOCUSER_DEVICES,
+    }
+
+    registry = registries.get(device_type, {})
+    result = {}
+
+    for name, info in registry.items():
+        # Try to get friendly name from device class
+        try:
+            if device_type == "camera":
+                device_class = get_camera_class(name)
+            elif device_type == "mount":
+                device_class = get_mount_class(name)
+            elif device_type == "filter_wheel":
+                device_class = get_filter_wheel_class(name)
+            elif device_type == "focuser":
+                device_class = get_focuser_class(name)
+            else:
+                continue
+
+            friendly_name = device_class.get_friendly_name()
+        except Exception:
+            # Fallback to description if friendly_name not available
+            friendly_name = info["description"]
+
+        result[name] = {
+            "friendly_name": friendly_name,
+            "description": info["description"],
+            "module": info["module"],
+            "class_name": info["class_name"],
+        }
+
+    return result
+
+
+def get_device_schema(device_type: str, device_name: str) -> list:
+    """Get the configuration schema for a specific device.
+
+    Args:
+        device_type: Type of device ("camera", "mount", "filter_wheel", "focuser")
+        device_name: The name of the device (e.g., "ximea", "celestron")
+
+    Returns:
+        The device's settings schema
+
+    Raises:
+        ValueError: If the device type or name is not registered
+        ImportError: If the device module cannot be imported
+    """
+    if device_type == "camera":
+        device_class = get_camera_class(device_name)
+    elif device_type == "mount":
+        device_class = get_mount_class(device_name)
+    elif device_type == "filter_wheel":
+        device_class = get_filter_wheel_class(device_name)
+    elif device_type == "focuser":
+        device_class = get_focuser_class(device_name)
+    else:
+        raise ValueError(f"Unknown device type: '{device_type}'")
+
+    return device_class.get_settings_schema()
+
+
+def check_dependencies(device_class: Type[Any]) -> dict[str, Any]:
+    """Check if dependencies for a device are available.
+
+    Args:
+        device_class: Device class to check
+
+    Returns:
+        Dict with keys:
+            - available (bool): True if all dependencies installed
+            - missing (list[str]): List of missing package names
+            - install_cmd (str): Command to install missing packages
+    """
+    import time
+
+    start_time = time.time()
+
+    deps = device_class.get_dependencies()
+    packages = deps.get("packages", [])
+    install_extra = deps.get("install_extra", "")
+
+    missing = []
+    for package in packages:
+        try:
+            importlib.import_module(package)
+        except ImportError:
+            missing.append(package)
+
+    available = len(missing) == 0
+    install_cmd = f"pip install citrascope[{install_extra}]" if install_extra else f"pip install {' '.join(missing)}"
+
+    elapsed = time.time() - start_time
+    if elapsed > 0.05:  # Log if takes more than 50ms
+        from citrascope.logging import CITRASCOPE_LOGGER
+
+        CITRASCOPE_LOGGER.info(f"Dependency check for {device_class.__name__} took {elapsed:.3f}s")
+
+    return {
+        "available": available,
+        "missing": missing,
+        "install_cmd": install_cmd,
+    }

citrascope/hardware/devices/filter_wheel/__init__.py

@@ -0,0 +1,7 @@
+"""Filter wheel device adapters."""
+
+from citrascope.hardware.devices.filter_wheel.abstract_filter_wheel import AbstractFilterWheel
+
+__all__ = [
+    "AbstractFilterWheel",
+]

citrascope/hardware/devices/filter_wheel/abstract_filter_wheel.py

@@ -0,0 +1,73 @@
+"""Abstract filter wheel device interface."""
+
+from abc import abstractmethod
+from typing import Optional
+
+from citrascope.hardware.devices.abstract_hardware_device import AbstractHardwareDevice
+
+
+class AbstractFilterWheel(AbstractHardwareDevice):
+    """Abstract base class for filter wheel devices.
+
+    Provides a common interface for controlling motorized filter wheels.
+    """
+
+    @abstractmethod
+    def set_filter_position(self, position: int) -> bool:
+        """Move to specified filter position.
+
+        Args:
+            position: Filter position (0-indexed)
+
+        Returns:
+            True if move initiated successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def get_filter_position(self) -> Optional[int]:
+        """Get current filter position.
+
+        Returns:
+            Current filter position (0-indexed), or None if unavailable
+        """
+        pass
+
+    @abstractmethod
+    def is_moving(self) -> bool:
+        """Check if filter wheel is currently moving.
+
+        Returns:
+            True if moving, False if stationary
+        """
+        pass
+
+    @abstractmethod
+    def get_filter_count(self) -> int:
+        """Get the number of filter positions.
+
+        Returns:
+            Number of available filter positions
+        """
+        pass
+
+    @abstractmethod
+    def get_filter_names(self) -> list[str]:
+        """Get the names of all filters.
+
+        Returns:
+            List of filter names for each position
+        """
+        pass
+
+    @abstractmethod
+    def set_filter_names(self, names: list[str]) -> bool:
+        """Set the names for all filter positions.
+
+        Args:
+            names: List of filter names (must match filter count)
+
+        Returns:
+            True if names set successfully, False otherwise
+        """
+        pass

citrascope/hardware/devices/focuser/__init__.py

@@ -0,0 +1,7 @@
+"""Focuser device adapters."""
+
+from citrascope.hardware.devices.focuser.abstract_focuser import AbstractFocuser
+
+__all__ = [
+    "AbstractFocuser",
+]

citrascope/hardware/devices/focuser/abstract_focuser.py

@@ -0,0 +1,78 @@
+"""Abstract focuser device interface."""
+
+from abc import abstractmethod
+from typing import Optional
+
+from citrascope.hardware.devices.abstract_hardware_device import AbstractHardwareDevice
+
+
+class AbstractFocuser(AbstractHardwareDevice):
+    """Abstract base class for focuser devices.
+
+    Provides a common interface for controlling motorized focusers.
+    """
+
+    @abstractmethod
+    def move_absolute(self, position: int) -> bool:
+        """Move to absolute focuser position.
+
+        Args:
+            position: Target position in steps
+
+        Returns:
+            True if move initiated successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def move_relative(self, steps: int) -> bool:
+        """Move focuser by relative number of steps.
+
+        Args:
+            steps: Number of steps to move (positive=outward, negative=inward)
+
+        Returns:
+            True if move initiated successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def get_position(self) -> Optional[int]:
+        """Get current focuser position.
+
+        Returns:
+            Current position in steps, or None if unavailable
+        """
+        pass
+
+    @abstractmethod
+    def is_moving(self) -> bool:
+        """Check if focuser is currently moving.
+
+        Returns:
+            True if moving, False if stationary
+        """
+        pass
+
+    @abstractmethod
+    def abort_move(self):
+        """Stop the current focuser movement."""
+        pass
+
+    @abstractmethod
+    def get_max_position(self) -> Optional[int]:
+        """Get the maximum focuser position.
+
+        Returns:
+            Maximum position in steps, or None if unlimited/unknown
+        """
+        pass
+
+    @abstractmethod
+    def get_temperature(self) -> Optional[float]:
+        """Get focuser temperature reading if available.
+
+        Returns:
+            Temperature in degrees Celsius, or None if not available
+        """
+        pass

citrascope/hardware/devices/mount/__init__.py

@@ -0,0 +1,7 @@
+"""Mount device adapters."""
+
+from citrascope.hardware.devices.mount.abstract_mount import AbstractMount
+
+__all__ = [
+    "AbstractMount",
+]

citrascope/hardware/devices/mount/abstract_mount.py

@@ -0,0 +1,115 @@
+"""Abstract mount device interface."""
+
+from abc import abstractmethod
+from typing import Optional, Tuple
+
+from citrascope.hardware.devices.abstract_hardware_device import AbstractHardwareDevice
+
+
+class AbstractMount(AbstractHardwareDevice):
+    """Abstract base class for telescope mount devices.
+
+    Provides a common interface for controlling equatorial and alt-az mounts.
+    """
+
+    @abstractmethod
+    def slew_to_radec(self, ra: float, dec: float) -> bool:
+        """Slew the mount to specified RA/Dec coordinates.
+
+        Args:
+            ra: Right Ascension in degrees
+            dec: Declination in degrees
+
+        Returns:
+            True if slew initiated successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def is_slewing(self) -> bool:
+        """Check if mount is currently slewing.
+
+        Returns:
+            True if slewing, False if stationary or tracking
+        """
+        pass
+
+    @abstractmethod
+    def abort_slew(self):
+        """Stop the current slew operation."""
+        pass
+
+    @abstractmethod
+    def get_radec(self) -> Tuple[float, float]:
+        """Get current mount RA/Dec position.
+
+        Returns:
+            Tuple of (RA in degrees, Dec in degrees)
+        """
+        pass
+
+    @abstractmethod
+    def start_tracking(self, rate: Optional[str] = "sidereal") -> bool:
+        """Start tracking at specified rate.
+
+        Args:
+            rate: Tracking rate - "sidereal", "lunar", "solar", or device-specific
+
+        Returns:
+            True if tracking started successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def stop_tracking(self) -> bool:
+        """Stop tracking.
+
+        Returns:
+            True if tracking stopped successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def is_tracking(self) -> bool:
+        """Check if mount is currently tracking.
+
+        Returns:
+            True if tracking, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def park(self) -> bool:
+        """Park the mount to its home position.
+
+        Returns:
+            True if park initiated successfully, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def unpark(self) -> bool:
+        """Unpark the mount from its home position.
+
+        Returns:
+            True if unpark successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def is_parked(self) -> bool:
+        """Check if mount is parked.
+
+        Returns:
+            True if parked, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def get_mount_info(self) -> dict:
+        """Get mount capabilities and information.
+
+        Returns:
+            Dictionary containing mount specs and capabilities
+        """
+        pass