pyninaapiio 0.0.8__tar.gz → 0.0.10__tar.gz

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

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

{pyninaapiio-0.0.8 → pyninaapiio-0.0.10}/README.md

@@ -7,6 +7,11 @@
 pip install openapi-python-client
 
 openapi-python-client generate --url https://bump.sh/christian-photo/doc/advanced-api.json
+
+# or
+
+curl -O https://bump.sh/christian-photo/doc/advanced-api.json
+openapi-python-client generate --path advanced-api.json 
 ```
 
 ## advanced-api-client

pyninaapiio-0.0.10/pyninaapiio/__init__.py

@@ -0,0 +1,10 @@
+"""A client library for accessing Advanced API"""
+
+# from advanced_api_client.client import AuthenticatedClient, Client
+# from pyninaapiio.nina import NinaAPI
+
+# __all__ = (
+#     "AuthenticatedClient",
+#     "Client",
+#     "NinaAPI",
+# )

pyninaapiio-0.0.10/pyninaapiio/advanced_api_client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Advanced API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

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

@@ -8,19 +8,30 @@ from typing import Any, Optional, TypedDict
 
 from typeguard import typechecked
 
-from pyninaapiio.models.fw_info_response_available_filters_item import FWInfoResponseAvailableFiltersItem
-from pyninaapiio.models.fw_info_response_selected_filter import FWInfoResponseSelectedFilter
-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
-from pyninaapiio.models.mount_info_response_alignment_mode import MountInfoResponseAlignmentMode
-from pyninaapiio.models.mount_info_response_coordinates import MountInfoResponseCoordinates
-from pyninaapiio.models.mount_info_response_equatorial_system import MountInfoResponseEquatorialSystem
-from pyninaapiio.models.mount_info_response_primary_axis_rates_item import MountInfoResponsePrimaryAxisRatesItem
-from pyninaapiio.models.mount_info_response_secondary_axis_rates_item import MountInfoResponseSecondaryAxisRatesItem
-from pyninaapiio.models.mount_info_response_side_of_pier import MountInfoResponseSideOfPier
-from pyninaapiio.models.mount_info_response_tracking_modes_item import MountInfoResponseTrackingModesItem
-from pyninaapiio.models.mount_info_response_tracking_rate import MountInfoResponseTrackingRate
+from .advanced_api_client.models.fw_info_response_available_filters_item import (
+    FWInfoResponseAvailableFiltersItem,
+)
+from .advanced_api_client.models.fw_info_response_selected_filter import FWInfoResponseSelectedFilter
+from .advanced_api_client.models.guider_info_response_last_guide_step import GuiderInfoResponseLastGuideStep
+from .advanced_api_client.models.guider_info_response_rms_error import GuiderInfoResponseRMSError
+from .advanced_api_client.models.guider_info_response_state import GuiderInfoResponseState
+from .advanced_api_client.models.mount_info_response_alignment_mode import MountInfoResponseAlignmentMode
+from .advanced_api_client.models.mount_info_response_coordinates import MountInfoResponseCoordinates
+from .advanced_api_client.models.mount_info_response_equatorial_system import (
+    MountInfoResponseEquatorialSystem,
+)
+from .advanced_api_client.models.mount_info_response_primary_axis_rates_item import (
+    MountInfoResponsePrimaryAxisRatesItem,
+)
+from .advanced_api_client.models.mount_info_response_secondary_axis_rates_item import (
+    MountInfoResponseSecondaryAxisRatesItem,
+)
+from .advanced_api_client.models.mount_info_response_side_of_pier import MountInfoResponseSideOfPier
+from .advanced_api_client.models.mount_info_response_tracking_modes_item import (
+    MountInfoResponseTrackingModesItem,
+)
+from .advanced_api_client.models.mount_info_response_tracking_rate import MountInfoResponseTrackingRate
+from .advanced_api_client.types import Unset
 
 
 # #########################################################################
@@ -177,11 +188,11 @@ class FilterWheelDataModel(TypedDict, total=False):
     Connected: bool
     Description: str
     DeviceId: str
-    DisplayName: str
+    DisplayName: str | Unset
     DriverInfo: str
     DriverVersion: str
     IsMoving: bool
-    Name: str
+    Name: str | Unset
     SelectedFilter: FWInfoResponseSelectedFilter
     SupportedActions: list[Any]
 
@@ -222,8 +233,8 @@ class FocuserDataModel(TypedDict, total=False):
     TempCompAvailable: bool
     SupportedActions: list[Any]
     Connected: bool
-    Name: str
-    DisplayName: str
+    Name: str | Unset
+    DisplayName: str | Unset
     Description: str
     DriverInfo: str
     DriverVersion: str
@@ -258,7 +269,7 @@ class GuiderDataModel(TypedDict, total=False):
     CanSetShiftRate: bool
     CanGetLockPosition: bool
     PixelScale: float
-    Name: str
+    Name: str | Unset
     DisplayName: str
     Description: str
     DriverInfo: str
@@ -313,73 +324,78 @@ class GuiderData:
 # Image
 # #########################################################################
 class ImageDataModel(TypedDict, total=False):
+    Connected: bool
     DecodedData: bytes
+    DecodedDataLength: int
     IndexLatest: int
 
 
 class ImageData:
     def __init__(self, *, data: ImageDataModel):
+        self.connected = data.get("Connected")
         self.decoded_data = data.get("DecodedData")
+        self.decoded_data_length = data.get("DecodedDataLength")
         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 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 | Unset
+#     Id: str | Unset
+#     Name: str | Unset
+#     DisplayName: str | Unset
+#     Category: str | Unset
+#     Connected: bool
+#     Description: str | Unset
+#     DriverInfo: str | Unset
+#     DriverVersion: str | Unset
+#     SupportedActions: list | Unset
+#     # additional_properties: dict
+
+
+# @typechecked
+# class DeviceMountData:
+#     """A representation of the geographic location."""
+
+#     def __init__(self, *, data: DeviceMountDataModel):
+#         print("init")
+#         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, total=False):
     Connected: bool
-    Name: str
-    DisplayName: str
+    Name: str | Unset
+    DisplayName: str | Unset
     AlignmentMode: MountInfoResponseAlignmentMode | Any
-    Altitude: float
+    Altitude: float | str
     AltitudeString: str
     AtHome: bool
     AtPark: bool
-    Azimuth: float
+    Azimuth: float | str
     AzimuthString: str
     CanFindHome: bool
     CanMovePrimaryAxis: bool
@@ -395,7 +411,7 @@ class MountDataModel(TypedDict, total=False):
     Coordinates: MountInfoResponseCoordinates | Any
     Declination: float
     DeclinationString: str
-    DeviceId: str
+    DeviceId: str | Unset
     EquatorialSystem: MountInfoResponseEquatorialSystem | Any
     GuideRateDeclinationArcsecPerSec: int | Any
     GuideRateRightAscensionArcsecPerSec: int | Any
@@ -564,6 +580,7 @@ class SwitchData:
 class NinaDevicesDataModel(TypedDict, total=False):
     # device_list_response_item
 
+    Connected: bool
     Application: Optional[ApplicationData]
     Camera: Optional[CameraData]
     # Dome: Optional[DomeData]
@@ -585,11 +602,12 @@ class NinaDevicesData:
     """A representation of the geographic location."""
 
     def __init__(self, *, data: NinaDevicesDataModel):
+        self.connected = data.get("Connected")
         self.application = data.get("Application")
-        self.camera = data["Camera"]
-        self.filterwheel = data["FilterWheel"]
-        self.focuser = data["Focuser"]
-        self.guider = data["Guider"]
-        self.image = data["Image"]
-        self.mount = data["Mount"]
-        self.switch = data["Switch"]
+        self.camera = data.get("Camera")
+        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.switch = data.get("Switch")

{pyninaapiio-0.0.8 → pyninaapiio-0.0.10}/pyninaapiio/nina.py

@@ -5,23 +5,33 @@ import traceback
 from pprint import pprint as pp
 
 from httpx import ConnectTimeout
-
-from pyninaapiio.api.application import get_version
-from pyninaapiio.api.camera import get_equipment_camera_info
-from pyninaapiio.api.filter_wheel import get_equipment_filterwheel_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 (
+from typeguard import TypeCheckError
+
+from .advanced_api_client.api.application import get_version
+from .advanced_api_client.api.camera import get_equipment_camera_info
+from .advanced_api_client.api.filter_wheel import get_equipment_filterwheel_info
+from .advanced_api_client.api.focuser import get_equipment_focuser_info
+from .advanced_api_client.api.guider import get_equipment_guider_info
+from .advanced_api_client.api.image import get_image_history, get_image_index
+from .advanced_api_client.api.mount import get_equipment_mount_info, get_equipment_mount_list_devices
+from .advanced_api_client.api.switch import get_equipment_switch_info
+from .advanced_api_client.client import Client
+from .advanced_api_client.models.camera_info import CameraInfo
+from .advanced_api_client.models.device_list import DeviceList
+from .advanced_api_client.models.focuser_info import FocuserInfo
+from .advanced_api_client.models.fw_info import FWInfo
+from .advanced_api_client.models.get_image_history_response_200 import GetImageHistoryResponse200
+from .advanced_api_client.models.get_image_index_response_200 import GetImageIndexResponse200
+from .advanced_api_client.models.get_version_response_200 import GetVersionResponse200
+from .advanced_api_client.models.guider_info import GuiderInfo
+from .advanced_api_client.models.mount_info import MountInfo
+from .advanced_api_client.models.switch_info import SwitchInfo
+from .advanced_api_client.types import Response
+from .dataclasses import (
     ApplicationData,
     ApplicationDataModel,
     CameraData,
     CameraDataModel,
-    DeviceMountData,
-    DeviceMountDataModel,
     FilterWheelData,
     FilterWheelDataModel,
     FocuserData,
@@ -37,27 +47,16 @@ from pyninaapiio.dataclasses import (
     SwitchData,
     SwitchDataModel,
 )
-from pyninaapiio.models.camera_info import CameraInfo
-from pyninaapiio.models.device_list import DeviceList
-from pyninaapiio.models.focuser_info import FocuserInfo
-from pyninaapiio.models.fw_info import FWInfo
-from pyninaapiio.models.get_image_history_response_200 import GetImageHistoryResponse200
-from pyninaapiio.models.get_image_index_response_200 import GetImageIndexResponse200
-from pyninaapiio.models.get_version_response_200 import GetVersionResponse200
-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.DEBUG,
+    level=logging.INFO,
     format="%(asctime)s %(levelname)s (%(threadName)s) [%(funcName)s] %(message)s",
     datefmt="%Y-%m-%d %H:%M:%S",
 )
 
-API_TIMEOUT = 10
+API_TIMEOUT = 3
 
 
 # async with client as client:
@@ -89,7 +88,7 @@ class NinaAPI:
 
         # Save last capture
         self._image_index_latest = -1
-        self._image_data = None
+        self._image_data = b""
 
         return None
 
@@ -98,89 +97,103 @@ class NinaAPI:
     # #########################################################################
     async def application_info(self):
         try:
-            _LOGGER.debug(f"Retrieve application info")
+            _LOGGER.info("Retrieve info")
             _application_info: Response[GetVersionResponse200] = await get_version.asyncio(client=self._client)
-            print(_application_info)
             _application_info_data = ApplicationDataModel({"Version": _application_info.response, "Connected": True})
 
             return ApplicationData(data=_application_info_data)
 
+        except ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return ApplicationData(data={"Connected": False})
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Application not connected. {ke}")
+            _LOGGER.info("Application not connected.")
+            return ApplicationData(data={"Connected": False})
 
     # #########################################################################
     # Camera
     # #########################################################################
     async def camera_info(self):
         try:
-            _LOGGER.debug(f"Retrieve camera info")
+            _LOGGER.info("Retrieve info")
             _camera_info: Response[CameraInfo] = await get_equipment_camera_info.asyncio(client=self._client)
             _camera_info_data = CameraDataModel(_camera_info.response.to_dict())
 
             return CameraData(data=_camera_info_data)
 
+        except ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Camera not connected. {ke}")
+            _LOGGER.info("Camera not connected.")
+            return CameraData(data={"Connected": False})
 
     # #########################################################################
     # FilterWheel
     # #########################################################################
     async def filterwheel_info(self):
         try:
-            _LOGGER.debug(f"Retrieve filterwheel info")
+            _LOGGER.info("Retrieve info")
             _filterwheel_info: Response[FWInfo] = await get_equipment_filterwheel_info.asyncio(client=self._client)
             _filterwheel_info_data = FilterWheelDataModel(_filterwheel_info.response.to_dict())
 
             return FilterWheelData(data=_filterwheel_info_data)
 
+        except ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"FilterWheel not connected. {ke}")
+            _LOGGER.info("FilterWheel not connected.")
+            return FilterWheelData(data={"Connected": False})
 
     # #########################################################################
     # Focuser
     # #########################################################################
     async def focuser_info(self):
         try:
-            _LOGGER.debug(f"Retrieve focuser info")
+            _LOGGER.info("Retrieve info")
             _focuser_info: Response[FocuserInfo] = await get_equipment_focuser_info.asyncio(client=self._client)
             _focuser_info_data = FocuserDataModel(_focuser_info.response.to_dict())
 
             return FocuserData(data=_focuser_info_data)
 
+        except ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Focuser not connected. {ke}")
+            _LOGGER.info("Focuser not connected.")
+            return FocuserData(data={"Connected": False})
 
     # #########################################################################
     # Guider
     # #########################################################################
     async def guider_info(self):
         try:
-            _LOGGER.debug(f"Retrieve guider info")
+            _LOGGER.info("Retrieve info")
             _guider_info: Response[GuiderInfo] = await get_equipment_guider_info.asyncio(client=self._client)
             _guider_info_data = GuiderDataModel(_guider_info.response.to_dict())
 
             return GuiderData(data=_guider_info_data)
 
+        except ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Guider not connected. {ke}")
+            _LOGGER.info("Guider not connected.")
+            return GuiderData(data={"Connected": False})
 
     # #########################################################################
     # Image
     # #########################################################################
     async def image_latest(self):
-        _LOGGER.debug(f"Retrieve index of last capture")
+        _LOGGER.info("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}")
+            _LOGGER.info(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)
@@ -188,72 +201,91 @@ class NinaAPI:
                 image_data = base64.b64decode(image.response)
                 self._image_data = image_data
             else:
-                traceback.print_exc()
                 _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})
+            _LOGGER.info(f"Returning previous capture with index {self._image_index_latest}")
+
+        _LOGGER.info(f"Capture Index: {self._image_index_latest}")
+        _camera_data = ImageDataModel(
+            {
+                "Connected": True,
+                "DecodedData": self._image_data,
+                "DecodedDataLength": len(self._image_data),
+                "IndexLatest": self._image_index_latest,
+            }
+        )
         return ImageData(data=_camera_data)
 
     # #########################################################################
     # Mount
     # #########################################################################
-    async def mount_list_devices(self):
-        items = []
+    # async def mount_list_devices(self):
+    #     items = []
 
-        try:
-            _list_devices: Response[DeviceList] = await get_equipment_mount_list_devices.asyncio(client=self._client)
+    #     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())
+    #         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}")
+    #             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:")
 
-        return items
+    #     return items
 
     async def mount_info(self):
         try:
-            _LOGGER.debug(f"Retrieve mount info")
+            _LOGGER.info("Retrieve 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 ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Mount not connected. {ke}")
+            _LOGGER.info("Mount not connected.")
+            return MountData(data={"Connected": False})
 
     # #########################################################################
     # Switch
     # #########################################################################
     async def switch_info(self):
         try:
-            _LOGGER.debug(f"Retrieve switch info")
+            _LOGGER.info("Retrieve 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 ConnectTimeout as ct:
+            _LOGGER.info("N.I.N.A. not available.")
+            return None
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.warning(f"Switch not connected. {ke}")
+            _LOGGER.info("Switch not connected.")
+            return SwitchData(data={"Connected": False})
 
     # #########################################################################
-    # Nina
+    # N.I.N.A.
     # #########################################################################
     async def nina_info(
         self,
-    ):
+    ) -> NinaDevicesData:
+        _LOGGER.info("Connecting to N.I.N.A.")
+        application_data: ApplicationData = await self.application_info()
+
+        if application_data.connected is False:
+            _LOGGER.info("N.I.N.A. not available.")
+            return NinaDevicesData(data={"Connected": False})
+
         try:
-            _LOGGER.debug(f"Retrieve nina info")
+            _LOGGER.info("Retrieve info")
             _nina = {
                 "Application": await self.application_info() if self._application_enabled else None,
                 "Camera": await self.camera_info() if self._camera_enabled else None,
@@ -269,7 +301,9 @@ class NinaAPI:
             return NinaDevicesData(data=_nina_info_data)
 
         except ConnectTimeout as ct:
-            _LOGGER.debug(f"Nina not available.")
+            _LOGGER.info("N.I.N.A. not available.")
+            return NinaDevicesData(data={"Connected": False})
         except KeyError as ke:
-            traceback.print_exc()
-            _LOGGER.debug(f"Nina not connected. {ke}")
+            # traceback.print_exc()
+            _LOGGER.info("N.I.N.A. not connected.")
+            return NinaDevicesData(data={"Connected": False})

{pyninaapiio-0.0.8 → pyninaapiio-0.0.10}/pyninaapiio.egg-info/PKG-INFO

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