pyninaapiio 0.0.10__tar.gz → 0.0.12__tar.gz

{pyninaapiio-0.0.10 → pyninaapiio-0.0.12}/PKG-INFO

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

{pyninaapiio-0.0.10 → pyninaapiio-0.0.12}/pyninaapiio/dataclasses.py

@@ -32,6 +32,7 @@ from .advanced_api_client.models.mount_info_response_tracking_modes_item import
 )
 from .advanced_api_client.models.mount_info_response_tracking_rate import MountInfoResponseTrackingRate
 from .advanced_api_client.types import Unset
+from datetime import datetime
 
 
 # #########################################################################
@@ -52,162 +53,162 @@ class ApplicationData:
 # Camera
 # #########################################################################
 class CameraDataModel(TypedDict, total=False):
-    TargetTemp: float
+    Connected: bool
+    Name: str
+    DisplayName: str
     AtTargetTemp: bool
-    CanSetTemperature: bool
-    HasShutter: bool
-    Temperature: int
-    Gain: int
-    DefaultGain: int
-    ElectronsPerADU: int
+    Battery: int
+    BayerOffsetX: int
+    BayerOffsetY: int
+    BinningModes: list[Any]
     BinX: int
-    BitDepth: int
     BinY: int
-    CanSetOffset: bool
-    CanGetGain: bool
-    OffsetMin: int
-    OffsetMax: int
-    Offset: int
-    DefaultOffset: int
-    USBLimit: int
-    IsSubSampleEnabled: bool
+    BitDepth: int
     CameraState: str
-    XSize: int
-    YSize: int
-    PixelSize: int
-    Battery: int
-    GainMin: int
-    GainMax: int
+    CanGetGain: bool
     CanSetGain: bool
-    Gains: list[Any]
+    CanSetOffset: bool
+    CanSetTemperature: bool
+    CanSetUSBLimit: bool
+    CanShowLiveView: bool
+    CanSubSample: bool
     CoolerOn: bool
     CoolerPower: int
-    HasDewHeater: bool
+    DefaultGain: int
+    DefaultOffset: int
+    DeviceId: str
     DewHeaterOn: bool
-    CanSubSample: bool
-    SubSampleX: int
-    SubSampleY: int
-    SubSampleWidth: int
-    SubSampleHeight: int
-    TemperatureSetPoint: int
-    ReadoutModes: str
-    ReadoutMode: int
-    ReadoutModeForSnapImages: int
-    ReadoutModeForNormalImages: int
-    IsExposing: bool
+    ElectronsPerADU: int
     ExposureEndTime: str
-    LastDownloadTime: int
-    SensorType: str
-    BayerOffsetX: int
-    BayerOffsetY: int
-    BinningModes: list[Any]
     ExposureMax: int
     ExposureMin: int
+    Gain: int
+    GainMax: int
+    GainMin: int
+    Gains: list[Any]
+    HasDewHeater: bool
+    HasShutter: bool
+    IsExposing: bool
+    IsSubSampleEnabled: bool
+    LastDownloadTime: int
     LiveViewEnabled: bool
-    CanShowLiveView: bool
+    Offset: int
+    OffsetMax: int
+    OffsetMin: int
+    PixelSize: int
+    ReadoutMode: int
+    ReadoutModeForNormalImages: int
+    ReadoutModeForSnapImages: int
+    ReadoutModes: str
+    SensorType: str
+    SubSampleHeight: int
+    SubSampleWidth: int
+    SubSampleX: int
+    SubSampleY: int
     SupportedActions: str
-    CanSetUSBLimit: bool
-    USBLimitMin: int
+    TargetTemp: float
+    Temperature: int
+    TemperatureSetPoint: int
+    USBLimit: int
     USBLimitMax: int
-    Connected: bool
-    Name: str
-    DisplayName: str
-    DeviceId: str
+    USBLimitMin: int
+    XSize: int
+    YSize: int
 
 
 class CameraData:
     def __init__(self, *, data: CameraDataModel):
-        self.target_temp = data.get("TargetTemp")
+        self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
         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.battery = data.get("Battery")
+        self.bayer_offset_x = data.get("BayerOffsetX")
+        self.bayer_offset_y = data.get("BayerOffsetY")
         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.binning_modes = data.get("BinningModes")
+        self.bit_depth = data.get("BitDepth")
         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_get_gain = data.get("CanGetGain")
         self.can_set_gain = data.get("CanSetGain")
-        self.gains = data.get("Gains")
+        self.can_set_offset = data.get("CanSetOffset")
+        self.can_set_temperature = data.get("CanSetTemperature")
+        self.can_set_usb_limit = data.get("CanSetUSBLimit")
+        self.can_show_live_view = data.get("CanShowLiveView")
+        self.can_sub_sample = data.get("CanSubSample")
         self.cooler_on = data.get("CoolerOn")
         self.cooler_power = data.get("CoolerPower")
-        self.has_dew_heater = data.get("HasDewHeater")
+        self.default_gain = data.get("DefaultGain")
+        self.default_offset = data.get("DefaultOffset")
+        self.device_id = data.get("DeviceId")
         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.electrons_per_adu = data.get("ElectronsPerADU")
         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.gain = data.get("Gain")
+        self.gain_max = data.get("GainMax")
+        self.gain_min = data.get("GainMin")
+        self.gains = data.get("Gains")
+        self.has_dew_heater = data.get("HasDewHeater")
+        self.has_shutter = data.get("HasShutter")
+        self.is_exposing = data.get("IsExposing")
+        self.is_sub_sample_enabled = data.get("IsSubSampleEnabled")
+        self.last_download_time = data.get("LastDownloadTime")
         self.live_view_enabled = data.get("LiveViewEnabled")
-        self.can_show_live_view = data.get("CanShowLiveView")
+        self.offset = data.get("Offset")
+        self.offset_max = data.get("OffsetMax")
+        self.offset_min = data.get("OffsetMin")
+        self.pixel_size = data.get("PixelSize")
+        self.readout_mode = data.get("ReadoutMode")
+        self.readout_mode_for_normal_images = data.get("ReadoutModeForNormalImages")
+        self.readout_mode_for_snap_images = data.get("ReadoutModeForSnapImages")
+        self.readout_modes = data.get("ReadoutModes")
+        self.sensor_type = data.get("SensorType")
+        self.sub_sample_height = data.get("SubSampleHeight")
+        self.sub_sample_width = data.get("SubSampleWidth")
+        self.sub_sample_x = data.get("SubSampleX")
+        self.sub_sample_y = data.get("SubSampleY")
         self.supported_actions = data.get("SupportedActions")
-        self.can_set_usb_limit = data.get("CanSetUSBLimit")
-        self.usb_limit_min = data.get("USBLimitMin")
+        self.target_temp = data.get("TargetTemp")
+        self.temperature = data.get("Temperature")
+        self.temperature_set_point = data.get("TemperatureSetPoint")
+        self.usb_limit = data.get("USBLimit")
         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")
+        self.usb_limit_min = data.get("USBLimitMin")
+        self.x_size = data.get("XSize")
+        self.y_size = data.get("YSize")
 
 
 # #########################################################################
 # FilterWheel
 # #########################################################################
 class FilterWheelDataModel(TypedDict, total=False):
-    AvailableFilters: list[FWInfoResponseAvailableFiltersItem]
     Connected: bool
+    Name: str | Unset
+    DisplayName: str | Unset
+    AvailableFilters: list[FWInfoResponseAvailableFiltersItem]
     Description: str
     DeviceId: str
-    DisplayName: str | Unset
     DriverInfo: str
     DriverVersion: str
     IsMoving: bool
-    Name: str | Unset
     SelectedFilter: FWInfoResponseSelectedFilter
     SupportedActions: list[Any]
 
 
 class FilterWheelData:
     def __init__(self, *, data: FilterWheelDataModel):
-        self.available_filters = data.get("AvailableFilters")
         self.connected = data.get("Connected")
+        self.name = data.get("Name")
+        self.display_name = data.get("DisplayName")
+        self.available_filters = data.get("AvailableFilters")
         self.description = data.get("Description")
         self.device_id = data.get("DeviceId")
-        self.display_name = data.get("DisplayName")
         self.driver_info = data.get("DriverInfo")
         self.driver_version = data.get("DriverVersion")
         self.is_moving = data.get("IsMoving")
-        self.name = data.get("Name")
         self.selected_filter = data.get("SelectedFilter")
         self.supported_actions = data.get("SupportedActions")
 
@@ -224,40 +225,40 @@ class FilterWheelData:
 # 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 | Unset
     DisplayName: str | Unset
     Description: str
+    DeviceId: str
     DriverInfo: str
     DriverVersion: str
-    DeviceId: str
+    IsMoving: bool
+    IsSettling: bool
+    Position: int
+    StepSize: int
+    SupportedActions: list[Any]
+    TempComp: bool
+    TempCompAvailable: bool
+    Temperature: float
 
 
 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.device_id = data.get("DeviceId")
         self.driver_info = data.get("DriverInfo")
         self.driver_version = data.get("DriverVersion")
-        self.device_id = data.get("DeviceId")
+        self.is_moving = data.get("IsMoving")
+        self.is_settling = data.get("IsSettling")
+        self.position = data.get("Position")
+        self.step_size = data.get("StepSize")
+        self.supported_actions = data.get("SupportedActions")
+        self.temp_comp = data.get("TempComp")
+        self.temp_comp_available = data.get("TempCompAvailable")
+        self.temperature = data.get("Temperature")
 
 
 # #########################################################################
@@ -265,39 +266,39 @@ class FocuserData:
 # #########################################################################
 class GuiderDataModel(TypedDict, total=False):
     Connected: bool
-    CanClearCalibration: bool
-    CanSetShiftRate: bool
-    CanGetLockPosition: bool
-    PixelScale: float
     Name: str | Unset
     DisplayName: str
+    CanClearCalibration: bool
+    CanGetLockPosition: bool
+    CanSetShiftRate: bool
     Description: str
+    DeviceId: str
     DriverInfo: str
     DriverVersion: str
-    DeviceId: str
-    SupportedActions: list[Any]
-    RMSError: GuiderInfoResponseRMSError
     LastGuideStep: Optional[GuiderInfoResponseLastGuideStep]
+    PixelScale: float
+    RMSError: GuiderInfoResponseRMSError
     State: GuiderInfoResponseState
+    SupportedActions: list[Any]
 
 
 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.can_clear_calibration = data.get("CanClearCalibration")
+        self.can_get_lock_position = data.get("CanGetLockPosition")
+        self.can_set_shift_rate = data.get("CanSetShiftRate")
         self.description = data.get("Description")
+        self.device_id = data.get("DeviceId")
         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.pixel_scale = data.get("PixelScale")
+        self.rms_error = data.get("RMSError")
         self.state = data.get("State")
+        self.supported_actions = data.get("SupportedActions")
 
     @property
     def rms_error_ra_arcsec(self) -> float:
@@ -325,17 +326,51 @@ class GuiderData:
 # #########################################################################
 class ImageDataModel(TypedDict, total=False):
     Connected: bool
+    CameraName: str
+    Date: datetime
     DecodedData: bytes
     DecodedDataLength: int
+    ExposureTime: int
+    Filter: str
+    FocalLength: int
+    Gain: int
+    HFR: float
+    ImageType: str  # GetImageHistoryResponse200ResponseType0ItemImageType
     IndexLatest: int
+    IsBayered: bool
+    Mean: float
+    Median: float
+    Offset: int
+    RmsText: str
+    Stars: int
+    StDev: float
+    TelescopeName: str
+    Temperature: float
 
 
 class ImageData:
     def __init__(self, *, data: ImageDataModel):
         self.connected = data.get("Connected")
+        self.camera_name = data.get("CameraName")
+        self.date = data.get("Date")
         self.decoded_data = data.get("DecodedData")
         self.decoded_data_length = data.get("DecodedDataLength")
+        self.exposure_time = data.get("ExposureTime")
+        self.filter = data.get("Filter")
+        self.focal_length = data.get("FocalLength")
+        self.gain = data.get("Gain")
+        self.hfr = data.get("HFR")
+        self.image_type = data.get("ImageType")
         self.index_latest = data.get("IndexLatest")
+        self.is_bayered = data.get("IsBayered")
+        self.mean = data.get("Mean")
+        self.median = data.get("Median")
+        self.offset = data.get("Offset")
+        self.rms_text = data.get("RmsText")
+        self.st_dev = data.get("StDev")
+        self.stars = data.get("Stars")
+        self.telescope_name = data.get("TelescopeName")
+        self.temperature = data.get("Temperature")
 
 
 # #########################################################################
@@ -517,13 +552,13 @@ class MountData:
 class SwitchPortDataModel(TypedDict, total=False):
     # device_list_response_item
 
+    Name: str
+    Description: str
+    Id: int
     Maximum: Optional[int]
     Minimum: Optional[int]
     StepSize: Optional[int]
     TargetValue: Optional[int]
-    Id: int
-    Name: str
-    Description: str
     Value: float
 
 
@@ -532,29 +567,29 @@ class SwitchPortData:
     """A representation of the geographic location."""
 
     def __init__(self, *, data: SwitchPortDataModel):
+        self.name = data.get("Name")
+        self.description = data.get("Description")
+        self.id = data.get("Id")
         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
+    DeviceId: str
     DriverInfo: str
     DriverVersion: str
-    DeviceId: str
+    ReadonlySwitches: Optional[list[SwitchPortDataModel]]
+    SupportedActions: list[str]
+    WritableSwitches: Optional[list[SwitchPortDataModel]]
 
 
 @typechecked
@@ -562,16 +597,16 @@ 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.device_id = data.get("DeviceId")
         self.driver_info = data.get("DriverInfo")
         self.driver_version = data.get("DriverVersion")
-        self.device_id = data.get("DeviceId")
+        self.readonly_switches = data.get("ReadonlySwitches")
+        self.supported_actions = data.get("SupportedActions")
+        self.writable_switches = data.get("WritableSwitches")
 
 
 # #########################################################################