pyninaapiio 0.0.14__tar.gz → 0.0.16__tar.gz

{pyninaapiio-0.0.14 → pyninaapiio-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyninaapiio
-Version: 0.0.14
+Version: 0.0.16
 Summary: Python Wrapper for N.I.N.A. Advanced API
 Home-page: https://github.com/mawinkler/pyninaapiio
 Author: Markus Winkler

{pyninaapiio-0.0.14 → pyninaapiio-0.0.16}/pyninaapiio/dataclasses.py

@@ -9,6 +9,7 @@ from typing import Any, Optional, TypedDict
 
 from typeguard import typechecked
 
+from .advanced_api_client.models.dome_info_response_shutter_status import DomeInfoResponseShutterStatus
 from .advanced_api_client.models.fw_info_response_available_filters_item import (
     FWInfoResponseAvailableFiltersItem,
 )
@@ -43,10 +44,12 @@ class ApplicationDataModel(TypedDict, total=False):
     Version: str
 
 
+@typechecked
 class ApplicationData:
     def __init__(self, *, data: ApplicationDataModel):
         self.version = data.get("Version")
         self.connected = data.get("Connected")
+        # self.screenshot
 
 
 # #########################################################################
@@ -78,10 +81,10 @@ class CameraDataModel(TypedDict, total=False):
     DefaultOffset: int
     DeviceId: str
     DewHeaterOn: bool
-    ElectronsPerADU: int
+    ElectronsPerADU: int | Any
     ExposureEndTime: str
-    ExposureMax: int
-    ExposureMin: int
+    ExposureMax: int | Any
+    ExposureMin: int | Any
     Gain: int
     GainMax: int
     GainMin: int
@@ -95,17 +98,17 @@ class CameraDataModel(TypedDict, total=False):
     Offset: int
     OffsetMax: int
     OffsetMin: int
-    PixelSize: int
-    ReadoutMode: str
-    ReadoutModeForNormalImages: int
-    ReadoutModeForSnapImages: int
-    ReadoutModes: str
+    PixelSize: int | Any
+    ReadoutMode: int | str
+    ReadoutModeForNormalImages: int | str
+    ReadoutModeForSnapImages: int | str
+    ReadoutModes: list[str]
     SensorType: str
     SubSampleHeight: int
     SubSampleWidth: int
     SubSampleX: int
     SubSampleY: int
-    SupportedActions: str
+    SupportedActions: list[str]
     TargetTemp: float
     Temperature: int
     TemperatureSetPoint: int
@@ -116,6 +119,7 @@ class CameraDataModel(TypedDict, total=False):
     YSize: int
 
 
+@typechecked
 class CameraData:
     def __init__(self, *, data: CameraDataModel):
         self.connected = data.get("Connected")
@@ -161,9 +165,21 @@ class CameraData:
         self.offset_max = data.get("OffsetMax")
         self.offset_min = data.get("OffsetMin")
         self.pixel_size = data.get("PixelSize")
-        self.readout_mode = data.get("ReadoutModes")[data.get("ReadoutMode")]
-        self.readout_mode_for_normal_images = data.get("ReadoutModes")[data.get("ReadoutModeForNormalImages")]
-        self.readout_mode_for_snap_images = data.get("ReadoutModes")[data.get("ReadoutModeForSnapImages")]
+        self.readout_mode = (
+            data.get("ReadoutModes")[data.get("ReadoutMode")]
+            if data.get("ReadoutMode") is not None and data.get("ReadoutModes") is not None
+            else None
+        )
+        self.readout_mode_for_normal_images = (
+            data.get("ReadoutModes")[data.get("ReadoutModeForNormalImages")]
+            if data.get("ReadoutModeForNormalImages") is not None and data.get("ReadoutModes") is not None
+            else None
+        )
+        self.readout_mode_for_snap_images = (
+            data.get("ReadoutModes")[data.get("ReadoutModeForSnapImages")]
+            if data.get("ReadoutModeForSnapImages") is not None and data.get("ReadoutModes") is not None
+            else None
+        )
         self.readout_modes = data.get("ReadoutModes")
         self.sensor_type = data.get("SensorType")
         self.sub_sample_height = data.get("SubSampleHeight")
@@ -181,6 +197,73 @@ class CameraData:
         self.y_size = data.get("YSize")
 
 
+# #########################################################################
+# Dome
+# #########################################################################
+class DomeDataModel(TypedDict, total=False):
+    Connected: bool
+    Name: str | Unset
+    DisplayName: str | Unset
+    Description: str
+    Altitude: float | str
+    AltitudeDMS: str
+    ApplicationFollowing: bool
+    AtHome: bool
+    AtPark: bool
+    Azimuth: float | str
+    AzimuthDMS: str
+    CanFindHome: bool
+    CanPark: bool
+    CanSetAzimuth: bool
+    CanSetPark: bool
+    CanSetShutter: bool
+    CanSyncAzimuth: bool
+    DeviceId: str
+    DriverCanFollow: bool
+    DriverFollowing: bool
+    DriverInfo: str
+    DriverVersion: str
+    FollowingType: str
+    IsFollowing: bool
+    IsSynchronized: bool
+    ShutterStatus: str  # DomeInfoResponseShutterStatus
+    Slewing: bool
+    SupportedActions: list[Any]
+
+
+@typechecked
+class DomeData:
+    def __init__(self, *, data: DomeDataModel):
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+        self.altitude = data.get("Altitude")
+        self.altitude_dms = data.get("AltitudeDMS")
+        self.application_following = data.get("ApplicationFollowing")
+        self.at_home = data.get("AtHome")
+        self.at_park = data.get("AtPark")
+        self.azimuth = data.get("Azimuth")
+        self.azimuth_dms = data.get("AzimuthDMS")
+        self.can_find_home = data.get("CanFindHome")
+        self.can_park = data.get("CanPark")
+        self.can_set_azimuth = data.get("CanSetAzimuth")
+        self.can_set_park = data.get("CanSetPark")
+        self.can_set_shutter = data.get("CanSetShutter")
+        self.can_sync_azimuth = data.get("CanSyncAzimuth")
+        self.device_id = data.get("DeviceId")
+        self.driver_can_follow = data.get("DriverCanFollow")
+        self.driver_following = data.get("DriverFollowing")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.following_type = data.get("FollowingType")
+        self.is_following = data.get("IsFollowing")
+        self.is_synchronized = data.get("IsSynchronized")
+        self.shutter_status = data.get("ShutterStatus")
+        self.slewing = data.get("Slewing")
+        self.supported_actions = data.get("SupportedActions")
+
+
 # #########################################################################
 # FilterWheel
 # #########################################################################
@@ -188,16 +271,17 @@ class FilterWheelDataModel(TypedDict, total=False):
     Connected: bool
     Name: str | Unset
     DisplayName: str | Unset
-    AvailableFilters: list[FWInfoResponseAvailableFiltersItem]
+    AvailableFilters: list[Any]
     Description: str
     DeviceId: str
     DriverInfo: str
     DriverVersion: str
     IsMoving: bool
-    SelectedFilter: FWInfoResponseSelectedFilter
+    SelectedFilter: Any  # FWInfoResponseSelectedFilter
     SupportedActions: list[Any]
 
 
+@typechecked
 class FilterWheelData:
     def __init__(self, *, data: FilterWheelDataModel):
         self.connected = data.get("Connected")
@@ -214,11 +298,11 @@ class FilterWheelData:
 
     @property
     def selected_filter_id(self) -> int:
-        return self.selected_filter.get("Id")
+        return self.selected_filter.get("Id") if self.selected_filter is not None else -1
 
     @property
     def selected_filter_name(self) -> str:
-        return self.selected_filter.get("Name")
+        return self.selected_filter.get("Name") if self.selected_filter is not None else ""
 
 
 # #########################################################################
@@ -242,6 +326,7 @@ class FocuserDataModel(TypedDict, total=False):
     Temperature: float
 
 
+@typechecked
 class FocuserData:
     def __init__(self, *, data: FocuserDataModel):
         self.connected = data.get("Connected")
@@ -277,11 +362,12 @@ class GuiderDataModel(TypedDict, total=False):
     DriverVersion: str
     LastGuideStep: Optional[GuiderInfoResponseLastGuideStep]
     PixelScale: float
-    RMSError: GuiderInfoResponseRMSError
-    State: GuiderInfoResponseState
+    RMSError: Any  # GuiderInfoResponseRMSError
+    State: Any  # GuiderInfoResponseState
     SupportedActions: list[Any]
 
 
+@typechecked
 class GuiderData:
     def __init__(self, *, data: GuiderDataModel):
         self.connected = data.get("Connected")
@@ -302,31 +388,31 @@ class GuiderData:
 
     @property
     def last_guide_step_ra(self) -> float:
-        return self.last_guide_step.get("RADistanceRaw")
+        return self.last_guide_step.get("RADistanceRaw") if self.last_guide_step is not None else 0
 
     @property
     def last_guide_step_dec(self) -> float:
-        return self.last_guide_step.get("DECDistanceRaw")
+        return self.last_guide_step.get("DECDistanceRaw") if self.last_guide_step is not None else 0
 
     @property
     def rms_error_ra_arcsec(self) -> float:
-        return self.rms_error.get("RA").get("Arcseconds")
+        return self.rms_error.get("RA").get("Arcseconds") if self.rms_error is not None else 0
 
     @property
     def rms_error_ra_peak_arcsec(self) -> float:
-        return self.rms_error.get("PeakRA").get("Arcseconds")
+        return self.rms_error.get("PeakRA").get("Arcseconds") if self.rms_error is not None else 0
 
     @property
     def rms_error_dec_arcsec(self) -> float:
-        return self.rms_error.get("Dec").get("Arcseconds")
+        return self.rms_error.get("Dec").get("Arcseconds") if self.rms_error is not None else 0
 
     @property
     def rms_error_dec_peak_arcsec(self) -> float:
-        return self.rms_error.get("PeakDec").get("Arcseconds")
+        return self.rms_error.get("PeakDec").get("Arcseconds") if self.rms_error is not None else 0
 
     @property
     def rms_error_total_arcsec(self) -> float:
-        return self.rms_error.get("Total").get("Arcseconds")
+        return self.rms_error.get("Total").get("Arcseconds") if self.rms_error is not None else 0
 
 
 # #########################################################################
@@ -356,6 +442,7 @@ class ImageDataModel(TypedDict, total=False):
     Temperature: float
 
 
+@typechecked
 class ImageData:
     def __init__(self, *, data: ImageDataModel):
         self.connected = data.get("Connected")
@@ -473,6 +560,7 @@ class MountDataModel(TypedDict, total=False):
     SiteLongitude: float
     Slewing: bool
     SupportedActions: list[str]
+    TargetCoordinates: Any
     TimeToMeridianFlip: float
     TimeToMeridianFlipString: str
     TrackingEnabled: bool
@@ -490,11 +578,17 @@ class MountData:
         self.name = data.get("Name")
         self.display_name = data.get("DisplayName")
         self.alignment_mode = data.get("AlignmentMode")
-        self.altitude = round(data.get("Altitude"), 3) if data.get("Altitude") is not None else None
+        self.altitude = (
+            round(data.get("Altitude"), 3)
+            if data.get("Altitude") is not None and data.get("Altitude") != "NaN"
+            else None
+        )
         self.altitude_string = data.get("AltitudeString")
         self.at_home = data.get("AtHome")
         self.at_park = data.get("AtPark")
-        self.azimuth = round(data.get("Azimuth"), 3) if data.get("Azimuth") is not None else None
+        self.azimuth = (
+            round(data.get("Azimuth"), 3) if data.get("Azimuth") is not None and data.get("Azimuth") != "NaN" else None
+        )
         self.azimuth_string = data.get("AzimuthString")
         self.can_find_home = data.get("CanFindHome")
         self.can_move_primary_axis = data.get("CanMovePrimaryAxis")
@@ -529,6 +623,7 @@ class MountData:
         self.site_longitude = round(data.get("SiteLongitude"), 3) if data.get("SiteLongitude") is not None else None
         self.slewing = data.get("Slewing")
         self.supported_actions = data.get("SupportedActions")
+        self.target_coordinates = data.get("TargetCoordinates")
         self.time_to_meridian_flip = data.get("TimeToMeridianFlip")
         self.time_to_meridian_flip_string = data.get("TimeToMeridianFlipString")
         self.tracking_enabled = data.get("TrackingEnabled")
@@ -538,19 +633,119 @@ class MountData:
 
     @property
     def coordinates_ra(self) -> float:
-        return round(self.coordinates.get("RA"), 3) if self.coordinates.get("RA") is not None else None
+        return (
+            round(self.coordinates.get("RA"), 3)
+            if self.coordinates is not None and self.coordinates.get("RA") is not None
+            else 0
+        )
 
     @property
     def coordinates_ra_str(self) -> str:
-        return self.coordinates.get("RAString")
+        return (
+            self.coordinates.get("RAString")
+            if self.coordinates is not None and self.coordinates.get("RAString") is not None
+            else ""
+        )
 
     @property
     def coordinates_dec(self) -> float:
-        return round(self.coordinates.get("Dec"), 3) if self.coordinates.get("Dec") is not None else None
+        return (
+            round(self.coordinates.get("Dec"), 3)
+            if self.coordinates is not None and self.coordinates.get("Dec") is not None
+            else 0
+        )
 
     @property
     def coordinates_dec_str(self) -> str:
-        return self.coordinates.get("DecString")
+        return (
+            self.coordinates.get("DecString")
+            if self.coordinates is not None and self.coordinates.get("DecString") is not None
+            else ""
+        )
+
+
+# #########################################################################
+# Rotator
+# #########################################################################
+class RotatorDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    Connected: bool
+    Name: str
+    DisplayName: str
+    Description: str
+
+    CanReverse: bool
+    Reverse: bool
+    MechanicalPosition: int
+    Position: int
+    StepSize: float
+    IsMoving: bool
+    Synced: bool
+    SupportedActions: list[Any]
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+    AdditionalProperties: dict[str, Any]
+
+
+@typechecked
+class RotatorData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: RotatorDataModel):
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+
+        self.can_reverse = data.get("CanReverse")
+        self.reverse = data.get("Reverse")
+        self.mechanical_position = data.get("MechanicalPosition")
+        self.position = data.get("Position")
+        self.step_size = data.get("StepSize")
+        self.is_moving = data.get("IsMoving")
+        self.synced = data.get("Synced")
+        self.supported_actions = data.get("SupportedActions")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
+        self.additional_properties = data.get("Name")
+
+
+# #########################################################################
+# SafetyMonitor
+# #########################################################################
+class SafetyMonitorDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    Connected: bool
+    Name: str
+    DisplayName: str
+    Description: str
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+
+    IsSafe: bool
+    SupportedActions: list[Any]
+
+
+@typechecked
+class SafetyMonitorData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: SafetyMonitorDataModel):
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+
+        self.is_safe = data.get("IsSafe")
+        self.supported_actions = data.get("SupportedActions")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
 
 
 # #########################################################################
@@ -616,6 +811,66 @@ class SwitchData:
         self.writable_switches = data.get("WritableSwitches")
 
 
+# #########################################################################
+# Weather
+# #########################################################################
+class WeatherDataModel(TypedDict, total=False):
+    # device_list_response_item
+
+    Connected: bool
+    Name: str
+    DisplayName: str
+    Description: str
+
+    AveragePeriod: int
+    CloudCover: int
+    DewPoint: float
+    Humidity: int
+    Pressure: float
+    RainRate: float
+    SkyBrightness: str
+    SkyQuality: str
+    SkyTemperature: str
+    StarFWHM: str
+    Temperature: float
+    WindDirection: int
+    WindGust: float
+    WindSpeed: float
+    SupportedActions: list[str]
+    DriverInfo: str
+    DriverVersion: str
+    DeviceId: str
+
+
+@typechecked
+class WeatherData:
+    """A representation of the geographic location."""
+
+    def __init__(self, *, data: WeatherDataModel):
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.description = data.get("Description")
+        self.average_period = data.get("AveragePeriod")
+        self.cloud_cover = data.get("CloudCover")
+        self.dew_point = round(data.get("DewPoint"), 1) if data.get("DewPoint") is not None else None
+        self.humidity = data.get("Humidity")
+        self.pressure = round(data.get("Pressure"), 1) if data.get("Pressure") is not None else None
+        self.rain_rate = round(data.get("RainRate"), 1) if data.get("RainRate") is not None else None
+        self.sky_brightness = data.get("SkyBrightness")
+        self.sky_quality = data.get("SkyQuality")
+        self.sky_temperature = data.get("SkyTemperature")
+        self.star_fwhm = data.get("StarFWHM")
+        self.temperature = round(data.get("Temperature"), 1) if data.get("Temperature") is not None else None
+        self.wind_direction = data.get("WindDirection")
+        self.wind_gust = round(data.get("WindGust"), 1) if data.get("WindGust") is not None else None
+        self.wind_speed = round(data.get("WindSpeed"), 1) if data.get("WindSpeed") is not None else None
+        self.supported_actions = data.get("SupportedActions")
+        self.driver_info = data.get("DriverInfo")
+        self.driver_version = data.get("DriverVersion")
+        self.device_id = data.get("DeviceId")
+
+
 # #########################################################################
 # N.I.N.A. Devices
 # #########################################################################
@@ -625,7 +880,7 @@ class NinaDevicesDataModel(TypedDict, total=False):
     Connected: bool
     Application: Optional[ApplicationData]
     Camera: Optional[CameraData]
-    # Dome: Optional[DomeData]
+    Dome: Optional[DomeData]
     FilterWheel: Optional[FilterWheelData]
     # FlatPanel: Optional[FlatPanelData]
     Focuser: Optional[FocuserData]
@@ -633,10 +888,11 @@ class NinaDevicesDataModel(TypedDict, total=False):
     Image: Optional[ImageData]
     Mount: Optional[MountData]
     # Profile: Optional[ProfileData]
-    # Rotator: Optional[RotatorData]
-    # SafetyMonitor: Optional[SafetyMonitorData]
+    Rotator: Optional[RotatorData]
+    SafetyMonitor: Optional[SafetyMonitorData]
     # Sequence: Optional[SequenceData]
     Switch: Optional[SwitchData]
+    Weather: Optional[WeatherData]
 
 
 @typechecked
@@ -647,9 +903,13 @@ class NinaDevicesData:
         self.connected = data.get("Connected")
         self.application = data.get("Application")
         self.camera = data.get("Camera")
+        self.dome = data.get("Dome")
         self.filterwheel = data.get("FilterWheel")
         self.focuser = data.get("Focuser")
         self.guider = data.get("Guider")
         self.image = data.get("Image")
         self.mount = data.get("Mount")
+        self.rotator = data.get("Rotator")
+        self.safety_monitor = data.get("SafetyMonitor")
         self.switch = data.get("Switch")
+        self.weather = data.get("Weather")