eheimdigital 1.0.0__tar.gz

eheimdigital-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 autinerd
+
+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.

eheimdigital-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: eheimdigital
+Version: 1.0.0
+Summary: Offers a Python API for the EHEIM Digital smart aquarium devices.
+License: MIT License
+Project-URL: Homepage, https://github.com/autinerd/eheimdigital
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: aiohttp

eheimdigital-1.0.0/README.md

@@ -0,0 +1,23 @@
+# EHEIM.digital API wrapper in Python
+
+This library is an API wrapper for the EHEIM.digital smart aquarium tools.
+
+
+## Currently supported devices
+
+- EHEIM classicLEDcontrol+e
+- EHEIM classicVARIO
+- EHEIM thermocontrol
+
+## How to use
+
+### Connect to a hub
+
+```python
+from aiohttp import ClientSession
+from eheimdigital.hub import EheimDigitalHub
+
+session = ClientSession(base_url="http://eheimdigital")
+hub = EheimDigitalHub(session)
+await hub.connect()
+```

eheimdigital-1.0.0/eheimdigital/__init__.py

@@ -0,0 +1,3 @@
+"""The Eheim Digital package."""
+
+__version__ = "1.0.0"

eheimdigital-1.0.0/eheimdigital/classic_led_ctrl.py

@@ -0,0 +1,140 @@
+"""The EHEIM classicLEDcontrol light controller."""
+
+from __future__ import annotations
+
+import json
+from logging import getLogger
+from typing import TYPE_CHECKING
+
+from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.types import (
+    CCVPacket,
+    ClockPacket,
+    CloudPacket,
+    LightMode,
+    MoonPacket,
+    MsgTitle,
+    UsrDtaPacket,
+)
+
+if TYPE_CHECKING:
+    from eheimdigital.hub import EheimDigitalHub
+
+_LOGGER = getLogger(__package__)
+
+
+class EheimDigitalClassicLEDControl(EheimDigitalDevice):
+    """Represent a EHEIM classicLEDcontrol light controller."""
+
+    ccv: CCVPacket | None = None
+    clock: ClockPacket | None = None
+    cloud: CloudPacket | None = None
+    moon: MoonPacket | None = None
+    tankconfig: list[list[str]]
+    power: list[list[int]]
+
+    def __init__(self, hub: EheimDigitalHub, usrdta: UsrDtaPacket) -> None:
+        """Initialize a classicLEDcontrol light controller."""
+        super().__init__(hub, usrdta)
+        self.tankconfig = json.loads(usrdta["tankconfig"])
+        self.power = json.loads(usrdta["power"])
+
+    async def parse_message(self, msg: dict) -> None:
+        """Parse a message."""
+        match msg["title"]:
+            case MsgTitle.CCV:
+                self.ccv = CCVPacket(**msg)
+            case MsgTitle.CLOUD:
+                self.cloud = CloudPacket(**msg)
+            case MsgTitle.MOON:
+                self.moon = MoonPacket(**msg)
+            case MsgTitle.CLOCK:
+                self.clock = ClockPacket(**msg)
+
+    async def update(self) -> None:
+        """Get the new light state."""
+        await self.hub.send_packet(
+            {"title": "REQ_CCV", "to": self.mac_address, "from": "USER"}
+        )
+        await self.hub.send_packet(
+            {"title": "GET_CLOCK", "to": self.mac_address, "from": "USER"}
+        )
+        if "moon" not in self.__dict__:
+            await self.hub.send_packet(
+                {"title": "GET_MOON", "to": self.mac_address, "from": "USER"}
+            )
+        if "cloud" not in self.__dict__:
+            await self.hub.send_packet(
+                {"title": "GET_CLOUD", "to": self.mac_address, "from": "USER"}
+            )
+
+    @property
+    def light_level(self) -> tuple[int | None, int | None]:
+        """Return the current light level of the channels."""
+        if self.ccv is None:
+            return (None, None)
+        return (
+            self.ccv["currentValues"][0] if len(self.tankconfig[0]) > 0 else None,
+            self.ccv["currentValues"][1] if len(self.tankconfig[1]) > 0 else None,
+        )
+
+    @property
+    def power_consumption(self) -> tuple[float | None, float | None]:
+        """Return the power consumption of the channels."""
+        if self.ccv is None:
+            return (None, None)
+        return (
+            sum(self.power[0]) * self.ccv["currentValues"][0]
+            if len(self.tankconfig[0]) > 0
+            else None,
+            sum(self.power[1]) * self.ccv["currentValues"][1]
+            if len(self.tankconfig[1]) > 0
+            else None,
+        )
+
+    @property
+    def light_mode(self) -> LightMode | None:
+        """Return the current light operation mode."""
+        if self.clock is None or "mode" not in self.clock:
+            return None
+        return LightMode(self.clock["mode"])
+
+    async def set_light_mode(self, mode: LightMode) -> None:
+        """Set the light operation mode."""
+        await self.hub.send_packet(
+            {"title": str(mode), "to": self.mac_address, "from": "USER"}
+        )
+
+    async def turn_on(self, value: int, channel: int) -> None:
+        """Set a new brightness value for a channel."""
+        if self.light_mode == LightMode.DAYCL_MODE:
+            await self.set_light_mode(LightMode.MAN_MODE)
+        if self.ccv is None:
+            return
+        currentvalues = self.ccv["currentValues"]
+        currentvalues[channel] = value
+        await self.hub.send_packet(
+            {
+                "title": "CCV-SL",
+                "currentValues": currentvalues,
+                "to": self.mac_address,
+                "from": "USER",
+            }
+        )
+
+    async def turn_off(self, channel: int) -> None:
+        """Turn off a channel."""
+        if self.light_mode == LightMode.DAYCL_MODE:
+            await self.set_light_mode(LightMode.MAN_MODE)
+        if self.ccv is None:
+            return
+        currentvalues = self.ccv["currentValues"]
+        currentvalues[channel] = 0
+        await self.hub.send_packet(
+            {
+                "title": "CCV-SL",
+                "currentValues": currentvalues,
+                "to": self.mac_address,
+                "from": "USER",
+            }
+        )

eheimdigital-1.0.0/eheimdigital/classic_vario.py

@@ -0,0 +1,101 @@
+"""The Eheim Digital classicVARIO filter."""
+
+from __future__ import annotations
+
+from logging import getLogger
+from typing import TYPE_CHECKING
+
+from .device import EheimDigitalDevice
+from .types import (
+    ClassicVarioDataPacket,
+    FilterMode,
+    MsgTitle,
+    UsrDtaPacket,
+)
+
+if TYPE_CHECKING:
+    from eheimdigital.hub import EheimDigitalHub
+
+_LOGGER = getLogger(__package__)
+
+
+class EheimDigitalClassicVario(EheimDigitalDevice):
+    """Represent a Eheim Digital classicVARIO filter."""
+
+    classic_vario_data: ClassicVarioDataPacket | None = None
+
+    def __init__(self, hub: EheimDigitalHub, usrdta: UsrDtaPacket) -> None:
+        """Initialize a classicVARIO filter."""
+        super().__init__(hub, usrdta)
+
+    async def parse_message(self, msg: dict) -> None:
+        """Parse a message."""
+        if msg["title"] == MsgTitle.CLASSIC_VARIO_DATA:
+            self.classic_vario_data = ClassicVarioDataPacket(**msg)
+
+    async def update(self) -> None:
+        """Get the new filter state."""
+        await self.hub.send_packet(
+            {
+                "title": MsgTitle.GET_CLASSIC_VARIO_DATA,
+                "to": self.mac_address,
+                "from": "USER",
+            }
+        )
+
+    async def set_classic_vario_param(self, data: dict) -> None:
+        """Send a SET_CLASSIC_VARIO_PARAM packet, containing new values from data."""
+        if self.classic_vario_data is None:
+            _LOGGER.error(
+                "set_classic_vario_param: No CLASSIC_VARIO_DATA packet received yet."
+            )
+            return
+        await self.hub.send_packet(
+            {
+                "title": "SET_CLASSIC_VARIO_PARAM",
+                "to": self.classic_vario_data["from"],
+                "filterActive": self.classic_vario_data["filterActive"],
+                "rel_manual_motor_speed": self.classic_vario_data[
+                    "rel_manual_motor_speed"
+                ],
+                "rel_motor_speed_day": self.classic_vario_data["rel_motor_speed_day"],
+                "rel_motor_speed_night": self.classic_vario_data[
+                    "rel_motor_speed_night"
+                ],
+                "startTime_day": self.classic_vario_data["startTime_day"],
+                "startTime_night": self.classic_vario_data["startTime_night"],
+                "pulse_motorSpeed_High": self.classic_vario_data[
+                    "pulse_motorSpeed_High"
+                ],
+                "pulse_motorSpeed_Low": self.classic_vario_data["pulse_motorSpeed_Low"],
+                "pulse_Time_High": self.classic_vario_data["pulse_Time_High"],
+                "pulse_Time_Low": self.classic_vario_data["pulse_Time_Low"],
+                "pumpMode": self.classic_vario_data["pumpMode"],
+                "from": "USER",
+                **data,
+            }
+        )
+
+    @property
+    def current_speed(self) -> int:
+        """Return the current filter pump speed."""
+        return self.classic_vario_data["rel_speed"]
+
+    @property
+    def service_hours(self) -> int:
+        """Return the amount of hours until the next service is needed."""
+        return self.classic_vario_data["serviceHour"]
+
+    @property
+    def filter_mode(self) -> FilterMode:
+        """Return the current filter mode."""
+        return FilterMode(self.classic_vario_data["pumpMode"])
+
+    async def set_filter_mode(self, value: FilterMode) -> None:
+        """Set the filter mode."""
+        await self.set_classic_vario_param({"pumpMode": value.value})
+
+    @property
+    def is_active(self) -> bool:
+        """Return whether the filter is active."""
+        return bool(self.classic_vario_data["filterActive"])

eheimdigital-1.0.0/eheimdigital/device.py

@@ -0,0 +1,58 @@
+"""The Eheim Digital device."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from .types import EheimDeviceType
+
+if TYPE_CHECKING:
+    from .hub import EheimDigitalHub
+    from .types import UsrDtaPacket
+
+
+class EheimDigitalDevice:
+    """Represent a Eheim Digital device."""
+
+    hub: EheimDigitalHub
+    usrdta: UsrDtaPacket
+
+    def __init__(self, hub: EheimDigitalHub, usrdta: UsrDtaPacket) -> None:
+        """Initialize a device."""
+        self.hub = hub
+        self.usrdta = usrdta
+
+    @cached_property
+    def name(self) -> str:
+        """Device name."""
+        return self.usrdta["name"]
+
+    @cached_property
+    def mac_address(self) -> str:
+        """Device MAC address."""
+        return self.usrdta["from"]
+
+    @cached_property
+    def sw_version(self) -> str:
+        """Device software version."""
+        return f"{self.usrdta["revision"][0]//1000}.{(self.usrdta["revision"][0]%1000)//100}.{self.usrdta["revision"][0]%100}_{self.usrdta["revision"][1]//1000}.{(self.usrdta["revision"][1]%1000)//100}.{self.usrdta["revision"][1]%100}"
+
+    @cached_property
+    def device_type(self) -> EheimDeviceType:
+        """Device type."""
+        return EheimDeviceType(self.usrdta["version"])
+
+    @cached_property
+    def aquarium_name(self) -> str:
+        """Aquarium name."""
+        return self.usrdta["aqName"]
+
+    @abstractmethod
+    async def parse_message(self, msg: dict) -> None:
+        """Parse a message."""
+
+    @abstractmethod
+    async def update(self) -> None:
+        """Update a device state."""

eheimdigital-1.0.0/eheimdigital/heater.py

@@ -0,0 +1,99 @@
+"""The Eheim Digital Heater."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .device import EheimDigitalDevice
+from .types import (
+    HeaterDataPacket,
+    HeaterMode,
+    HeaterUnit,
+    MsgTitle,
+)
+
+if TYPE_CHECKING:
+    from .hub import EheimDigitalHub
+    from .types import UsrDtaPacket
+
+
+class EheimDigitalHeater(EheimDigitalDevice):
+    """Represent a Eheim Digital Heater."""
+
+    heater_data: HeaterDataPacket
+
+    def __init__(self, hub: EheimDigitalHub, usrdta: UsrDtaPacket) -> None:
+        """Initialize a heater."""
+        super().__init__(hub, usrdta)
+
+    async def parse_message(self, msg: dict) -> None:
+        """Parse a message."""
+        if msg["title"] == MsgTitle.HEATER_DATA:
+            self.heater_data = HeaterDataPacket(**msg)
+
+    async def update(self) -> None:
+        """Get the new heater state."""
+        await self.hub.send_packet(
+            {"title": MsgTitle.GET_EHEATER_DATA, "to": self.mac_address, "from": "USER"}
+        )
+
+    async def set_eheater_param(self, data: dict) -> None:
+        """Send a SET_EHEATER_PARAM packet, containing new values from data."""
+        await self.hub.send_packet(
+            {
+                "title": "SET_EHEATER_PARAM",
+                "to": self.heater_data["from"],
+                "mUnit": self.heater_data["mUnit"],
+                "sollTemp": self.heater_data["sollTemp"],
+                "active": self.heater_data["active"],
+                "hystLow": self.heater_data["hystLow"],
+                "hystHigh": self.heater_data["hystHigh"],
+                "offset": self.heater_data["offset"],
+                "mode": self.heater_data["mode"],
+                "sync": self.heater_data["sync"],
+                "partnerName": self.heater_data["partnerName"],
+                "dayStartT": self.heater_data["dayStartT"],
+                "nightStartT": self.heater_data["nightStartT"],
+                "nReduce": self.heater_data["nReduce"],
+                "from": "USER",
+                **data,
+            }
+        )
+
+    @property
+    def temperature_unit(self) -> HeaterUnit:
+        """Return the temperature unit."""
+        return HeaterUnit(self.heater_data["mUnit"])
+
+    @property
+    def current_temperature(self) -> float:
+        """Return the current temperature."""
+        return self.heater_data["isTemp"] / 10
+
+    @property
+    def target_temperature(self) -> float:
+        """Return the target temperature."""
+        return self.heater_data["sollTemp"] / 10
+
+    async def set_target_temperature(self, value: float) -> None:
+        """Set a new target temperature."""
+        await self.set_eheater_param({"sollTemp": int(value * 10)})
+
+    @property
+    def temperature_offset(self) -> float:
+        """Return the temperature offset."""
+        return self.heater_data["offset"] / 10
+
+    async def set_temperature_offset(self, value: float) -> None:
+        """Set a temperature offset."""
+        await self.set_eheater_param({"offset": int(value * 10)})
+
+    @property
+    def operation_mode(self) -> HeaterMode:
+        """Return the heater operation mode."""
+        return HeaterMode(self.heater_data["mode"])
+
+    @property
+    def is_heating(self) -> bool:
+        """Return whether the heater is heating."""
+        return bool(self.heater_data["isHeating"])

eheimdigital-1.0.0/eheimdigital/hub.py

@@ -0,0 +1,145 @@
+"""The Eheim Digital hub."""
+
+from __future__ import annotations
+
+import asyncio
+import typing
+from logging import getLogger
+
+import aiohttp
+
+from .classic_led_ctrl import EheimDigitalClassicLEDControl
+from .classic_vario import EheimDigitalClassicVario
+from .heater import EheimDigitalHeater
+from .types import EheimDeviceType, MeshNetworkPacket, MsgTitle, UsrDtaPacket
+
+if typing.TYPE_CHECKING:
+    from .device import EheimDigitalDevice
+
+
+_LOGGER = getLogger(__package__)
+
+
+class EheimDigitalHub:
+    """Represent a Eheim Digital hub."""
+
+    devices: dict[str, EheimDigitalDevice]
+    ws: aiohttp.ClientWebSocketResponse
+    receive_task: asyncio.Task
+    loop: asyncio.AbstractEventLoop
+    receive_callback: typing.Callable[[], typing.Awaitable[None]] | None
+    master: EheimDigitalDevice | None
+
+    def __init__(
+        self,
+        *,
+        session: aiohttp.ClientSession | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        receive_callback: typing.Callable[[], typing.Awaitable[None]] | None = None,
+    ) -> None:
+        """Initialize a hub."""
+        self.session = session or aiohttp.ClientSession(
+            base_url="http://eheimdigital.local"
+        )
+        self.devices = {}
+        self.loop = loop or asyncio.get_event_loop()
+        self.receive_callback = receive_callback
+        self.master = None
+
+    async def connect(self) -> None:  # pragma: no cover
+        """Connect to the hub."""
+        self.ws = await self.session.ws_connect("/ws")
+        self.receive_task = self.loop.create_task(self.receive_messages())
+
+    async def close(self) -> None:  # pragma: no cover
+        """Close the connection."""
+        self.receive_task.cancel()
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.close()
+
+    def add_device(self, usrdta: UsrDtaPacket) -> None:
+        """Add a device to the device list."""
+        match EheimDeviceType(usrdta["version"]):
+            case EheimDeviceType.VERSION_EHEIM_EXT_HEATER:
+                self.devices[usrdta["from"]] = EheimDigitalHeater(self, usrdta)
+            case EheimDeviceType.VERSION_EHEIM_CLASSIC_VARIO:
+                self.devices[usrdta["from"]] = EheimDigitalClassicVario(self, usrdta)
+            case EheimDeviceType.VERSION_EHEIM_CLASSIC_LED_CTRL_PLUS_E:
+                self.devices[usrdta["from"]] = EheimDigitalClassicLEDControl(
+                    self, usrdta
+                )
+        if self.master is None and usrdta["from"] in self.devices:
+            self.master = self.devices[usrdta["from"]]
+
+    async def request_usrdta(self, mac_address: str) -> None:
+        """Request the USRDTA of a device."""
+        await self.send_packet(
+            {"title": MsgTitle.GET_USRDTA, "to": mac_address, "from": "USER"}
+        )
+
+    async def send_packet(self, packet: dict) -> None:
+        """Send a packet to the hub."""
+        await self.ws.send_json(packet)
+
+    async def parse_mesh_network(self, msg: MeshNetworkPacket) -> None:
+        """Parse a MESH_NETWORK packet."""
+        for client in msg["clientList"]:
+            if client not in self.devices:
+                await self.request_usrdta(client)
+
+    async def parse_usrdta(self, msg: UsrDtaPacket) -> None:
+        """Parse a USRDTA packet."""
+        if msg["from"] not in self.devices:
+            self.add_device(msg)
+
+    async def parse_message(self, msg: dict) -> None:
+        """Parse a received message."""
+        if "from" not in msg:
+            _LOGGER.debug("Received message without 'from' property: %s", msg)
+            return
+        if "USER" in msg["from"]:
+            _LOGGER.debug("Received message from other user: %s", msg)
+            return
+        if "title" not in msg:
+            _LOGGER.debug("Received message without 'title' property: %s", msg)
+            return
+        match msg["title"]:
+            case MsgTitle.MESH_NETWORK:
+                _LOGGER.debug("Received mesh network packet: %s", msg)
+                await self.parse_mesh_network(MeshNetworkPacket(**msg))
+            case MsgTitle.USRDTA:
+                _LOGGER.debug("Received usrdta packet: %s", msg)
+                await self.parse_usrdta(UsrDtaPacket(**msg))
+                if self.receive_callback:
+                    await self.receive_callback()
+            case _:
+                _LOGGER.debug(
+                    "Received packet %s for device %s: %s",
+                    msg["title"],
+                    msg["from"],
+                    msg,
+                )
+                if "from" in msg and msg["from"] in self.devices:
+                    await self.devices[msg["from"]].parse_message(msg)
+                    if self.receive_callback:
+                        await self.receive_callback()
+
+    async def receive_messages(self) -> None:
+        """Receive messages from the hub."""
+        while True:
+            async for msg in self.ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    msgdata = msg.json()
+                    if type(msgdata) is list:
+                        for part in msgdata:
+                            await self.parse_message(part)
+                    else:
+                        await self.parse_message(msgdata)
+
+    async def update(self) -> None:
+        """Update the device states."""
+        if not self.ws:
+            await self.connect()
+        await self.request_usrdta("ALL")
+        for device in self.devices.values():
+            await device.update()

eheimdigital-1.0.0/eheimdigital/types.py

@@ -0,0 +1,284 @@
+"""Types for Eheim Digital."""
+
+from __future__ import annotations
+
+from enum import IntEnum, StrEnum
+from typing import Literal, NotRequired, TypedDict
+
+
+class HeaterUnit(IntEnum):
+    """Heater temperature unit."""
+
+    CELSIUS = 0
+    FAHRENHEIT = 1
+
+
+class HeaterMode(IntEnum):
+    """Heater operation mode."""
+
+    MANUAL = 0
+    BIO = 1
+    SMART = 2
+
+
+class FilterMode(IntEnum):
+    """Filter operation mode."""
+
+    MANUAL = 16
+    PULSE = 8
+    BIO = 4
+
+
+class LightMode(StrEnum):
+    """Light operation mode."""
+
+    DAYCL_MODE = "DAYCL_MODE"
+    MAN_MODE = "MAN_MODE"
+
+
+class MsgTitle(StrEnum):
+    """Represent a message title."""
+
+    USRDTA = "USRDTA"
+    CLOCK = "CLOCK"
+    NET_ST = "NET_ST"
+    NET_AP = "NET_AP"
+    MESH_NETWORK = "MESH_NETWORK"
+    CLASSIC_VARIO_DATA = "CLASSIC_VARIO_DATA"
+    HEATER_DATA = "HEATER_DATA"
+    SET_EHEATER_PARAM = "SET_EHEATER_PARAM"
+    GET_USRDTA = "GET_USRDTA"
+    GET_EHEATER_DATA = "GET_EHEATER_DATA"
+    GET_CLASSIC_VARIO_DATA = "GET_CLASSIC_VARIO_DATA"
+    CCV = "CCV"
+    MOON = "MOON"
+    CLOUD = "CLOUD"
+    ACCLIMATE = "ACCLIMATE"
+    REQ_KEEP_ALIVE = "REQ_KEEP_ALIVE"
+
+
+class EheimDeviceType(IntEnum):
+    """Represent a device type."""
+
+    VERSION_UNDEFINED = 0
+    VERSION_HC = 1
+    VERSION_HC_PLUS = 2
+    VERSION_EHEIM_LIGHT = 3
+    VERSION_EHEIM_EXT_FILTER = 4
+    VERSION_EHEIM_EXT_HEATER = 5
+    VERSION_EHEIM_FEEDER = 6
+    VERSION_EHEIM_CHILLER = 7
+    VERSION_EHEIM_LIGHT_AQUAKIDS = 8
+    VERSION_EHEIM_PH_CONTROL = 9
+    VERSION_EHEIM_STREAM_CONTROL = 10
+    VERSION_EHEIM_REEFLEX = 11
+    VERSION_EHEIM_80_FILTER_WITH_HEAT = 12
+    VERSION_EHEIM_80_FILTER_WITHOUT_HEAT = 13
+    VERSION_EHEIM_DOSING_PUMP = 14
+    VERSION_EHEIM_LED_CTRL_PLUS_E = 15
+    VERSION_EHEIM_RGB_CTRL_PLUS_E = 16
+    VERSION_EHEIM_CLASSIC_LED_CTRL_PLUS_E = 17
+    VERSION_EHEIM_CLASSIC_VARIO = 18
+    VERSION_EHEIM_CONDUCTION_METER = 19
+    VERSION_EHEIM_COMPACT_ON = 20
+
+    @property
+    def model_name(self) -> str | None:
+        """Return the model name."""
+        match self:
+            case EheimDeviceType.VERSION_EHEIM_EXT_HEATER:
+                return "thermocontrol+e"
+            case EheimDeviceType.VERSION_EHEIM_CLASSIC_VARIO:
+                return "classicVARIO+e"
+            case EheimDeviceType.VERSION_EHEIM_CLASSIC_LED_CTRL_PLUS_E:
+                return "classicLEDcontrol+e"
+            case _:
+                return None
+
+
+MeshNetworkPacket = TypedDict(
+    "MeshNetworkPacket",
+    {"title": str, "to": str, "clientList": list[str], "from": NotRequired[str]},
+)
+
+
+UsrDtaPacket = TypedDict(
+    "UsrDtaPacket",
+    {
+        "aqName": str,
+        "build": NotRequired[list[str]],
+        "demoUse": int,
+        "dst": int,
+        "emailAddr": str,
+        "firmwareAvailable": int,
+        "firstStart": int,
+        "from": str,
+        "fstTime": NotRequired[int],
+        "groupID": int,
+        "host": str,
+        "language": str,
+        "latestAvailableRevision": list[int],
+        "liveTime": int,
+        "meshing": int,
+        "mode": NotRequired[str],
+        "name": str,
+        "netmode": str,
+        "power": str,
+        "remote": int,
+        "revision": list[int],
+        "softChange": NotRequired[int],
+        "sstTime": NotRequired[int],
+        "stMail": NotRequired[int],
+        "stMailMode": NotRequired[int],
+        "sysLED": int,
+        "tankconfig": str,
+        "tID": int,
+        "timezone": int,
+        "title": str,
+        "to": str,
+        "unit": int,
+        "usrName": str,
+        "version": int,
+    },
+)
+
+HeaterDataPacket = TypedDict(
+    "HeaterDataPacket",
+    {
+        "title": str,
+        "from": str,
+        "mUnit": int,
+        "sollTemp": int,
+        "isTemp": int,
+        "hystLow": int,
+        "hystHigh": int,
+        "offset": int,
+        "active": int,
+        "isHeating": int,
+        "mode": int,
+        "sync": str,
+        "partnerName": str,
+        "dayStartT": int,
+        "nightStartT": int,
+        "nReduce": int,
+        "alertState": int,
+        "to": str,
+    },
+)
+
+SetEheaterParamPacket = TypedDict(
+    "SetEheaterParamPacket",
+    {
+        "title": Literal["SET_EHEATER_PARAM"],
+        "to": str,
+        "mUnit": int,
+        "sollTemp": int,
+        "active": int,
+        "hystLow": int,
+        "hystHigh": int,
+        "offset": int,
+        "mode": int,
+        "sync": str,
+        "partnerName": str,
+        "dayStartT": int,
+        "nightStartT": int,
+        "nReduce": int,
+        "from": Literal["USER"],
+    },
+)
+
+
+ClassicVarioDataPacket = TypedDict(
+    "ClassicVarioDataPacket",
+    {
+        "title": Literal[MsgTitle.CLASSIC_VARIO_DATA],
+        "from": str,
+        "rel_speed": int,
+        "pumpMode": int,
+        "filterActive": int,
+        "turnOffTime": int,
+        "serviceHour": int,
+        "rel_manual_motor_speed": int,
+        "rel_motor_speed_day": int,
+        "rel_motor_speed_night": int,
+        "startTime_day": int,
+        "startTime_night": int,
+        "pulse_motorSpeed_High": int,
+        "pulse_motorSpeed_Low": int,
+        "pulse_Time_High": int,
+        "pulse_Time_Low": int,
+        "turnTimeFeeding": int,
+        "errorCode": int,
+        "version": int,
+    },
+)
+
+CCVPacket = TypedDict(
+    "CCVPacket",
+    {
+        "title": Literal[MsgTitle.CCV],
+        "from": str,
+        "currentValues": list[int],
+        "to": str,
+    },
+)
+
+MoonPacket = TypedDict(
+    "MoonPacket",
+    {
+        "title": Literal[MsgTitle.MOON],
+        "from": str,
+        "maxmoonlight": int,
+        "minmoonlight": int,
+        "moonlightActive": int,
+        "moonlightCycle": int,
+        "to": str,
+    },
+)
+
+CloudPacket = TypedDict(
+    "CloudPacket",
+    {
+        "title": Literal[MsgTitle.CLOUD],
+        "from": str,
+        "probability": int,
+        "maxAmount": int,
+        "minIntensity": int,
+        "maxIntensity": int,
+        "minDuration": int,
+        "maxDuration": int,
+        "cloudActive": int,
+        "mode": int,
+        "to": str,
+    },
+)
+
+AcclimatePacket = TypedDict(
+    "AcclimatePacket",
+    {
+        "title": Literal[MsgTitle.ACCLIMATE],
+        "from": str,
+        "duration": int,
+        "intensityReduction": int,
+        "currentAcclDay": int,
+        "acclActive": int,
+        "pause": int,
+        "to": str,
+    },
+)
+
+ClockPacket = TypedDict(
+    "ClockPacket",
+    {
+        "title": Literal[MsgTitle.CLOCK],
+        "from": str,
+        "year": int,
+        "month": int,
+        "day": int,
+        "hour": int,
+        "min": int,
+        "sec": int,
+        "mode": NotRequired[str],
+        "valid": NotRequired[int],
+    },
+)

eheimdigital-1.0.0/eheimdigital.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: eheimdigital
+Version: 1.0.0
+Summary: Offers a Python API for the EHEIM Digital smart aquarium devices.
+License: MIT License
+Project-URL: Homepage, https://github.com/autinerd/eheimdigital
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: aiohttp

eheimdigital-1.0.0/eheimdigital.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+eheimdigital/__init__.py
+eheimdigital/classic_led_ctrl.py
+eheimdigital/classic_vario.py
+eheimdigital/device.py
+eheimdigital/heater.py
+eheimdigital/hub.py
+eheimdigital/types.py
+eheimdigital.egg-info/PKG-INFO
+eheimdigital.egg-info/SOURCES.txt
+eheimdigital.egg-info/dependency_links.txt
+eheimdigital.egg-info/requires.txt
+eheimdigital.egg-info/top_level.txt
+tests/test_hub.py

eheimdigital-1.0.0/eheimdigital.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eheimdigital-1.0.0/eheimdigital.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

eheimdigital-1.0.0/eheimdigital.egg-info/top_level.txt

@@ -0,0 +1 @@
+eheimdigital

eheimdigital-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eheimdigital"
+description = "Offers a Python API for the EHEIM Digital smart aquarium devices."
+dynamic = ["version"]
+dependencies = ["aiohttp"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+license = { text = "MIT License" }
+
+[project.urls]
+Homepage = "https://github.com/autinerd/eheimdigital"
+
+[tool.setuptools.dynamic]
+version = { attr = "eheimdigital.__version__" }
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+output-format = "concise"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["D211", "D213", "COM812", "D203", "ISC001", "E501", "EXE002"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S101", "RUF018"]
+
+[tool.uv]
+dev-dependencies = ["ruff>=0.6.7", "pytest>=8.3.3", "pytest-asyncio>=0.24.0"]

eheimdigital-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eheimdigital-1.0.0/tests/test_hub.py

@@ -0,0 +1,27 @@
+"""Tests for the EHEIM.digital hub."""
+
+import json
+from pathlib import Path
+from unittest.mock import Mock
+
+import pytest
+
+from eheimdigital.hub import EheimDigitalHub
+from eheimdigital.types import UsrDtaPacket
+
+
+@pytest.mark.parametrize("fixture", ["usrdta_heater.json"])
+async def test_add_device(fixture: str) -> None:
+    """Tests adding a device."""
+    usrdta = UsrDtaPacket(
+        json.loads(
+            (Path(__file__).parent / "fixtures" / fixture).read_text(encoding="utf8")
+        )
+    )
+    hub = EheimDigitalHub(Mock())
+    hub.add_device(usrdta)
+    assert len(hub.devices) == 1
+    assert usrdta["from"] in hub.devices
+    assert (device := hub.devices[usrdta["from"]])
+    assert device.mac_address == usrdta["from"]
+    assert device.device_type == usrdta["version"]