eheimdigital 1.0.1__py2.py3-none-any.whl

eheimdigital/__init__.py

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

eheimdigital/classic_led_ctrl.py

@@ -0,0 +1,150 @@
+"""The EHEIM classicLEDcontrol light controller."""
+
+from __future__ import annotations
+
+import json
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, override
+
+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"])
+
+    @override
+    async def parse_message(self, msg: dict[str, Any]) -> 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)
+            case _:
+                pass
+
+    @override
+    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/classic_vario.py

@@ -0,0 +1,93 @@
+"""The Eheim Digital classicVARIO filter."""
+
+from __future__ import annotations
+
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, override
+
+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)
+
+    @override
+    async def parse_message(self, msg: dict[str, Any]) -> None:
+        """Parse a message."""
+        if msg["title"] == MsgTitle.CLASSIC_VARIO_DATA:
+            self.classic_vario_data = ClassicVarioDataPacket(**msg)
+
+    @override
+    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[str, Any]) -> 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/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, Any
+
+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[str, Any]) -> None:
+        """Parse a message."""
+
+    @abstractmethod
+    async def update(self) -> None:
+        """Update a device state."""

eheimdigital/heater.py

@@ -0,0 +1,101 @@
+"""The Eheim Digital Heater."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, override
+
+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 | None = None
+
+    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)
+
+    @override
+    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",
+        })
+
+    @override
+    async def set_eheater_param(self, data: dict[str, Any]) -> 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/hub.py

@@ -0,0 +1,162 @@
+"""The Eheim Digital hub."""
+
+from __future__ import annotations
+
+import asyncio
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, Callable
+
+import aiohttp
+from yarl import URL
+
+from .classic_led_ctrl import EheimDigitalClassicLEDControl
+from .classic_vario import EheimDigitalClassicVario
+from .heater import EheimDigitalHeater
+from .types import EheimDeviceType, MeshNetworkPacket, MsgTitle, UsrDtaPacket
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
+    from .device import EheimDigitalDevice
+
+
+_LOGGER = getLogger(__package__)
+
+
+class EheimDigitalHub:
+    """Represent a Eheim Digital hub."""
+
+    devices: dict[str, EheimDigitalDevice]
+    loop: asyncio.AbstractEventLoop
+    main: EheimDigitalDevice | None
+    receive_callback: Callable[[], Awaitable[None]] | None
+    receive_task: asyncio.Task[None] | None = None
+    url: URL
+    ws: aiohttp.ClientWebSocketResponse | None = None
+
+    def __init__(
+        self,
+        *,
+        host: str = "eheimdigital.local",
+        session: aiohttp.ClientSession | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        receive_callback: Callable[[], Awaitable[None]] | None = None,
+    ) -> None:
+        """Initialize a hub."""
+        self.url = URL.build(scheme="http", host=host, path="/ws")
+        self.session = session or aiohttp.ClientSession()
+        self.devices = {}
+        self.loop = loop or asyncio.get_event_loop()
+        self.receive_callback = receive_callback
+        self.main = None
+
+    async def connect(self) -> None:  # pragma: no cover
+        """Connect to the hub."""
+        self.ws = await self.session.ws_connect(self.url)
+        self.receive_task = self.loop.create_task(self.receive_messages())
+
+    async def close(self) -> None:  # pragma: no cover
+        """Close the connection."""
+        if self.receive_task is not None:
+            _ = 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
+                )
+            case _:
+                _LOGGER.debug(
+                    "Found device %s with unsupported device type %s",
+                    usrdta["from"],
+                    EheimDeviceType(usrdta["version"]),
+                )
+        if self.main is None and usrdta["from"] in self.devices:
+            self.main = 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[str, Any]) -> None:
+        """Send a packet to the hub."""
+        if self.ws is not None:
+            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[str, Any]) -> 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."""
+        if self.ws is None:
+            _LOGGER.error("receive_task called without an established connection!")
+            return
+        while True:
+            async for msg in self.ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    msgdata: list[dict[str, Any]] | dict[str, Any] = msg.json()
+                    if isinstance(msgdata, 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 self.ws is None:
+            await self.connect()
+        await self.request_usrdta("ALL")
+        for device in self.devices.values():
+            await device.update()

eheimdigital/types.py

@@ -0,0 +1,284 @@
+"""Types for Eheim Digital."""  # noqa: A005
+
+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[MsgTitle.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.1.dist-info/METADATA

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

eheimdigital-1.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+eheimdigital/__init__.py,sha256=YUvqMGJgCX2er7k9uZGXErWFIgSsualBVSWAODtnhyI,56
+eheimdigital/classic_led_ctrl.py,sha256=GV2h27ywfPmUm87CM-K_pF4nbtDTCQ01My9FpAcPqTs,4822
+eheimdigital/classic_vario.py,sha256=KyOYcqetTavDLWzR502Nblakt381qn6wsrGXjW6qibw,3460
+eheimdigital/device.py,sha256=Rme9McxQ1XK_DbPxCWgciWWtr4038fqqf5owLj-3Tig,1657
+eheimdigital/heater.py,sha256=mvWqX0rCew9BKs1_KJ_vaobmFyrymH602xbgCHPO1zA,3320
+eheimdigital/hub.py,sha256=o3M102eTo9fAA3mjQh69lW21BMoC_03vQRQL2K4zw00,6185
+eheimdigital/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eheimdigital/types.py,sha256=SxckYZVEqNl9PBVFK-V_XOe4CzbMly5e_AQdTe2JxHg,6617
+eheimdigital-1.0.1.dist-info/METADATA,sha256=go_hg4kUTiK0Srvq5gT1Dj5OuVJ4qeOp0rI_XuBPM3c,380
+eheimdigital-1.0.1.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
+eheimdigital-1.0.1.dist-info/licenses/LICENSE,sha256=8_SOcHL0FUe_0x_fQ_wQjA8F-5X5o6-zESDFTdQqYjI,1065
+eheimdigital-1.0.1.dist-info/RECORD,,

eheimdigital-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

eheimdigital-1.0.1.dist-info/licenses/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.