ariston-net-api 0.20.0__tar.gz

ariston_net_api-0.20.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022 fustom
+Copyright (c) 2026 Wojciech Anioł
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ariston_net_api-0.20.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: ariston-net-api
+Version: 0.20.0
+Summary: Ariston module
+Author-email: Tamás Füstös <fustom@gmail.com>
+Maintainer: Wojciech Anioł
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: requests
+Requires-Dist: pytest==9.0.3 ; extra == "test"
+Requires-Dist: pytest-asyncio==1.4.0 ; extra == "test"
+Requires-Dist: ruff==0.17.2 ; extra == "test"
+Project-URL: Issues, https://github.com/wojciech-aniol/python-ariston-net-api/issues
+Project-URL: Repository, https://github.com/wojciech-aniol/python-ariston-net-api.git
+Provides-Extra: test
+
+[![Tests](https://github.com/wojciech-aniol/python-ariston-net-api/actions/workflows/tests.yml/badge.svg)](https://github.com/wojciech-aniol/python-ariston-net-api/actions/workflows/tests.yml)
+
+# python-ariston-net-api
+A maintained fork of [fustom/python-ariston-api](https://github.com/fustom/python-ariston-api)
+for the [Ariston NET](https://github.com/wojciech-aniol/ariston-remotethermo-home-assistant-v3)
+Home Assistant integration. The package is `ariston-net-api` and the module is `ariston_net_api`,
+so it can live next to fustom's `ariston` package:
+```python3
+from ariston_net_api import Ariston
+```
+
+A Python module for controlling Ariston devices with cloud polling.
+The following devices are currently supported:
+- Ariston Alteas One 24
+- Ariston Velis Evo
+- Ariston Velis Lux
+- Ariston Lydos Hybrid
+- Ariston Genus One
+- Ariston Nuos Split
+- Ariston Thision S
+- Chaffoteaux INOA S 24
+
+## Installation
+Use pip3 to install the latest version of this module.
+```
+pip3 install ariston-net-api
+```
+
+## The easy way (recommended for testing the module)
+First, open Python 3 and import ariston module.
+```
+python3
+```
+```python3
+import ariston_net_api as 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](#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](#use-your-device)
+## The ariston class way (recommended for integrate the module)
+First, open Python 3 and import Ariston class from this module.
+```
+python3
+```
+```python3
+from ariston_net_api import Ariston
+```
+Create a new Ariston instance
+```python3
+ariston = Ariston()
+```
+Now let's try some functions
+
+### 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
+```
+
+Sync
+```python3
+asyncio.run(ariston.async_connect("username", "password"))
+```
+Async
+```python3
+await ariston.async_connect("username", "password")
+```
+- username: Your ariston cloud username.
+- password: Your ariston cloud password.
+
+### Discovery
+Use this function to discover devices. You can skip this step if you already know the gateway id.
+
+Sync
+```python3
+devices = asyncio.run(ariston.async_discover())
+```
+Async
+```python3
+devices = await ariston.async_discover()
+```
+
+## Say hello
+Use this function to create the device object.
+
+Sync
+```python3
+device = asyncio.run(ariston.async_hello("gateway", is_metric, "location"))
+```
+Async
+```python3
+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_net_api-0.20.0/README.md

@@ -0,0 +1,144 @@
+[![Tests](https://github.com/wojciech-aniol/python-ariston-net-api/actions/workflows/tests.yml/badge.svg)](https://github.com/wojciech-aniol/python-ariston-net-api/actions/workflows/tests.yml)
+
+# python-ariston-net-api
+A maintained fork of [fustom/python-ariston-api](https://github.com/fustom/python-ariston-api)
+for the [Ariston NET](https://github.com/wojciech-aniol/ariston-remotethermo-home-assistant-v3)
+Home Assistant integration. The package is `ariston-net-api` and the module is `ariston_net_api`,
+so it can live next to fustom's `ariston` package:
+```python3
+from ariston_net_api import Ariston
+```
+
+A Python module for controlling Ariston devices with cloud polling.
+The following devices are currently supported:
+- Ariston Alteas One 24
+- Ariston Velis Evo
+- Ariston Velis Lux
+- Ariston Lydos Hybrid
+- Ariston Genus One
+- Ariston Nuos Split
+- Ariston Thision S
+- Chaffoteaux INOA S 24
+
+## Installation
+Use pip3 to install the latest version of this module.
+```
+pip3 install ariston-net-api
+```
+
+## The easy way (recommended for testing the module)
+First, open Python 3 and import ariston module.
+```
+python3
+```
+```python3
+import ariston_net_api as 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](#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](#use-your-device)
+## The ariston class way (recommended for integrate the module)
+First, open Python 3 and import Ariston class from this module.
+```
+python3
+```
+```python3
+from ariston_net_api import Ariston
+```
+Create a new Ariston instance
+```python3
+ariston = Ariston()
+```
+Now let's try some functions
+
+### 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
+```
+
+Sync
+```python3
+asyncio.run(ariston.async_connect("username", "password"))
+```
+Async
+```python3
+await ariston.async_connect("username", "password")
+```
+- username: Your ariston cloud username.
+- password: Your ariston cloud password.
+
+### Discovery
+Use this function to discover devices. You can skip this step if you already know the gateway id.
+
+Sync
+```python3
+devices = asyncio.run(ariston.async_discover())
+```
+Async
+```python3
+devices = await ariston.async_discover()
+```
+
+## Say hello
+Use this function to create the device object.
+
+Sync
+```python3
+device = asyncio.run(ariston.async_hello("gateway", is_metric, "location"))
+```
+Async
+```python3
+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_net_api-0.20.0/ariston_net_api/__init__.py

@@ -0,0 +1,216 @@
+"""Ariston module"""
+
+import asyncio
+import logging
+from typing import Any
+
+from .ariston_api import AristonAPI, ConnectionException
+from .base_device import AristonBaseDevice
+from .bsb_device import AristonBsbDevice
+from .const import (
+    ARISTON_API_URL,
+    ARISTON_USER_AGENT,
+    DeviceAttribute,
+    SystemType,
+    VelisDeviceAttribute,
+    WheType,
+)
+from .evo_device import AristonEvoDevice
+from .evo_one_device import AristonEvoOneDevice
+from .galevo_device import AristonGalevoDevice
+from .lux2_device import AristonLux2Device
+from .lux_device import AristonLuxDevice
+from .lydos_device import AristonLydosDevice
+from .lydos_hybrid_device import AristonLydosHybridDevice
+from .nuos_split_device import AristonNuosSplitDevice
+from .velis_base_device import AristonVelisBaseDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+_MAP_WHE_TYPES_TO_CLASS: dict[int, type[AristonVelisBaseDevice]] = {
+    WheType.Evo.value: AristonEvoOneDevice,
+    WheType.LydosHybrid.value: AristonLydosHybridDevice,
+    WheType.Lydos.value: AristonLydosDevice,
+    WheType.NuosSplit.value: AristonNuosSplitDevice,
+    WheType.Andris2.value: AristonEvoDevice,
+    WheType.Evo2.value: AristonEvoDevice,
+    WheType.Lux2.value: AristonLux2Device,
+    WheType.Lux.value: AristonLuxDevice,
+}
+
+
+class Ariston:
+    """Ariston class"""
+
+    def __init__(self) -> None:
+        self.api = None
+        self.cloud_devices: list[dict[str, Any]] = []
+
+    async def async_connect(
+        self,
+        username: str,
+        password: str,
+        api_url: str = ARISTON_API_URL,
+        user_agent: str = ARISTON_USER_AGENT,
+    ) -> bool:
+        """Connect to the ariston cloud"""
+        self.api = AristonAPI(username, password, api_url, user_agent)
+        return await self.api.async_connect()
+
+    async def async_discover(self) -> list[dict[str, Any]]:
+        """Retreive ariston devices from the cloud"""
+        if self.api is None:
+            _LOGGER.exception("Call async_connect first")
+            return []
+        cloud_devices = await _async_discover(self.api)
+        self.cloud_devices = cloud_devices
+        return cloud_devices
+
+    async def async_hello(
+        self, gateway: str, is_metric: bool = True, language_tag: str = "en-US"
+    ) -> AristonBaseDevice | None:
+        """Get ariston device"""
+        if self.api is None:
+            _LOGGER.exception("Call async_connect() first")
+            return None
+
+        if len(self.cloud_devices) == 0:
+            await self.async_discover()
+
+        return _get_device(
+            self.cloud_devices, self.api, gateway, is_metric, language_tag
+        )
+
+
+def _get_device(
+    cloud_devices: list[dict[str, Any]],
+    api: AristonAPI,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+) -> AristonBaseDevice | None:
+    """Get ariston device"""
+    device = next(
+        (dev for dev in cloud_devices if dev.get(DeviceAttribute.GW) == gateway),
+        None,
+    )
+    if device is None:
+        _LOGGER.exception("No device %s found.", gateway)
+        return None
+
+    system_type = device.get(DeviceAttribute.SYS)
+
+    match system_type:
+        case SystemType.GALEVO.value:
+            return AristonGalevoDevice(
+                api,
+                device,
+                is_metric,
+                language_tag,
+            )
+        case SystemType.VELIS.value:
+            whe_type = device.get(VelisDeviceAttribute.WHE_TYPE, None)
+            device_class = _MAP_WHE_TYPES_TO_CLASS.get(whe_type, None)
+            if device_class is None:
+                _LOGGER.exception("Unsupported whe type %s", whe_type)
+                return None
+            return device_class(api, device)
+
+        case SystemType.BSB.value:
+            return AristonBsbDevice(api, device)
+        case _:
+            _LOGGER.exception("Unsupported system type %s", system_type)
+            return None
+
+
+def _connect(
+    username: str,
+    password: str,
+    api_url: str = ARISTON_API_URL,
+    user_agent: str = ARISTON_USER_AGENT,
+) -> AristonAPI:
+    """Connect to ariston api"""
+    api = AristonAPI(username, password, api_url, user_agent)
+    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, api_url: str = ARISTON_API_URL
+) -> list[dict[str, Any]]:
+    """Retreive ariston devices from the cloud"""
+    api = _connect(username, password, api_url)
+    return _discover(api)
+
+
+def hello(
+    username: str,
+    password: str,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+    api_url: str = ARISTON_API_URL,
+) -> AristonBaseDevice | None:
+    """Get ariston device"""
+    api = _connect(username, password, api_url)
+    cloud_devices = _discover(api)
+    return _get_device(cloud_devices, api, gateway, is_metric, language_tag)
+
+
+async def _async_connect(
+    username: str,
+    password: str,
+    api_url: str = ARISTON_API_URL,
+    user_agent: str = ARISTON_USER_AGENT,
+) -> AristonAPI:
+    """Async connect to ariston api"""
+    api = AristonAPI(username, password, api_url, user_agent)
+    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, api_url: str = ARISTON_API_URL
+) -> list[dict[str, Any]]:
+    """Retreive ariston devices from the cloud"""
+    api = await _async_connect(username, password, api_url)
+    return await _async_discover(api)
+
+
+async def async_hello(
+    username: str,
+    password: str,
+    gateway: str,
+    is_metric: bool = True,
+    language_tag: str = "en-US",
+    api_url: str = ARISTON_API_URL,
+) -> AristonBaseDevice | None:
+    """Get ariston device"""
+    api = await _async_connect(username, password, api_url)
+    cloud_devices = await _async_discover(api)
+    return _get_device(cloud_devices, api, gateway, is_metric, language_tag)