Add sync functions

Author: fustom

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+.vscode/

README.md

@@ -12,7 +12,35 @@ Use pip3 to install the latest version of this module.
 pip3 install ariston
 ```
 
-## Basic functions
+## The easy way (recommended for testing the module)
+First, open Python 3 and import ariston module.
+```
+python3
+```
+```python3
+import ariston
+```
+### Syncronous
+Discover devices if you dont know your gateway id. You can skip this step.
+```python3
+raw_devices = ariston.discover("username", "password")
+```
+For example the gateway id for your first device.
+```python3
+ raw_devices[0]['gw']
+```
+Get your device
+```python3
+device = ariston.hello("username", "password", "gateway", is_metric, "location")
+```
+[Go use your device section](https://github.com/fustom/python-ariston-api/edit/main/README.md#Use-your-device)
+### Asyncronous
+```python3
+raw_devices = await ariston.async_discover("username", "password")
+device = await ariston.async_hello("username", "password", "gateway", is_metric, "location")
+```
+[Go use your device section](https://github.com/fustom/python-ariston-api/edit/main/README.md#Use-your-device)
+## The ariston class way (recommended for integrate the module)
 First, open Python 3 and import Ariston class from this module.
 ```
 python3
@@ -26,7 +54,7 @@ ariston = Ariston()
 ```
 Now let's try some functions
 
-## Connect
+### Connect
 The cloud requests are asynchronous, so if you call them from a synchronous function or not even from function, you should use asyncio.
 ```python3
 import asyncio
@@ -43,7 +71,7 @@ await ariston.async_connect("username", "password")
 - username: Your ariston cloud username.
 - password: Your ariston cloud password.
 
-## Discovery
+### Discovery
 Use this function to discover devices. You can skip this step if you already know the gateway id.
 
 Sync
@@ -69,3 +97,32 @@ device = await ariston.async_hello("gateway", is_metric, "location")
 - gateway: You can find the value in the returned discover dictionary name 'gw'
 - is_metric: Optional. True or False. True means metric, False means imperial. Only works with Galevo (Alteas One, Genus One, etc) system. Default is True.
 - language_tag: Optional. Check https://en.wikipedia.org/wiki/IETF_language_tag Only works with Galevo (Alteas One, Genus One, etc) system. Default is "en-US".
+
+## Use your device
+### Get device features
+Sync
+```python3
+device.get_features()
+```
+Async
+```python3
+await device.async_get_features()
+```
+### Get device data
+Sync
+```python3
+device.update_state()
+```
+Async
+```python3
+await device.async_update_state()
+```
+### Get device energy
+Sync
+```python3
+device.update_energy()
+```
+Async
+```python3
+await device.async_update_energy()
+```

ariston/__init__.py

@@ -1,17 +1,31 @@
 """Ariston module"""
+import asyncio
 import logging
-from asyncio import gather
+from typing import Any, Optional
 
-from .ariston import (
-    AristonAPI,
+from .ariston_api import AristonAPI, ConnectionException
+from .const import (
     DeviceAttribute,
     SystemType,
     VelisDeviceAttribute,
     WheType,
+    PlantMode,
+    ZoneMode,
+    ConsumptionProperties,
+    ConsumptionType,
+    CustomDeviceFeatures,
+    MedDeviceSettings,
+    VelisDeviceProperties,
+    EvoDeviceProperties,
+    DeviceProperties,
+    DeviceFeatures,
+    ThermostatProperties,
 )
 from .evo_device import AristonEvoDevice
 from .galevo_device import AristonGalevoDevice
 from .lydos_hybrid_device import AristonLydosHybridDevice
+from .velis_device import AristonVelisDevice
+from .device import AristonDevice
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,70 +35,153 @@ class Ariston:
 
     def __init__(self) -> None:
         self.api = None
-        self.cloud_devices: list[dict] = []
+        self.cloud_devices: list[dict[str, Any]] = []
 
     async def async_connect(self, username: str, password: str) -> bool:
         """Connect to the ariston cloud"""
         self.api = AristonAPI(username, password)
         return await self.api.async_connect()
 
-    async def async_discover(self):
+    async def async_discover(self) -> Optional[list[dict[str, Any]]]:
         """Retreive ariston devices from the cloud"""
         if self.api is None:
             _LOGGER.exception("Call async_connect first")
-            return None        
-        cloud_devices: list[dict] = []
-        cloud_devices_tuple = await gather(self.api.async_get_detailed_devices(), self.api.async_get_detailed_velis_devices())
-
-        for devices in cloud_devices_tuple:
-            cloud_devices.extend(devices)
-        
+            return None
+        cloud_devices = await _async_discover(self.api)
         self.cloud_devices = cloud_devices
         return cloud_devices
 
-    async def async_hello(self, gateway: str, is_metric=True, language_tag="en-US"):
+    async def async_hello(
+        self, gateway: str, is_metric: bool = True, language_tag: str = "en-US"
+    ) -> Optional[AristonDevice]:
         """Get ariston device"""
         if self.api is None:
             _LOGGER.exception("Call async_connect() first")
-            return
+            return None
 
         if len(self.cloud_devices) == 0:
             await self.async_discover()
 
-        device = next(
-            (
-                dev
-                for dev in self.cloud_devices
-                if dev.get(DeviceAttribute.GW) == gateway
-            ),
-            None,
+        return _get_device(
+            self.cloud_devices, self.api, gateway, is_metric, language_tag
         )
-        if device is None:
-            _LOGGER.exception(f'No device "{gateway}" found.')
-            return None
 
-        system_type = device.get(DeviceAttribute.SYS)
-        if system_type == SystemType.GALEVO:
-            return AristonGalevoDevice(
-                self.api,
+
+def _get_device(
+    cloud_devices: list[dict[str, Any]],
+    api: AristonAPI,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+) -> Optional[AristonDevice]:
+    """Get ariston device"""
+    device = next(
+        (dev for dev in cloud_devices if dev.get(DeviceAttribute.GW) == gateway),
+        None,
+    )
+    if device is None:
+        _LOGGER.exception(f'No device "{gateway}" found.')
+        return None
+
+    system_type = device.get(DeviceAttribute.SYS)
+    if system_type == SystemType.GALEVO:
+        return AristonGalevoDevice(
+            api,
+            device,
+            is_metric,
+            language_tag,
+        )
+    if system_type == SystemType.VELIS:
+        whe_type = device.get(VelisDeviceAttribute.WHE_TYPE)
+        if whe_type == WheType.LydosHybrid:
+            return AristonLydosHybridDevice(
+                api,
                 device,
-                is_metric,
-                language_tag,
             )
-        if system_type == SystemType.VELIS:
-            whe_type = device.get(VelisDeviceAttribute.WHE_TYPE)
-            if whe_type == WheType.LydosHybrid:
-                return AristonLydosHybridDevice(
-                    self.api,
-                    device,
-                )
-            if whe_type == WheType.Evo:
-                return AristonEvoDevice(
-                    self.api,
-                    device,
-                )
-            _LOGGER.exception(f"Unsupported whe type {whe_type}")
-            return None
-
-        _LOGGER.exception(f"Unsupported system type {system_type}")
+        if whe_type == WheType.Evo:
+            return AristonEvoDevice(
+                api,
+                device,
+            )
+        _LOGGER.exception(f"Unsupported whe type {whe_type}")
         return None
+
+    _LOGGER.exception(f"Unsupported system type {system_type}")
+    return None
+
+
+def _connect(username: str, password: str) -> AristonAPI:
+    """Connect to ariston api"""
+    api = AristonAPI(username, password)
+    api.connect()
+    return api
+
+
+def _discover(api: AristonAPI) -> list[dict[str, Any]]:
+    """Retreive ariston devices from the cloud"""
+    cloud_devices: list[dict[str, Any]] = []
+    cloud_devices.extend(api.get_detailed_devices())
+    cloud_devices.extend(api.get_detailed_velis_devices())
+
+    return cloud_devices
+
+
+def discover(username: str, password: str) -> list[dict[str, Any]]:
+    """Retreive ariston devices from the cloud"""
+    api = _connect(username, password)
+    return _discover(api)
+
+
+def hello(
+    username: str,
+    password: str,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+) -> Optional[AristonDevice]:
+    """Get ariston device"""
+    api = _connect(username, password)
+    cloud_devices = _discover(api)
+    return _get_device(cloud_devices, api, gateway, is_metric, language_tag)
+
+
+async def _async_connect(username: str, password: str) -> AristonAPI:
+    """Async connect to ariston api"""
+    api = AristonAPI(username, password)
+    if not await api.async_connect():
+        raise ConnectionException
+    return api
+
+
+async def _async_discover(api: AristonAPI) -> list[dict[str, Any]]:
+    """Async retreive ariston devices from the cloud"""
+    cloud_devices: list[dict[str, Any]] = []
+    cloud_devices_tuple: tuple[
+        list[dict[str, Any]], list[dict[str, Any]]
+    ] = await asyncio.gather(
+        api.async_get_detailed_devices(), api.async_get_detailed_velis_devices()
+    )
+
+    for devices in cloud_devices_tuple:
+        cloud_devices.extend(devices)
+
+    return cloud_devices
+
+
+async def async_discover(username: str, password: str) -> list[dict[str, Any]]:
+    """Retreive ariston devices from the cloud"""
+    api = await _async_connect(username, password)
+    return await _async_discover(api)
+
+
+async def async_hello(
+    username: str,
+    password: str,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+) -> Optional[AristonDevice]:
+    """Get ariston device"""
+    api = await _async_connect(username, password)
+    cloud_devices = await _async_discover(api)
+    return _get_device(cloud_devices, api, gateway, is_metric, language_tag)