bwt-api 0.6.1__tar.gz → 1.0.0__tar.gz

{bwt_api-0.6.1 → bwt_api-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bwt_api
-Version: 0.6.1
+Version: 1.0.0
 Summary: Python API to access the local BWT Perla API.
 Home-page: https://github.com/dkarv/bwt_api
 Author: dkarv

bwt_api-1.0.0/src/bwt_api/api.py

@@ -0,0 +1,13 @@
+"""API facade for the BWT package."""
+
+from bwt_api.bwt_api import BwtApi
+from bwt_api.silk_api import BwtSilkApi
+from bwt_api.smart_dos_api import BwtSmartDosApi
+
+__all__ = ["BwtApi", "BwtSilkApi", "BwtSmartDosApi"]
+
+def treated_to_blended(treated: int, hardness_in: int, hardness_out: int) -> float:
+    if hardness_in == 0 or hardness_in == hardness_out:
+        return treated
+
+    return treated / (1.0 - hardness_out / hardness_in)

{bwt_api-0.6.1 → bwt_api-1.0.0}/src/bwt_api/bwt.py

@@ -13,13 +13,15 @@ class BwtModel(Enum):
     """Enum for BWT models."""
     PERLA_LOCAL_API = 1
     PERLA_SILK = 2
+    SMART_DOS = 3
 
 async def determine_bwt_model(host: str) -> BwtModel:
     """Determine the BWT model based on the api response."""
 
     _logger.debug(f"Determining BWT model for host {host}")
     timeout = aiohttp.ClientTimeout(total=3)
-    # Try :8080/api/GetCurrentData
+
+    # Recent BWT Perla models with local API
     try:
         async with aiohttp.ClientSession() as session:
             async with session.get(f"http://{host}:8080/api", timeout=timeout) as response:
@@ -30,7 +32,7 @@ async def determine_bwt_model(host: str) -> BwtModel:
     except Exception:
         pass
 
-    # Try :80/status
+    # Perla Silk with registers endpoint that returns a list of raw data
     try:
         async with aiohttp.ClientSession() as session:
             async with session.get(f"http://{host}:80/silk/registers", timeout=timeout) as response:
@@ -41,4 +43,15 @@ async def determine_bwt_model(host: str) -> BwtModel:
     except Exception:
         pass
 
+    # Smart Dos
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"http://{host}:80/api/v1/gatt/0201", timeout=timeout) as response:
+                res = await response.text()
+                _logger.debug(f"Response from {host}:80/api/v1/gatt/0201: {response.status} - {res}")
+                if response.status == 200 and res.startswith("""{"""):
+                    return BwtModel.SMART_DOS
+    except Exception:
+        pass
+
     raise ConnectException(f"Could not determine BWT model for host {host}. Please check the connection or the host address.")

bwt_api-0.6.1/src/bwt_api/api.py → bwt_api-1.0.0/src/bwt_api/bwt_api.py

@@ -1,7 +1,5 @@
 """The BWT API class."""
 
-
-from tokenize import String
 import aiohttp
 import base64
 import logging
@@ -13,11 +11,12 @@ from bwt_api.data import CurrentResponse, DailyResponse, MonthlyResponse, Yearly
 
 _logger = logging.getLogger(__name__)
 
+
 class BwtApi:
     """BWT Api."""
     _session: aiohttp.ClientSession
     _host: str
-    _headers: dict[str,str]
+    _headers: dict[str, str]
 
     def __init__(self, host, code):
         self._host = host
@@ -25,7 +24,7 @@ class BwtApi:
         base64_auth = base64.b64encode(auth.encode("ascii")).decode("ascii")
         self._headers = {"Authorization": f"Basic {base64_auth}"}
         self._session = aiohttp.ClientSession(headers=self._headers)
-    
+
     async def __aenter__(self):
         return self
 
@@ -39,27 +38,29 @@ class BwtApi:
         """Internal method to fetch json from the endpoint and handle general errors."""
         try:
             async with self._session.get(f"http://{self._host}:8080/api/{endpoint}") as response:
-                _logger.debug(f"Response status: {response.status}, content-type: {response.headers['content-type']}")
-                if (response.status == 200):
+                _logger.debug(
+                    f"Response status: {response.status}, content-type: {response.headers['content-type']}"
+                )
+                if response.status == 200:
                     json = await response.json(content_type=None)
                     _logger.debug(f"Raw response: {json}")
                     return json
                 else:
                     text = await response.text()
-                    if (response.status == 404 and text == ""):
+                    if response.status == 404 and text == "":
                         _logger.warning(f"Assuming wrong code: {response}")
                         raise WrongCodeException
                     else:
                         _logger.warning(f"Unknown response with status {response.status}: {text}")
                         raise ApiException(f"Unknown response: {text}")
-        except aiohttp.ClientConnectorError as e:
+        except (aiohttp.ClientConnectorError, TimeoutError) as e:
             raise ConnectException from e
+        except (aiohttp.ContentTypeError, ValueError) as e:
+            raise ApiException from e
 
     def _convert_datetime(self, input: str) -> datetime:
         # It looks like the device sends and even shows everything in local time
-        return datetime.strptime(
-            input, "%Y-%m-%d %H:%M:%S"
-        )# .replace(tzinfo=ZoneInfo("UTC"))
+        return datetime.strptime(input, "%Y-%m-%d %H:%M:%S")
 
     async def get_current_data(self) -> CurrentResponse:
         """Get the current state of the BWT."""
@@ -69,7 +70,7 @@ class BwtApi:
         if BwtError.UNKNOWN in errors:
             _logger.warning(f"Unknown error in current data response {raw['ActiveErrorIDs']}")
         perla_one = raw["CapacityColumn2_ml_dH"] == -1
-        
+
         in_hardness = Hardness(
             raw["HardnessIN_CaCO3"],
             raw["HardnessIN_dH"],
@@ -112,10 +113,9 @@ class BwtApi:
         )
 
     async def get_daily_data(self) -> DailyResponse:
-        """"Get treated water of the current day."""
+        """Get treated water of the current day."""
         _logger.debug(f"Fetching daily data from {self._host}")
         raw = await self.__get_data("GetDailyData")
-        # Build the keys. Starting with "00:00_00:39_l" up to "23:30_23:59_l"
         keys = [
             f"{min // 60:02}{min % 60:02}_{min // 60:02}{min % 60 + 29:02}_l"
             for min in range(0, 1440, 30)
@@ -135,45 +135,3 @@ class BwtApi:
         raw = await self.__get_data("GetYearlyData")
         keys = [f"Month{month:02}_l" for month in range(1, 13)]
         return YearlyResponse(list(map(lambda k: raw[k], keys)))
-
-
-class BwtSilkApi:
-    """BWT Silk Api."""
-    _session: aiohttp.ClientSession
-    _host: str
-
-    def __init__(self, host):
-        self._host = host
-        self._session = aiohttp.ClientSession()
-    
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *err):
-        await self.close()
-
-    async def close(self):
-        await self._session.close()
-
-    async def get_registers(self) -> list[int]:
-        """Internal method to fetch json from the endpoint and handle general errors."""
-        try:
-            async with self._session.get(f"http://{self._host}:80/silk/registers") as response:
-                _logger.debug(f"Response status: {response.status}, content-type: {response.headers['content-type']}")
-                if (response.status == 200):
-                    json = await response.json(content_type=None)
-                    _logger.debug(f"Raw response: {json}")
-                    return json["params"]
-                else:
-                    text = await response.text()
-                    _logger.warning(f"Unknown response with status {response.status}: {text}")
-                    raise ApiException(f"Unknown response: {text}")
-        except aiohttp.ClientConnectorError as e:
-            raise ConnectException from e
-
-
-def treated_to_blended(treated: int, hardness_in: int, hardness_out: int) -> float:
-    if (hardness_in == 0 | hardness_in == hardness_out):
-        return treated
-
-    return treated / (1.0 - hardness_out / hardness_in)

bwt_api-1.0.0/src/bwt_api/data.py

@@ -0,0 +1,172 @@
+"""Data objects received from the API."""
+
+
+import enum
+
+from dataclasses import dataclass
+from datetime import datetime
+from bwt_api.error import BwtError
+
+
+class BwtStatus(enum.Enum):
+    OK = 0
+    WARNING = 1
+    ERROR = 2
+
+
+class SmartDosStatus(enum.IntEnum):
+    STANDBY = 2001
+    METERING_ACTIVE = 2002
+    MINERAL_CONTAINER_LEVEL_LOW = 7001
+    MINERAL_CONTAINER_EMPTY = 7002
+    SMART_MINERAL_RUNNING_LOW = 7003
+    SMART_MINERAL_RUN_OUT = 7004
+    AQA_VOLUME_ALARM = 7005
+    AQA_WATCH_ALARM = 7006
+    AQA_MAXFLOW_ALARM = 7007
+    PUMP_FAULT = 8001
+    PUMP_POWER_FAULT = 8002
+    PUMP_CONTROL_FAULT = 8003
+
+    @classmethod
+    def _missing_(cls, value):
+        return None
+
+
+class SubstanceType(enum.IntEnum):
+    L1_LE = 1
+    L2_L3 = 2
+    L4 = 3
+    CU2 = 4
+    FLUSHING_SOLUTION = 5
+
+    @classmethod
+    def _missing_(cls, value):
+        return None
+
+
+@dataclass
+class Hardness:
+    caco3: int  # ppm CACO3
+    dH: int  # dH
+    fH: int  # fH
+    mmol: int  # mmol / l
+
+
+@dataclass
+class CurrentResponse:
+    errors: list[BwtError]
+    blended_total: int  # l
+    capacity_1: int  # ml * dH
+    capacity_2: int  # ml * dH
+    current_flow: int  # l / h
+    dosing_total: int  # ml
+    firmware_version: str
+    in_hardness: Hardness
+    out_hardness: Hardness
+    holiday_mode: int  # -1 or 0: inactive, 1: active, unix timestamp: start in future
+    regeneration_last_1: datetime
+    regeneration_last_2: datetime
+    service_customer: datetime 
+    service_technician: datetime
+    out_of_service: int
+    regeneration_count_1: int
+    regeneration_count_2: int
+    regeneration_count: int
+    regenerativ_level: int  # %
+    regenerativ_days: int  # days left
+    regenerativ_total: int  # g
+    state: BwtStatus
+    treated_day: int  # treated water current day
+    treated_month: int  # treated water current month
+    treated_year: int  # treated water current year
+    columns: int # number of columns: 2 for BWT Duo and 1 for BWT Perla One
+
+
+@dataclass
+class DailyResponse:
+    # treated water in 30 minute intervals
+    # [0] = 00:00 - 00:29
+    # [1] = 00:30 - 00:59
+    values: list[int]
+
+@dataclass
+class MonthlyResponse:
+    # treated water in 1 day intervals
+    values: list[int]
+
+@dataclass
+class YearlyResponse:
+    # treated water in 1 month intervals
+    values: list[int]
+
+
+# Smart DOS API Data Classes
+
+@dataclass
+class WifiResponse:
+    """UUID 0104: Wi-Fi Information"""
+    ssid: str  # Wi-Fi network name
+    rssi: int  # Wi-Fi signal strength in dBm
+
+
+@dataclass
+class DeviceInfoResponse:
+    """UUID 0201: Device Information"""
+    fw_rev: str  # Firmware Revision
+    hw_rev: str  # Hardware Revision
+    product_code: str  # Product Code
+    uptime: int  # Operating time since last reboot (seconds)
+    operating_time: int  # Operating time since first reboot (seconds)
+    dev_state: SmartDosStatus | None  # Current device status
+    active_states: list[SmartDosStatus | None]  # List of active device statuses
+    comm_date: str  # Start-up date (ISO format)
+
+
+@dataclass
+class ConfigurationResponse:
+    """UUID 0202: Configuration"""
+    buzzer_en: bool  # Buzzer active
+    dosing_rate: float  # Metering rate (ml/m³)
+    aqa_volume_en: bool  # AQA Volume active
+    aqa_watch_en: bool  # AQA Watch active
+    aqa_max_flow_en: bool  # AQA MaxFlow active
+    aqa_volume_val: float  # AQA Volume value (l)
+
+
+@dataclass
+class TimeResponse:
+    """UUID 0208: Time and Timezone"""
+    time: int  # Unix timestamp (seconds since 1970-01-01)
+    timezone: str  # Timezone string
+
+
+@dataclass
+class PouchInfoResponse:
+    """UUID 0401: Pouch/Container Information"""
+    tot_cap: float  # Pouch volume (ml)
+    exp_date: str  # Substance expiry date (DD.MM.YYYY)
+    order_nr: int  # Order number
+    batch_nr: int  # Batch number
+    substance_type: SubstanceType | None  # Substance type ID
+    unit: int  # Unit (0 = ml)
+
+
+@dataclass
+class RemainingCapacityResponse:
+    """UUID 0402: Remaining Capacity"""
+    rem_capacity: float  # Remaining volume in ml
+    rem_capacity_pct: float  # Remaining volume in %
+    rem_capacity_days: int  # Remaining volume in days
+
+
+@dataclass
+class TreatedWaterResponse:
+    """UUID 0503: Treated Water"""
+    total_flow: int  # Total treated water in ml
+
+
+@dataclass
+class SubstanceDosageResponse:
+    """UUID 0505: Substance Dosage"""
+    dosed_mineral: float  # Substance dosage quantity since start-up (ml)

{bwt_api-0.6.1 → bwt_api-1.0.0}/src/bwt_api/error.py

@@ -57,10 +57,19 @@ class BwtError(enum.Enum):
 
     @classmethod
     def _missing_(cls, value):
-        obj = cls.UNKNOWN
+        obj = object.__new__(cls)
         obj._value_ = value
+        obj._name_ = f"UNKNOWN_{value}"
         return obj
 
+    def __eq__(self, other):
+        if isinstance(other, BwtError):
+            return self._value_ == other._value_
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._value_)
+
     def is_fatal(self) -> bool:
         return self not in WARNING_CODES
 

bwt_api-1.0.0/src/bwt_api/silk_api.py

@@ -0,0 +1,45 @@
+"""The BWT Silk API class."""
+
+import aiohttp
+import logging
+
+from bwt_api.exception import ApiException, ConnectException
+
+_logger = logging.getLogger(__name__)
+
+
+class BwtSilkApi:
+    """BWT Silk Api."""
+    _session: aiohttp.ClientSession
+    _host: str
+
+    def __init__(self, host):
+        self._host = host
+        self._session = aiohttp.ClientSession()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *err):
+        await self.close()
+
+    async def close(self):
+        await self._session.close()
+
+    async def get_registers(self) -> list[int]:
+        """Internal method to fetch json from the endpoint and handle general errors."""
+        try:
+            async with self._session.get(f"http://{self._host}:80/silk/registers") as response:
+                _logger.debug(
+                    f"Response status: {response.status}, content-type: {response.headers['content-type']}"
+                )
+                if response.status == 200:
+                    json = await response.json(content_type=None)
+                    _logger.debug(f"Raw response: {json}")
+                    return json["params"]
+                else:
+                    text = await response.text()
+                    _logger.warning(f"Unknown response with status {response.status}: {text}")
+                    raise ApiException(f"Unknown response: {text}")
+        except aiohttp.ClientConnectorError as e:
+            raise ConnectException from e

bwt_api-1.0.0/src/bwt_api/smart_dos_api.py

@@ -0,0 +1,137 @@
+"""The BWT Smart Dos API class."""
+
+import aiohttp
+import logging
+from typing import Any
+
+from bwt_api.data import (
+    WifiResponse,
+    DeviceInfoResponse,
+    SmartDosStatus,
+    SubstanceType,
+    ConfigurationResponse,
+    TimeResponse,
+    PouchInfoResponse,
+    RemainingCapacityResponse,
+    TreatedWaterResponse,
+    SubstanceDosageResponse,
+)
+from bwt_api.exception import ApiException, ConnectException
+
+_logger = logging.getLogger(__name__)
+
+
+class BwtSmartDosApi:
+    """BWT Smart Dos Api."""
+    _session: aiohttp.ClientSession
+    _host: str
+
+    def __init__(self, host: str):
+        self._host = host
+        self._session = aiohttp.ClientSession()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *err):
+        await self.close()
+
+    async def close(self):
+        await self._session.close()
+
+    async def _get_gatt(self, uuid: str) -> dict[str, Any]:
+        """Internal method to fetch GATT characteristic JSON."""
+        try:
+            async with self._session.get(f"http://{self._host}:80/api/v1/gatt/{uuid}") as response:
+                _logger.debug(
+                    f"Response status: {response.status}, content-type: {response.headers['content-type']}"
+                )
+                if response.status == 200:
+                    json = await response.json(content_type=None)
+                    _logger.debug(f"Raw response for UUID {uuid}: {json}")
+                    return json
+                text = await response.text()
+                _logger.warning(f"Unknown response with status {response.status}: {text}")
+                raise ApiException(f"Unknown response: {text}")
+        except aiohttp.ClientConnectorError as e:
+            raise ConnectException from e
+
+    async def get_wifi_info(self) -> WifiResponse:
+        """UUID 0104: Get Wi-Fi name and signal strength."""
+        _logger.debug(f"Fetching Wi-Fi info from {self._host}")
+        raw = await self._get_gatt("0104")
+        return WifiResponse(ssid=raw["ssid"], rssi=raw["rssi"])
+
+    async def get_device_info(self) -> DeviceInfoResponse:
+        """UUID 0201: Get device information."""
+        _logger.debug(f"Fetching device info from {self._host}")
+        raw = await self._get_gatt("0201")
+        return DeviceInfoResponse(
+            fw_rev=raw["fwRev"],
+            hw_rev=raw["hwRev"],
+            product_code=raw["productCode"],
+            uptime=raw["uptime"],
+            operating_time=raw["operatingTime"],
+            dev_state=SmartDosStatus(raw["devState"]),
+            active_states=[SmartDosStatus(state) for state in raw["activeStates"]],
+            comm_date=raw["commDate"],
+        )
+
+    async def get_configuration(self) -> ConfigurationResponse:
+        """UUID 0202: Get device configuration."""
+        _logger.debug(f"Fetching configuration from {self._host}")
+        raw = await self._get_gatt("0202")
+        return ConfigurationResponse(
+            buzzer_en=raw["buzzerEn"],
+            dosing_rate=raw["dosingRate"],
+            aqa_volume_en=raw["aqaVolumeEn"],
+            aqa_watch_en=raw["aqaWatchEn"],
+            aqa_max_flow_en=raw["aqaMaxFlowEn"],
+            aqa_volume_val=raw["aqaVolumeVal"],
+        )
+
+    async def get_time_info(self) -> TimeResponse:
+        """UUID 0208: Get time and timezone information."""
+        _logger.debug(f"Fetching time info from {self._host}")
+        raw = await self._get_gatt("0208")
+        return TimeResponse(time=raw["time"], timezone=raw["timezone"])
+
+    async def get_pouch_info(self) -> PouchInfoResponse:
+        """UUID 0401: Get pouch/container information."""
+        _logger.debug(f"Fetching pouch info from {self._host}")
+        raw = await self._get_gatt("0401")
+        return PouchInfoResponse(
+            tot_cap=raw["totCap"],
+            exp_date=raw["expDate"],
+            order_nr=raw["orderNr"],
+            batch_nr=raw["batchNr"],
+            substance_type=SubstanceType(raw["id"]),
+            unit=raw["unit"],
+        )
+
+    async def get_remaining_capacity(self) -> RemainingCapacityResponse:
+        """UUID 0402: Get remaining capacity information."""
+        _logger.debug(f"Fetching remaining capacity from {self._host}")
+        raw = await self._get_gatt("0402")
+        return RemainingCapacityResponse(
+            rem_capacity=raw["remCapacity"],
+            rem_capacity_pct=raw["remCapacityPct"],
+            rem_capacity_days=raw["remCapacityDays"],
+        )
+
+    async def get_treated_water(self) -> TreatedWaterResponse:
+        """UUID 0503: Get treated water information."""
+        _logger.debug(f"Fetching treated water from {self._host}")
+        raw = await self._get_gatt("0503")
+        total_flow = raw["flow"]["1"]["totFlow"]
+        return TreatedWaterResponse(total_flow=total_flow)
+
+    async def get_substance_dosage(self) -> SubstanceDosageResponse:
+        """UUID 0505: Get substance dosage information."""
+        _logger.debug(f"Fetching substance dosage from {self._host}")
+        raw = await self._get_gatt("0505")
+        return SubstanceDosageResponse(dosed_mineral=raw["dosedMineral"])
+
+    async def get_gatt_0201(self) -> dict[str, Any]:
+        """Fetch the Smart Dos GATT 0201 characteristic JSON (raw)."""
+        return await self._get_gatt("0201")

{bwt_api-0.6.1 → bwt_api-1.0.0}/src/bwt_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bwt_api
-Version: 0.6.1
+Version: 1.0.0
 Summary: Python API to access the local BWT Perla API.
 Home-page: https://github.com/dkarv/bwt_api
 Author: dkarv

{bwt_api-0.6.1 → bwt_api-1.0.0}/src/bwt_api.egg-info/SOURCES.txt

@@ -15,16 +15,21 @@ tox.ini
 src/bwt_api/__init__.py
 src/bwt_api/api.py
 src/bwt_api/bwt.py
+src/bwt_api/bwt_api.py
 src/bwt_api/data.py
 src/bwt_api/error.py
 src/bwt_api/exception.py
+src/bwt_api/silk_api.py
 src/bwt_api/skeleton.py
+src/bwt_api/smart_dos_api.py
 src/bwt_api.egg-info/PKG-INFO
 src/bwt_api.egg-info/SOURCES.txt
 src/bwt_api.egg-info/dependency_links.txt
 src/bwt_api.egg-info/entry_points.txt
 src/bwt_api.egg-info/not-zip-safe
 src/bwt_api.egg-info/requires.txt
+src/bwt_api.egg-info/scm_file_list.json
+src/bwt_api.egg-info/scm_version.json
 src/bwt_api.egg-info/top_level.txt
 tests/conftest.py
 tests/test_api.py

bwt_api-1.0.0/src/bwt_api.egg-info/scm_file_list.json

@@ -0,0 +1,32 @@
+{
+  "files": [
+    ".coveragerc",
+    "setup.cfg",
+    "tox.ini",
+    "LICENSE.txt",
+    "setup.py",
+    "pyproject.toml",
+    "CHANGELOG.rst",
+    "CONTRIBUTING.rst",
+    "README.rst",
+    ".gitignore",
+    "AUTHORS.rst",
+    ".devcontainer/devcontainer.json",
+    "src/bwt_api/data.py",
+    "src/bwt_api/error.py",
+    "src/bwt_api/__init__.py",
+    "src/bwt_api/silk_api.py",
+    "src/bwt_api/exception.py",
+    "src/bwt_api/api.py",
+    "src/bwt_api/bwt_api.py",
+    "src/bwt_api/bwt.py",
+    "src/bwt_api/smart_dos_api.py",
+    "src/bwt_api/bwt_api",
+    "src/bwt_api/skeleton.py",
+    "tests/test_api.py",
+    "tests/conftest.py",
+    "tests/test_distinguish.py",
+    ".github/workflows/python-publish.yml",
+    ".github/workflows/python-package.yml"
+  ]
+}

bwt_api-1.0.0/src/bwt_api.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.0",
+  "distance": 0,
+  "node": "g5492b4bbc37a2bb17fa43aa4c44738964f42a13f",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-14"
+}

{bwt_api-0.6.1 → bwt_api-1.0.0}/tests/test_api.py

@@ -1,13 +1,25 @@
 from datetime import datetime
 from zoneinfo import ZoneInfo
+from unittest.mock import Mock
 import pytest
+from aiohttp.client_reqrep import ClientResponse
 
-from bwt_api.api import BwtApi, treated_to_blended
+from bwt_api.api import BwtApi, BwtSmartDosApi, treated_to_blended
 from bwt_api.error import BwtError
-from bwt_api.data import CurrentResponse, Hardness, BwtStatus
+from bwt_api.data import CurrentResponse, Hardness, BwtStatus, SmartDosStatus, SubstanceType
 
 from aioresponses import aioresponses
 
+# Compatibility shim for aioresponses with aiohttp 3.14+.
+_original_client_response_init = ClientResponse.__init__
+
+def _compat_client_response_init(self, method, url, *args, stream_writer=None, **kwargs):
+    if stream_writer is None:
+        stream_writer = Mock(output_size=0)
+    return _original_client_response_init(self, method, url, *args, stream_writer=stream_writer, **kwargs)
+
+ClientResponse.__init__ = _compat_client_response_init
+
 from bwt_api.exception import ApiException, ConnectException, WrongCodeException
 
 __author__ = "dkarv"
@@ -140,6 +152,15 @@ async def test_connect_error():
             await api.get_current_data()
 
 
+async def test_timeout_error():
+    """Timeouts should be wrapped as ConnectException, not escape as raw TimeoutError."""
+    with aioresponses() as mocked:
+        mocked.get("http://host:8080/api/GetCurrentData", exception=TimeoutError())
+        async with BwtApi("host", "code") as api:
+            with pytest.raises(ConnectException):
+                await api.get_current_data()
+
+
 async def test_unknown_response():
     with aioresponses() as mocked:
         mocked.get("http://host:8080/api/GetCurrentData", status=400, body="")
@@ -148,6 +169,15 @@ async def test_unknown_response():
                 await api.get_current_data()
 
 
+async def test_invalid_json_response():
+    """HTTP 200 with non-JSON body should raise ApiException, not JSONDecodeError."""
+    with aioresponses() as mocked:
+        mocked.get("http://host:8080/api/GetCurrentData", status=200, body="not json")
+        async with BwtApi("host", "code") as api:
+            with pytest.raises(ApiException):
+                await api.get_current_data()
+
+
 async def test_current_data():
     with aioresponses() as mocked:
         mocked.get("http://host:8080/api/GetCurrentData", status=200, body=current_json)
@@ -158,7 +188,7 @@ async def test_current_data():
                     BwtError.REGENERATIV_20,
                     BwtError.MAINTENANCE_CUSTOMER,
                     BwtError.MAINTENANCE_SERVICE,
-                    BwtError.UNKNOWN,
+                    BwtError(29),
                 ],
                 blended_total=318383,
                 capacity_1=5485275,
@@ -257,9 +287,71 @@ async def test_perla_one():
                 columns=1,
             )
 
+def test_unknown_error_no_mutation():
+    """Unknown error codes must not mutate the UNKNOWN singleton."""
+    err1 = BwtError(29)
+    assert err1.value == 29
+    assert err1.name == "UNKNOWN_29"
+    err2 = BwtError(123)
+    assert err2.value == 123
+    assert err2.name == "UNKNOWN_123"
+    # UNKNOWN singleton must be untouched
+    assert BwtError.UNKNOWN.value == -1
+    # Different unknown codes produce different instances
+    assert err1 is not err2
+
+async def test_smartdos_get_gatt_0201():
+    with aioresponses() as mocked:
+        mocked.get(
+            "http://host:80/api/v1/gatt/0201",
+            status=200,
+            body='{"characteristic":"0201","value":[1,2,3]}',
+            headers={"Content-Type": "application/json"},
+        )
+        async with BwtSmartDosApi("host") as api:
+            result = await api.get_gatt_0201()
+            assert result == {"characteristic": "0201", "value": [1, 2, 3]}
+
+
+async def test_smartdos_unknown_response():
+    with aioresponses() as mocked:
+        mocked.get("http://host:80/api/v1/gatt/0201", status=404, body="Not Found")
+        async with BwtSmartDosApi("host") as api:
+            with pytest.raises(ApiException):
+                await api.get_gatt_0201()
+
+
+async def test_smartdos_device_info_parses_status_values():
+    with aioresponses() as mocked:
+        mocked.get(
+            "http://host:80/api/v1/gatt/0201",
+            status=200,
+            body='{"fwRev":"1.1.0+4","hwRev":"2.4.0(B)","productCode":"8R19-CX2A","uptime":4889,"operatingTime":706889,"devState":2001,"activeStates":[2001],"commDate":"2024-12-04T13:45:38.833Z"}',
+            headers={"Content-Type": "application/json"},
+        )
+        async with BwtSmartDosApi("host") as api:
+            result = await api.get_device_info()
+            assert result.dev_state == SmartDosStatus.STANDBY
+            assert result.active_states == [SmartDosStatus.STANDBY]
+
+
+async def test_smartdos_pouch_info_parses_substance_type():
+    with aioresponses() as mocked:
+        mocked.get(
+            "http://host:80/api/v1/gatt/0401",
+            status=200,
+            body='{"totCap":10000,"expDate":"05.12.2025","orderNr":125123456,"batchNr":12345,"id":2,"unit":0}',
+            headers={"Content-Type": "application/json"},
+        )
+        async with BwtSmartDosApi("host") as api:
+            result = await api.get_pouch_info()
+            assert result.substance_type == SubstanceType.L2_L3
+
 def test_treated_to_blended():
     assert treated_to_blended(0, 21, 4) == 0
     assert treated_to_blended(100, 21, 21) == 100
     assert treated_to_blended(10, 20, 4) == 12.5
     assert treated_to_blended(306, 21, 4) == 378
     assert treated_to_blended(191, 21, 4) == pytest.approx(235.9411)
+    # Edge case: hardness_in == 0 should return treated as-is, not divide by zero
+    assert treated_to_blended(100, 0, 0) == 100

bwt_api-0.6.1/src/bwt_api/data.py

@@ -1,69 +0,0 @@
-"""Data objects received from the API."""
-
-
-import enum
-
-from dataclasses import dataclass
-from datetime import datetime
-from bwt_api.error import BwtError
-
-
-class BwtStatus(enum.Enum):
-    OK = 0
-    WARNING = 1
-    ERROR = 2
-
-@dataclass
-class Hardness:
-    caco3: int  # ppm CACO3
-    dH: int  # dH
-    fH: int  # fH
-    mmol: int  # mmol / l
-
-
-@dataclass
-class CurrentResponse:
-    errors: list[BwtError]
-    blended_total: int  # l
-    capacity_1: int  # ml * dH
-    capacity_2: int  # ml * dH
-    current_flow: int  # l / h
-    dosing_total: int  # ml
-    firmware_version: str
-    in_hardness: Hardness
-    out_hardness: Hardness
-    holiday_mode: int  # -1 or 0: inactive, 1: active, unix timestamp: start in future
-    regeneration_last_1: datetime
-    regeneration_last_2: datetime
-    service_customer: datetime 
-    service_technician: datetime
-    out_of_service: int
-    regeneration_count_1: int
-    regeneration_count_2: int
-    regeneration_count: int
-    regenerativ_level: int  # %
-    regenerativ_days: int  # days left
-    regenerativ_total: int  # g
-    state: BwtStatus
-    treated_day: int  # treated water current day
-    treated_month: int  # treated water current month
-    treated_year: int  # treated water current year
-    columns: int # number of columns: 2 for BWT Duo and 1 for BWT Perla One
-
-
-@dataclass
-class DailyResponse:
-    # treated water in 30 minute intervals
-    # [0] = 00:00 - 00:29
-    # [1] = 00:30 - 00:59
-    values: list[int]
-
-@dataclass
-class MonthlyResponse:
-    # treated water in 1 day intervals
-    values: list[int]
-
-@dataclass
-class YearlyResponse:
-    # treated water in 1 month intervals
-    values: list[int]