pyninaapiio 0.0.3__tar.gz → 0.0.5__tar.gz

{pyninaapiio-0.0.3 → pyninaapiio-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyninaapiio
-Version: 0.0.3
+Version: 0.0.5
 Summary: Python Wrapper for N.I.N.A. Advanced API
 Home-page: https://github.com/mawinkler/pyninaapiio
 Author: Markus Winkler
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.13
 License-File: LICENSE
 Requires-Dist: httpx
 Requires-Dist: attrs
+Requires-Dist: typeguard
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

pyninaapiio-0.0.5/pyninaapiio/dataclasses.py

@@ -0,0 +1,427 @@
+"""Defines the Data Classes used."""
+
+# import math
+# from dataclasses import dataclass
+# from datetime import datetime
+# from pprint import pprint as pp
+from typing import Any, Optional, TypedDict
+
+from typeguard import typechecked
+
+from pyninaapiio.models.guider_info_response_last_guide_step import GuiderInfoResponseLastGuideStep
+from pyninaapiio.models.guider_info_response_rms_error import GuiderInfoResponseRMSError
+from pyninaapiio.models.guider_info_response_state import GuiderInfoResponseState
+
+
+# #########################################################################
+# Application
+# #########################################################################
+class ApplicationDataModel(TypedDict, total=False):
+    Dummy: int
+
+
+class ApplicationData:
+    def __init__(self, *, data: ApplicationDataModel):
+        self.dummy = data.get("Dummy")
+
+
+# #########################################################################
+# Camera
+# #########################################################################
+class CameraDataModel(TypedDict, total=False):
+    TargetTemp: float
+    AtTargetTemp: bool
+    CanSetTemperature: bool
+    HasShutter: bool
+    Temperature: int
+    Gain: int
+    DefaultGain: int
+    ElectronsPerADU: int
+    BinX: int
+    BitDepth: int
+    BinY: int
+    CanSetOffset: bool
+    CanGetGain: bool
+    OffsetMin: int
+    OffsetMax: int
+    Offset: int
+    DefaultOffset: int
+    USBLimit: int
+    IsSubSampleEnabled: bool
+    CameraState: str
+    XSize: int
+    YSize: int
+    PixelSize: int
+    Battery: int
+    GainMin: int
+    GainMax: int
+    CanSetGain: bool
+    Gains: list[Any]
+    CoolerOn: bool
+    CoolerPower: int
+    HasDewHeater: bool
+    DewHeaterOn: bool
+    CanSubSample: bool
+    SubSampleX: int
+    SubSampleY: int
+    SubSampleWidth: int
+    SubSampleHeight: int
+    TemperatureSetPoint: int
+    ReadoutModes: str
+    ReadoutMode: int
+    ReadoutModeForSnapImages: int
+    ReadoutModeForNormalImages: int
+    IsExposing: bool
+    ExposureEndTime: str
+    LastDownloadTime: int
+    SensorType: str
+    BayerOffsetX: int
+    BayerOffsetY: int
+    BinningModes: list[Any]
+    ExposureMax: int
+    ExposureMin: int
+    LiveViewEnabled: bool
+    CanShowLiveView: bool
+    SupportedActions: str
+    CanSetUSBLimit: bool
+    USBLimitMin: int
+    USBLimitMax: int
+    Connected: bool
+    Name: str
+    DisplayName: str
+    DeviceId: str
+
+
+class CameraData:
+    def __init__(self, *, data: CameraDataModel):
+        self.target_temp = data.get("TargetTemp")
+        self.at_target_temp = data.get("AtTargetTemp")
+        self.can_set_temperature = data.get("CanSetTemperature")
+        self.has_shutter = data.get("HasShutter")
+        self.temperature = data.get("Temperature")
+        self.gain = data.get("Gain")
+        self.default_gain = data.get("DefaultGain")
+        self.electrons_per_adu = data.get("ElectronsPerADU")
+        self.bin_x = data.get("BinX")
+        self.bit_depth = data.get("BitDepth")
+        self.bin_y = data.get("BinY")
+        self.can_set_offset = data.get("CanSetOffset")
+        self.can_get_gain = data.get("CanGetGain")
+        self.offset_min = data.get("OffsetMin")
+        self.offset_max = data.get("OffsetMax")
+        self.offset = data.get("Offset")
+        self.default_offset = data.get("DefaultOffset")
+        self.usb_limit = data.get("USBLimit")
+        self.is_sub_sample_enabled = data.get("IsSubSampleEnabled")
+        self.camera_state = data.get("CameraState")
+        self.x_size = data.get("XSize")
+        self.y_size = data.get("YSize")
+        self.pixel_size = data.get("PixelSize")
+        self.battery = data.get("Battery")
+        self.gain_min = data.get("GainMin")
+        self.gain_max = data.get("GainMax")
+        self.can_set_gain = data.get("CanSetGain")
+        self.gains = data.get("Gains")
+        self.cooler_on = data.get("CoolerOn")
+        self.cooler_power = data.get("CoolerPower")
+        self.has_dew_heater = data.get("HasDewHeater")
+        self.dew_heater_on = data.get("DewHeaterOn")
+        self.can_sub_sample = data.get("CanSubSample")
+        self.sub_sample_x = data.get("SubSampleX")
+        self.sub_sample_y = data.get("SubSampleY")
+        self.sub_sample_width = data.get("SubSampleWidth")
+        self.sub_sample_height = data.get("SubSampleHeight")
+        self.temperature_set_point = data.get("TemperatureSetPoint")
+        self.readout_modes = data.get("ReadoutModes")
+        self.readout_mode = data.get("ReadoutMode")
+        self.readout_mode_for_snap_images = data.get("ReadoutModeForSnapImages")
+        self.readout_mode_for_normal_images = data.get("ReadoutModeForNormalImages")
+        self.is_exposing = data.get("IsExposing")
+        self.exposure_end_time = data.get("ExposureEndTime")
+        self.last_download_time = data.get("LastDownloadTime")
+        self.sensor_type = data.get("SensorType")
+        self.bayer_offset_x = data.get("BayerOffsetX")
+        self.bayer_offset_y = data.get("BayerOffsetY")
+        self.binning_modes = data.get("BinningModes")
+        self.exposure_max = data.get("ExposureMax")
+        self.exposure_min = data.get("ExposureMin")
+        self.live_view_enabled = data.get("LiveViewEnabled")
+        self.can_show_live_view = data.get("CanShowLiveView")
+        self.supported_actions = data.get("SupportedActions")
+        self.can_set_usb_limit = data.get("CanSetUSBLimit")
+        self.usb_limit_min = data.get("USBLimitMin")
+        self.usb_limit_max = data.get("USBLimitMax")
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.device_id = data.get("DeviceId")
+
+
+# #########################################################################
+# Focuser
+# #########################################################################
+class FocuserDataModel(TypedDict, total=False):
+    Position: int
+    StepSize: int
+    Temperature: float
+    IsMoving: bool
+    IsSettling: bool
+    TempComp: bool
+    TempCompAvailable: bool
+    SupportedActions: list[Any]
+    Connected: bool
+    Name: str
+    DisplayName: str
+    Description: str
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+
+
+class FocuserData:
+    def __init__(self, *, data: FocuserDataModel):
+        self.position = data.get("Position")
+        self.step_size = data.get("StepSize")
+        self.temperature = data.get("Temperature")
+        self.is_moving = data.get("IsMoving")
+        self.is_settling = data.get("IsSettling")
+        self.temp_comp = data.get("TempComp")
+        self.temp_comp_available = data.get("TempCompAvailable")
+        self.supported_actions = data.get("SupportedActions")
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
+
+
+# #########################################################################
+# Guider
+# #########################################################################
+class GuiderDataModel(TypedDict, total=False):
+    Connected: bool
+    CanClearCalibration: bool
+    CanSetShiftRate: bool
+    CanGetLockPosition: bool
+    PixelScale: float
+    Name: str
+    DisplayName: str
+    Description: str
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+    SupportedActions: list[Any]
+    RMSError: GuiderInfoResponseRMSError
+    LastGuideStep: Optional[GuiderInfoResponseLastGuideStep]
+    State: GuiderInfoResponseState
+
+
+class GuiderData:
+    def __init__(self, *, data: GuiderDataModel):
+        self.connected = data.get("Connected")
+        self.can_clear_calibration = data.get("CanClearCalibration")
+        self.can_set_shift_rate = data.get("CanSetShiftRate")
+        self.can_get_lock_position = data.get("CanGetLockPosition")
+        self.pixel_scale = data.get("PixelScale")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
+        self.supported_actions = data.get("SupportedActions")
+        self.rms_error = data.get("RMSError")
+        self.last_guide_step = data.get("LastGuideStep")
+        self.state = data.get("State")
+
+
+# #########################################################################
+# Image
+# #########################################################################
+class ImageDataModel(TypedDict, total=False):
+    DecodedData: bytes
+    IndexLatest: int
+
+
+class ImageData:
+    def __init__(self, *, data: ImageDataModel):
+        self.decoded_data = data.get("DecodedData")
+        self.index_latest = data.get("IndexLatest")
+
+
+# #########################################################################
+# Mount
+# #########################################################################
+class DeviceMountListDataModel(TypedDict):
+    items: dict
+
+
+@typechecked
+class DeviceMountListData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: DeviceMountListDataModel):
+        self.items = data.get("items")
+
+
+class DeviceMountDataModel(TypedDict):
+    HasSetupDialog: bool
+    Id: str
+    Name: str
+    DisplayName: str
+    Category: str
+    Connected: bool
+    Description: str
+    DriverInfo: str
+    DriverVersion: str
+    SupportedActions: list
+    # additional_properties: dict
+
+
+@typechecked
+class DeviceMountData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: DeviceMountDataModel):
+        self.has_setup_dialog = data.get("HasSetupDialog")
+        self.id = data.get("Id")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.category = data.get("Category")
+        self.connected = data.get("Connected")
+        self.description = data.get("Description")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.supported_actions = data.get("SupportedActions")
+        # self.additional_properties = data.get("additional_properties")
+
+
+class MountDataModel(TypedDict):
+    connected: bool
+    name: str
+    display_name: str
+    device_id: str
+    sidereal_time: float
+    right_ascension: float
+    declination: float
+    site_latitude: float
+    site_longitude: float
+    site_elevation: float
+
+
+@typechecked
+class MountData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: MountDataModel):
+        self.connected = data.get("connected")
+        self.name = data.get("name")
+        self.display_name = data.get("display_name")
+        self.device_id = data.get("device_id")
+        self.sidereal_time = data.get("sidereal_time")
+        self.right_ascension = data.get("right_ascension")
+        self.declination = data.get("declination")
+        self.site_latitude = data.get("site_latitude")
+        self.site_longitude = data.get("site_longitude")
+        self.site_elevation = data.get("site_elevation")
+
+
+# #########################################################################
+# Switch
+# #########################################################################
+class SwitchPortDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    Maximum: Optional[int]
+    Minimum: Optional[int]
+    StepSize: Optional[int]
+    TargetValue: Optional[int]
+    Id: int
+    Name: str
+    Description: str
+    Value: float
+
+
+@typechecked
+class SwitchPortData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: SwitchPortDataModel):
+        self.maximum = data.get("Maximum")
+        self.minimum = data.get("Minimum")
+        self.step_size = data.get("StepSize")
+        self.target_value = data.get("TargetValue")
+        self.id = data.get("Id")
+        self.name = data.get("Name")
+        self.description = data.get("Description")
+        self.value = data.get("Value")
+
+
+class SwitchDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    WritableSwitches: Optional[list[SwitchPortDataModel]]
+    ReadonlySwitches: Optional[list[SwitchPortDataModel]]
+    SupportedActions: list[str]
+    Connected: bool
+    Name: str
+    DisplayName: str
+    Description: str
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+
+
+@typechecked
+class SwitchData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: SwitchDataModel):
+        self.writable_switches = data.get("WritableSwitches")
+        self.readonly_switches = data.get("ReadonlySwitches")
+        self.supported_actions = data.get("SupportedActions")
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
+
+
+# #########################################################################
+# N.I.N.A. Devices
+# #########################################################################
+class NinaDevicesDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    # Application: Optional[ApplicationData]
+    Camera: Optional[CameraData]
+    # Dome: Optional[DomeData]
+    # FilterWheel: Optional[FilterWheelData]
+    # FlatPanel: Optional[FlatPanelData]
+    Focuser: Optional[FocuserData]
+    Guider: Optional[GuiderData]
+    Image: Optional[ImageData]
+    Mount: Optional[MountData]
+    # Profile: Optional[ProfileData]
+    # Rotator: Optional[RotatorData]
+    # SafetyMonitor: Optional[SafetyMonitorData]
+    # Sequence: Optional[SequenceData]
+    Switch: Optional[SwitchData]
+
+
+@typechecked
+class NinaDevicesData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: NinaDevicesDataModel):
+        # self.application = data.get("Application")
+        self.camera = data["Camera"]
+        self.focuser = data["Focuser"]
+        self.guider = data["Guider"]
+        self.image = data["Image"]
+        self.mount = data["Mount"]
+        self.switch = data["Switch"]

pyninaapiio-0.0.5/pyninaapiio/nina.py

@@ -0,0 +1,254 @@
+# import asyncio
+import base64
+
+# import io
+import logging
+import sys
+from pprint import pprint as pp
+
+from pyninaapiio.api.camera import get_equipment_camera_info
+from pyninaapiio.api.focuser import get_equipment_focuser_info
+from pyninaapiio.api.guider import get_equipment_guider_info
+from pyninaapiio.api.image import get_image_history, get_image_index
+from pyninaapiio.api.mount import get_equipment_mount_info, get_equipment_mount_list_devices
+from pyninaapiio.api.switch import get_equipment_switch_info
+from pyninaapiio.client import Client
+from pyninaapiio.dataclasses import (
+    ApplicationData,
+    ApplicationDataModel,
+    CameraData,
+    CameraDataModel,
+    # CameraData,
+    # CameraDataModel,
+    DeviceMountData,
+    DeviceMountDataModel,
+    FocuserData,
+    FocuserDataModel,
+    GuiderData,
+    GuiderDataModel,
+    ImageData,
+    ImageDataModel,
+    # DeviceMountListData,
+    # DeviceMountListDataModel,
+    MountData,
+    MountDataModel,
+    NinaDevicesData,
+    NinaDevicesDataModel,
+    SwitchData,
+    # SwitchPortData,
+    # SwitchPortDataModel,
+    SwitchDataModel,
+)
+from pyninaapiio.models.camera_info import CameraInfo
+from pyninaapiio.models.device_list import DeviceList
+
+# from pyninaapiio.models.device_list_response_item import DeviceListResponseItem
+from pyninaapiio.models.focuser_info import FocuserInfo
+from pyninaapiio.models.get_image_history_response_200 import GetImageHistoryResponse200
+
+# from pyninaapiio.models.get_image_index_bayer_pattern import GetImageIndexBayerPattern
+from pyninaapiio.models.get_image_index_response_200 import GetImageIndexResponse200
+from pyninaapiio.models.guider_info import GuiderInfo
+from pyninaapiio.models.mount_info import MountInfo
+from pyninaapiio.models.switch_info import SwitchInfo
+from pyninaapiio.types import Response
+
+_LOGGER = logging.getLogger(__name__)
+logging.basicConfig(
+    stream=sys.stdout,
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s (%(threadName)s) [%(funcName)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+
+
+# async with client as client:
+class NinaAPI:
+    def __init__(
+        self,
+        # session: Optional[ClientSession] = None,
+        session=None,
+        base_url="http://192.168.1.234:1888/v2/api",
+        # application_enabled=False,
+        camera_enabled=False,
+        focuser_enabled=False,
+        guider_enabled=False,
+        image_enabled=False,
+        mount_enabled=False,
+        switch_enabled=False,
+    ):
+        self._session = session
+        self._client = Client(base_url=base_url)
+        # self._application_enabled = application_enabled
+        self._camera_enabled = camera_enabled
+        self._focuser_enabled = focuser_enabled
+        self._guider_enabled = guider_enabled
+        self._image_enabled = image_enabled
+        self._mount_enabled = mount_enabled
+        self._switch_enabled = switch_enabled
+
+        # Save last capture
+        self._image_index_latest = -1
+        self._image_data = None
+
+        return None
+
+    # #########################################################################
+    # Application
+    # #########################################################################
+    # async def application_info(self):
+    #     try:
+    #         _LOGGER.debug(f"Retrieve application info")
+    #         _application_info: Response[ApplicationInfo] = await get_equipment_application_info.asyncio(
+    #             client=self._client
+    #         )
+    #         print(_application_info.response)
+    #         _application_info_data = ApplicationDataModel(_application_info.response.to_dict())
+
+    #         return ApplicationData(data=_application_info_data)
+
+    #     except KeyError as ke:
+    #         _LOGGER.warning(f"Application not connected. {ke}")
+
+    # #########################################################################
+    # Camera
+    # #########################################################################
+    async def camera_info(self):
+        try:
+            _LOGGER.debug(f"Retrieve camera info")
+            _camera_info: Response[CameraInfo] = await get_equipment_camera_info.asyncio(client=self._client)
+            print(_camera_info.response)
+            _camera_info_data = CameraDataModel(_camera_info.response.to_dict())
+
+            return CameraData(data=_camera_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Camera not connected. {ke}")
+
+    # #########################################################################
+    # Focuser
+    # #########################################################################
+    async def focuser_info(self):
+        try:
+            _LOGGER.debug(f"Retrieve focuser info")
+            _focuser_info: Response[FocuserInfo] = await get_equipment_focuser_info.asyncio(client=self._client)
+            print(_focuser_info.response)
+            _focuser_info_data = FocuserDataModel(_focuser_info.response.to_dict())
+
+            return FocuserData(data=_focuser_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Focuser not connected. {ke}")
+
+    # #########################################################################
+    # Guider
+    # #########################################################################
+    async def guider_info(self):
+        try:
+            _LOGGER.debug(f"Retrieve guider info")
+            _guider_info: Response[GuiderInfo] = await get_equipment_guider_info.asyncio(client=self._client)
+            print(_guider_info.response)
+            _guider_info_data = GuiderDataModel(_guider_info.response.to_dict())
+
+            return GuiderData(data=_guider_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Guider not connected. {ke}")
+
+    # #########################################################################
+    # Image
+    # #########################################################################
+    async def image_latest(self):
+        _LOGGER.debug(f"Retrieve index of last capture")
+        image_history: GetImageHistoryResponse200 = await get_image_history.asyncio(client=self._client, count=True)
+        image_index_latest = image_history.response - 1
+
+        if image_index_latest > self._image_index_latest:
+            self._image_index_latest = image_index_latest
+
+            _LOGGER.debug(f"Retrieve capture with index {image_index_latest}")
+            image: GetImageIndexResponse200 = await get_image_index.asyncio(
+                index=image_index_latest, client=self._client
+            )  # , debayer=True, bayer_pattern=GetImageIndexBayerPattern.RGGB)
+            if image.success:
+                image_data = base64.b64decode(image.response)
+                self._image_data = image_data
+            else:
+                _LOGGER.error(f"{image.error}")
+        else:
+            _LOGGER.debug(f"Returning previous capture with index {self._image_index_latest}")
+
+        _LOGGER.debug(f"Capture Index: {self._image_index_latest}")
+        _camera_data = ImageDataModel({"DecodedData": self._image_data, "IndexLatest": self._image_index_latest})
+        return ImageData(data=_camera_data)
+
+    # #########################################################################
+    # Mount
+    # #########################################################################
+    async def mount_list_devices(self):
+        items = []
+
+        try:
+            _list_devices: Response[DeviceList] = await get_equipment_mount_list_devices.asyncio(client=self._client)
+
+            for _, device in enumerate(_list_devices.response):
+                item = DeviceMountDataModel(device.to_dict())
+
+                try:
+                    items.append(DeviceMountData(data=item))
+                except TypeError as ve:
+                    _LOGGER.error(f"Failed to parse device data model data: {item}")
+                    _LOGGER.error(ve)
+        except KeyError as ke:
+            _LOGGER.error(f"KeyError: {ke}")
+
+        return items
+
+    async def mount_info(self):
+        try:
+            _LOGGER.debug(f"Retrieve mount info")
+            _mount_info: Response[MountInfo] = await get_equipment_mount_info.asyncio(client=self._client)
+            _mount_info_data = MountDataModel(_mount_info.response.to_dict())
+
+            return MountData(data=_mount_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Mount not connected. {ke}")
+
+    # #########################################################################
+    # Switch
+    # #########################################################################
+    async def switch_info(self):
+        try:
+            _LOGGER.debug(f"Retrieve switch info")
+            _switch_info: Response[SwitchInfo] = await get_equipment_switch_info.asyncio(client=self._client)
+            _switch_info_data = SwitchDataModel(_switch_info.response.to_dict())
+
+            return SwitchData(data=_switch_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Switch not connected. {ke}")
+
+    # #########################################################################
+    # Nina
+    # #########################################################################
+    async def nina_info(
+        self,
+    ):
+        try:
+            _LOGGER.debug(f"Retrieve nina info")
+            _nina = {
+                # "Application": await self.application_info() if application_enabled else None,
+                "Camera": await self.camera_info() if self._camera_enabled else None,
+                "Focuser": await self.focuser_info() if self._focuser_enabled else None,
+                "Guider": await self.guider_info() if self._guider_enabled else None,
+                "Image": await self.image_latest() if self._image_enabled else None,
+                "Mount": await self.mount_info() if self._mount_enabled else None,
+                "Switch": await self.switch_info() if self._switch_enabled else None,
+            }
+            _nina_info_data = NinaDevicesDataModel(_nina)
+
+            return NinaDevicesData(data=_nina_info_data)
+
+        except KeyError as ke:
+            _LOGGER.warning(f"Nina not connected. {ke}")