python-bsblan 0.6.2__tar.gz → 0.6.3__tar.gz

{python_bsblan-0.6.2 → python_bsblan-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-bsblan
-Version: 0.6.2
+Version: 0.6.3
 Summary: Asynchronous Python client for BSBLAN
 Home-page: https://github.com/liudger/python-bsblan
 License: MIT
@@ -23,6 +23,7 @@ Requires-Dist: aiohttp (>=3.8.1)
 Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
 Requires-Dist: backoff (>=2.2.1,<3.0.0)
 Requires-Dist: mashumaro (>=3.13.1,<4.0.0)
+Requires-Dist: orjson (>=3.9.10,<4.0.0)
 Requires-Dist: packaging (>=21.3)
 Requires-Dist: yarl (>=1.7.2)
 Project-URL: Bug Tracker, https://github.com/liudger/python-bsblan/issues

{python_bsblan-0.6.2 → python_bsblan-0.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-bsblan"
-version = "0.6.2"
+version = "0.6.3"
 description = "Asynchronous Python client for BSBLAN"
 authors = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
 maintainers = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
@@ -32,10 +32,11 @@ packaging = ">=21.3"
 backoff = "^2.2.1"
 async-timeout = "^4.0.3"
 mashumaro = "^3.13.1"
+orjson = "^3.9.10"
 
 [tool.poetry.dev-dependencies]
 covdefaults = "^2.3.0"
-ruff = "^0.5.0"
+ruff = "^0.6.0"
 aresponses = "^3.0.0"
 black = "^24.0.0"
 blacken-docs = "^1.13.0"
@@ -47,8 +48,8 @@ pre-commit = "^3.0.0"
 pre-commit-hooks = "^4.3.0"
 pylint = "^3.0.0"
 pytest = "^8.0.0"
-pytest-asyncio = "^0.23.0"
-pytest-cov = "^4.0.0"
+pytest-asyncio = "^0.24.0"
+pytest-cov = "^5.0.0"
 yamllint = "^1.29.0"
 pyupgrade = "^3.3.1"
 flake8-simplify = "^0.21.0"

{python_bsblan-0.6.2 → python_bsblan-0.6.3}/src/bsblan/__init__.py

@@ -2,7 +2,7 @@
 
 from .bsblan import BSBLAN, BSBLANConfig
 from .exceptions import BSBLANConnectionError, BSBLANError
-from .models import Device, Info, Sensor, State, StaticState
+from .models import Device, HotWaterState, Info, Sensor, State, StaticState
 
 __all__ = [
     "BSBLAN",
@@ -14,4 +14,5 @@ __all__ = [
     "Device",
     "Sensor",
     "StaticState",
+    "HotWaterState",
 ]

python_bsblan-0.6.3/src/bsblan/bsblan.py

@@ -0,0 +1,363 @@
+"""Asynchronous Python client for BSB-Lan."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Mapping, cast
+
+import aiohttp
+from aiohttp.hdrs import METH_POST
+from aiohttp.helpers import BasicAuth
+from packaging import version as pkg_version
+from typing_extensions import Self
+from yarl import URL
+
+from .constants import (
+    API_DATA_NOT_INITIALIZED_ERROR_MSG,
+    API_VERSION_ERROR_MSG,
+    API_VERSIONS,
+    FIRMWARE_VERSION_ERROR_MSG,
+    HVAC_MODE_DICT,
+    HVAC_MODE_DICT_REVERSE,
+    MULTI_PARAMETER_ERROR_MSG,
+    NO_STATE_ERROR_MSG,
+    SESSION_NOT_INITIALIZED_ERROR_MSG,
+    TEMPERATURE_RANGE_ERROR_MSG,
+    VERSION_ERROR_MSG,
+    APIConfig,
+)
+from .exceptions import (
+    BSBLANConnectionError,
+    BSBLANError,
+    BSBLANInvalidParameterError,
+    BSBLANVersionError,
+)
+from .models import Device, HotWaterState, Info, Sensor, State, StaticState
+
+if TYPE_CHECKING:
+    from aiohttp.client import ClientSession
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BSBLANConfig:
+    """Configuration for BSBLAN."""
+
+    host: str
+    username: str | None = None
+    password: str | None = None
+    passkey: str | None = None
+    port: int = 80
+    request_timeout: int = 10
+
+
+@dataclass
+class BSBLAN:
+    """Main class for handling connections with BSBLAN."""
+
+    config: BSBLANConfig
+    session: ClientSession | None = None
+    _close_session: bool = False
+    _firmware_version: str | None = None
+    _api_version: str | None = None
+    _min_temp: float | None = None
+    _max_temp: float | None = None
+    _temperature_range_initialized: bool = False
+    _api_data: APIConfig | None = None
+
+    def __post_init__(self) -> None:
+        """Initialize the session if not provided."""
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+            self._close_session = True
+
+    async def __aenter__(self) -> Self:
+        """Enter the context manager."""
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+            self._close_session = True
+        await self._initialize()
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        """Exit the context manager."""
+        if self._close_session and self.session:
+            await self.session.close()
+
+    async def _initialize(self) -> None:
+        """Initialize the BSBLAN client."""
+        await self._fetch_firmware_version()
+        await self._initialize_temperature_range()
+        await self._initialize_api_data()
+
+    async def _fetch_firmware_version(self) -> None:
+        """Fetch the firmware version if not already available."""
+        if self._firmware_version is None:
+            device = await self.device()
+            self._firmware_version = device.version
+            logger.debug("BSBLAN version: %s", self._firmware_version)
+            self._set_api_version()
+
+    def _set_api_version(self) -> None:
+        """Set the API version based on the firmware version."""
+        if not self._firmware_version:
+            raise BSBLANError(FIRMWARE_VERSION_ERROR_MSG)
+
+        version = pkg_version.parse(self._firmware_version)
+        if version < pkg_version.parse("1.2.0"):
+            self._api_version = "v1"
+        elif version >= pkg_version.parse("3.0.0"):
+            self._api_version = "v3"
+        else:
+            raise BSBLANVersionError(VERSION_ERROR_MSG)
+
+    async def _initialize_temperature_range(self) -> None:
+        """Initialize the temperature range from static values."""
+        if not self._temperature_range_initialized:
+            static_values = await self.static_values()
+            self._min_temp = float(static_values.min_temp.value)
+            self._max_temp = float(static_values.max_temp.value)
+            self._temperature_range_initialized = True
+            logger.debug(
+                "Temperature range initialized: min=%f, max=%f",
+                self._min_temp,
+                self._max_temp,
+            )
+
+    async def _initialize_api_data(self) -> APIConfig:
+        """Initialize and cache the API data."""
+        if self._api_data is None:
+            if self._api_version is None:
+                raise BSBLANError(API_VERSION_ERROR_MSG)
+            self._api_data = API_VERSIONS[self._api_version]
+            logger.debug("API data initialized for version: %s", self._api_version)
+        if self._api_data is None:
+            raise BSBLANError(API_DATA_NOT_INITIALIZED_ERROR_MSG)
+        return self._api_data
+
+    async def _request(
+        self,
+        method: str = METH_POST,
+        base_path: str = "/JQ",
+        data: dict[str, object] | None = None,
+        params: Mapping[str, str | int] | str | None = None,
+    ) -> dict[str, Any]:
+        """Handle a request to a BSBLAN device."""
+        if self.session is None:
+            raise BSBLANError(SESSION_NOT_INITIALIZED_ERROR_MSG)
+        url = self._build_url(base_path)
+        auth = self._get_auth()
+        headers = self._get_headers()
+
+        try:
+            async with asyncio.timeout(self.config.request_timeout):
+                async with self.session.request(
+                    method,
+                    url,
+                    auth=auth,
+                    params=params,
+                    json=data,
+                    headers=headers,
+                ) as response:
+                    response.raise_for_status()
+                    return cast(dict[str, Any], await response.json())
+        except asyncio.TimeoutError as e:
+            raise BSBLANConnectionError(BSBLANConnectionError.message_timeout) from e
+        except aiohttp.ClientError as e:
+            raise BSBLANConnectionError(BSBLANConnectionError.message_error) from e
+        except ValueError as e:
+            raise BSBLANError(str(e)) from e
+
+    def _build_url(self, base_path: str) -> URL:
+        """Build the URL for the request."""
+        if self.config.passkey:
+            base_path = f"/{self.config.passkey}{base_path}"
+        return URL.build(
+            scheme="http",
+            host=self.config.host,
+            port=self.config.port,
+            path=base_path,
+        )
+
+    def _get_auth(self) -> BasicAuth | None:
+        """Get the authentication for the request."""
+        if self.config.username and self.config.password:
+            return BasicAuth(self.config.username, self.config.password)
+        return None
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get the headers for the request."""
+        return {
+            "User-Agent": f"PythonBSBLAN/{self._firmware_version}",
+            "Accept": "application/json, */*",
+        }
+
+    def _validate_single_parameter(self, *params: Any, error_msg: str) -> None:
+        """Validate that exactly one parameter is provided."""
+        if sum(param is not None for param in params) != 1:
+            raise BSBLANError(error_msg)
+
+    async def _get_parameters(self, params: dict[Any, Any]) -> dict[Any, Any]:
+        """Get the parameters info from BSBLAN device."""
+        string_params = ",".join(map(str, params))
+        return {"string_par": string_params, "list": list(params.values())}
+
+    async def state(self) -> State:
+        """Get the current state from BSBLAN device."""
+        api_data = await self._initialize_api_data()
+        params = await self._get_parameters(api_data["heating"])
+        data = await self._request(params={"Parameter": params["string_par"]})
+        data = dict(zip(params["list"], list(data.values()), strict=True))
+        data["hvac_mode"]["value"] = HVAC_MODE_DICT[int(data["hvac_mode"]["value"])]
+        return State.from_dict(data)
+
+    async def sensor(self) -> Sensor:
+        """Get the sensor information from BSBLAN device."""
+        api_data = await self._initialize_api_data()
+        params = await self._get_parameters(api_data["sensor"])
+        data = await self._request(params={"Parameter": params["string_par"]})
+        data = dict(zip(params["list"], list(data.values()), strict=True))
+        return Sensor.from_dict(data)
+
+    async def static_values(self) -> StaticState:
+        """Get the static information from BSBLAN device."""
+        api_data = await self._initialize_api_data()
+        params = await self._get_parameters(api_data["staticValues"])
+        data = await self._request(params={"Parameter": params["string_par"]})
+        data = dict(zip(params["list"], list(data.values()), strict=True))
+        return StaticState.from_dict(data)
+
+    async def device(self) -> Device:
+        """Get BSBLAN device info."""
+        device_info = await self._request(base_path="/JI")
+        return Device.from_dict(device_info)
+
+    async def info(self) -> Info:
+        """Get information about the current heating system config."""
+        api_data = await self._initialize_api_data()
+        params = await self._get_parameters(api_data["device"])
+        data = await self._request(params={"Parameter": params["string_par"]})
+        data = dict(zip(params["list"], list(data.values()), strict=True))
+        return Info.from_dict(data)
+
+    async def thermostat(
+        self,
+        target_temperature: str | None = None,
+        hvac_mode: str | None = None,
+    ) -> None:
+        """Change the state of the thermostat through BSB-Lan."""
+        await self._initialize_temperature_range()
+
+        self._validate_single_parameter(
+            target_temperature,
+            hvac_mode,
+            error_msg=MULTI_PARAMETER_ERROR_MSG,
+        )
+
+        state = self._prepare_thermostat_state(target_temperature, hvac_mode)
+        await self._set_thermostat_state(state)
+
+    def _prepare_thermostat_state(
+        self,
+        target_temperature: str | None,
+        hvac_mode: str | None,
+    ) -> dict[str, Any]:
+        """Prepare the thermostat state for setting."""
+        state: dict[str, Any] = {}
+        if target_temperature is not None:
+            self._validate_target_temperature(target_temperature)
+            state.update({"Parameter": "710", "Value": target_temperature, "Type": "1"})
+        if hvac_mode is not None:
+            self._validate_hvac_mode(hvac_mode)
+            state.update(
+                {
+                    "Parameter": "700",
+                    "EnumValue": HVAC_MODE_DICT_REVERSE[hvac_mode],
+                    "Type": "1",
+                },
+            )
+        return state
+
+    def _validate_target_temperature(self, target_temperature: str) -> None:
+        """Validate the target temperature."""
+        if self._min_temp is None or self._max_temp is None:
+            raise BSBLANError(TEMPERATURE_RANGE_ERROR_MSG)
+
+        try:
+            temp = float(target_temperature)
+            if not (self._min_temp <= temp <= self._max_temp):
+                raise BSBLANInvalidParameterError(target_temperature)
+        except ValueError as err:
+            raise BSBLANInvalidParameterError(target_temperature) from err
+
+    def _validate_hvac_mode(self, hvac_mode: str) -> None:
+        """Validate the HVAC mode."""
+        if hvac_mode not in HVAC_MODE_DICT_REVERSE:
+            raise BSBLANInvalidParameterError(hvac_mode)
+
+    async def _set_thermostat_state(self, state: dict[str, Any]) -> None:
+        """Set the thermostat state."""
+        response = await self._request(base_path="/JS", data=state)
+        logger.debug("Response for setting: %s", response)
+
+    async def hot_water_state(self) -> HotWaterState:
+        """Get the current hot water state from BSBLAN device."""
+        api_data = await self._initialize_api_data()
+        params = await self._get_parameters(api_data["hot_water"])
+        data = await self._request(params={"Parameter": params["string_par"]})
+        data = dict(zip(params["list"], list(data.values()), strict=True))
+        return HotWaterState.from_dict(data)
+
+    async def set_hot_water(
+        self,
+        operating_mode: str | None = None,
+        nominal_setpoint: float | None = None,
+        reduced_setpoint: float | None = None,
+    ) -> None:
+        """Change the state of the hot water system through BSB-Lan."""
+        self._validate_single_parameter(
+            operating_mode,
+            nominal_setpoint,
+            reduced_setpoint,
+            error_msg=MULTI_PARAMETER_ERROR_MSG,
+        )
+
+        state = self._prepare_hot_water_state(
+            operating_mode,
+            nominal_setpoint,
+            reduced_setpoint,
+        )
+        await self._set_hot_water_state(state)
+
+    def _prepare_hot_water_state(
+        self,
+        operating_mode: str | None,
+        nominal_setpoint: float | None,
+        reduced_setpoint: float | None,
+    ) -> dict[str, Any]:
+        """Prepare the hot water state for setting."""
+        state: dict[str, Any] = {}
+        if operating_mode is not None:
+            state.update(
+                {"Parameter": "1600", "EnumValue": operating_mode, "Type": "1"},
+            )
+        if nominal_setpoint is not None:
+            state.update(
+                {"Parameter": "1610", "Value": str(nominal_setpoint), "Type": "1"},
+            )
+        if reduced_setpoint is not None:
+            state.update(
+                {"Parameter": "1612", "Value": str(reduced_setpoint), "Type": "1"},
+            )
+        if not state:
+            raise BSBLANError(NO_STATE_ERROR_MSG)
+        return state
+
+    async def _set_hot_water_state(self, state: dict[str, Any]) -> None:
+        """Set the hot water state."""
+        response = await self._request(base_path="/JS", data=state)
+        logger.debug("Response for setting: %s", response)

python_bsblan-0.6.3/src/bsblan/constants.py

@@ -0,0 +1,128 @@
+"""BSBLAN constants."""
+
+from __future__ import annotations
+
+from typing import Final, TypedDict
+
+
+# API Versions
+class APIConfig(TypedDict):
+    """Type for API configuration."""
+
+    heating: dict[str, str]
+    staticValues: dict[str, str]
+    device: dict[str, str]
+    sensor: dict[str, str]
+    hot_water: dict[str, str]
+
+
+API_V1: Final[APIConfig] = {
+    "heating": {
+        "700": "hvac_mode",
+        "710": "target_temperature",
+        "900": "hvac_mode2",
+        "8000": "hvac_action",
+        "8740": "current_temperature",
+        "8749": "room1_thermostat_mode",
+    },
+    "staticValues": {
+        "714": "min_temp",
+        "730": "max_temp",
+    },
+    "device": {
+        "6224": "device_identification",
+        "6225": "controller_family",
+        "6226": "controller_variant",
+    },
+    "sensor": {
+        "8700": "outside_temperature",
+        "8740": "current_temperature",
+    },
+    "hot_water": {
+        "1600": "operating_mode",
+        "1610": "nominal_setpoint",
+        "1612": "reduced_setpoint",
+        "1620": "release",
+        "1640": "legionella_function",
+        "1645": "legionella_setpoint",
+        "1641": "legionella_periodically",
+    },
+}
+
+API_V3: Final[APIConfig] = {
+    "heating": {
+        "700": "hvac_mode",
+        "710": "target_temperature",
+        "900": "hvac_mode2",
+        "8000": "hvac_action",
+        "8740": "current_temperature",
+        "8749": "room1_thermostat_mode",
+        "770": "room1_temp_setpoint_boost",
+    },
+    "staticValues": {
+        "714": "min_temp",
+        "716": "max_temp",
+    },
+    "device": {
+        "6224": "device_identification",
+        "6225": "controller_family",
+        "6226": "controller_variant",
+    },
+    "sensor": {
+        "8700": "outside_temperature",
+        "8740": "current_temperature",
+    },
+    "hot_water": {
+        "1600": "operating_mode",
+        "1610": "nominal_setpoint",
+        "1612": "reduced_setpoint",
+        "1620": "release",
+        "1640": "legionella_function",
+        "1645": "legionella_setpoint",
+        "1641": "legionella_periodically",
+    },
+}
+
+API_VERSIONS: Final[dict[str, APIConfig]] = {
+    "v1": API_V1,
+    "v3": API_V3,
+}
+
+# HVAC Modes
+HVAC_MODE_DICT: Final[dict[int, str]] = {
+    0: "off",
+    1: "auto",
+    2: "eco",
+    3: "heat",
+}
+
+HVAC_MODE_DICT_REVERSE: Final[dict[str, int]] = {
+    "off": 0,
+    "auto": 1,
+    "eco": 2,
+    "heat": 3,
+}
+
+# Error Messages
+INVALID_VALUES_ERROR_MSG: Final[str] = "Invalid values provided."
+NO_STATE_ERROR_MSG: Final[str] = "No state provided."
+VERSION_ERROR_MSG: Final[str] = "Version not supported"
+FIRMWARE_VERSION_ERROR_MSG: Final[str] = "Firmware version not available"
+TEMPERATURE_RANGE_ERROR_MSG: Final[str] = "Temperature range not initialized"
+API_VERSION_ERROR_MSG: Final[str] = "API version not set"
+MULTI_PARAMETER_ERROR_MSG: Final[str] = "Only one parameter can be set at a time"
+SESSION_NOT_INITIALIZED_ERROR_MSG: Final[str] = "Session not initialized"
+API_DATA_NOT_INITIALIZED_ERROR_MSG: Final[str] = "API data not initialized"
+
+
+# Other Constants
+DEFAULT_PORT: Final[int] = 80
+SCAN_INTERVAL: Final[int] = 12  # seconds
+
+# Configuration Keys
+CONF_PASSKEY: Final[str] = "passkey"
+
+# Attributes
+ATTR_TARGET_TEMPERATURE: Final[str] = "target_temperature"
+ATTR_INSIDE_TEMPERATURE: Final[str] = "inside_temperature"
+ATTR_OUTSIDE_TEMPERATURE: Final[str] = "outside_temperature"

python_bsblan-0.6.3/src/bsblan/exceptions.py

@@ -0,0 +1,42 @@
+"""Exceptions for BSB-Lan."""
+
+from __future__ import annotations
+
+
+class BSBLANError(Exception):
+    """Generic BSBLAN exception."""
+
+    message: str = "Unexpected response from the BSBLAN device."
+
+    def __init__(self, message: str | None = None) -> None:
+        """Initialize a new instance of the BSBLANError class."""
+        if message is not None:
+            self.message = message
+        super().__init__(self.message)
+
+
+class BSBLANConnectionError(BSBLANError):
+    """BSBLAN connection exception."""
+
+    message_timeout: str = "Timeout occurred while connecting to BSBLAN device."
+    message_error: str = "Error occurred while connecting to BSBLAN device."
+
+    def __init__(self, response: str | None = None) -> None:
+        """Initialize a new instance of the BSBLANConnectionError class."""
+        self.response = response
+        super().__init__(self.message)
+
+
+class BSBLANVersionError(BSBLANError):
+    """Raised when the BSBLAN device has an unsupported version."""
+
+    message: str = "The BSBLAN device has an unsupported version."
+
+
+class BSBLANInvalidParameterError(BSBLANError):
+    """Raised when an invalid parameter is provided."""
+
+    def __init__(self, parameter: str) -> None:
+        """Initialize a new instance of the BSBLANInvalidParameterError class."""
+        self.message = f"Invalid values provided: {parameter}"
+        super().__init__(self.message)

{python_bsblan-0.6.2 → python_bsblan-0.6.3}/src/bsblan/models.py

@@ -57,6 +57,8 @@ class State(DataClassJSONMixin):
         The current temperature of the climate system.
     room1_thermostat_mode : EntityInfo
         The thermostat mode of the climate system.
+    room1_temp_setpoint_boost : EntityInfo
+        The temperature setpoint boost of the climate system.
 
     """
 
@@ -66,6 +68,7 @@ class State(DataClassJSONMixin):
     hvac_action: EntityInfo
     current_temperature: EntityInfo
     room1_thermostat_mode: EntityInfo
+    room1_temp_setpoint_boost: EntityInfo
 
 
 @dataclass
@@ -84,6 +87,19 @@ class Sensor(DataClassJSONMixin):
     outside_temperature: EntityInfo
 
 
+@dataclass
+class HotWaterState(DataClassJSONMixin):
+    """Object holds info about object for hot water climate."""
+
+    operating_mode: EntityInfo
+    nominal_setpoint: EntityInfo
+    reduced_setpoint: EntityInfo
+    release: EntityInfo
+    legionella_function: EntityInfo
+    legionella_setpoint: EntityInfo
+    legionella_periodically: EntityInfo
+
+
 @dataclass
 class Device(DataClassJSONMixin):
     """Object holds bsblan device information.

python_bsblan-0.6.2/src/bsblan/bsblan.py

@@ -1,403 +0,0 @@
-"""Asynchronous Python client for BSB-Lan."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from asyncio.log import logger
-from dataclasses import dataclass, field
-from typing import Any, Mapping, TypedDict, cast
-
-import aiohttp
-from aiohttp.client import ClientSession
-from aiohttp.hdrs import METH_POST
-from aiohttp.helpers import BasicAuth
-from packaging import version as pkg_version
-from typing_extensions import Self
-from yarl import URL
-
-from .constants import (
-    DEVICE_INFO_API_V1,
-    DEVICE_INFO_API_V3,
-    HEATING_CIRCUIT1_API_V1,
-    HEATING_CIRCUIT1_API_V3,
-    HVAC_MODE_DICT,
-    HVAC_MODE_DICT_REVERSE,
-    INVALID_VALUES_ERROR_MSG,
-    NO_STATE_ERROR_MSG,
-    SENSORS_API_V1,
-    SENSORS_API_V3,
-    STATIC_VALUES_API_V1,
-    STATIC_VALUES_API_V3,
-    VERSION_ERROR_MSG,
-)
-from .exceptions import (
-    BSBLANConnectionError,
-    BSBLANError,
-    BSBLANInvalidParameterError,
-    BSBLANVersionError,
-)
-from .models import Device, Info, Sensor, State, StaticState
-
-logging.basicConfig(level=logging.DEBUG)
-
-
-@dataclass
-class BSBLANConfig:
-    """Configuration for BSBLAN."""
-
-    host: str
-    username: str | None = None
-    password: str | None = None
-    passkey: str | None = None
-    port: int = 80
-    request_timeout: int = 10
-
-
-@dataclass
-class BSBLAN:
-    """Main class for handling connections with BSBLAN."""
-
-    _heating_params: list[str] | None = None
-    _string_circuit1: str | None = None
-    _sensor_params: list[str] | None = None
-    _sensor_list: str | None = None
-    _static_params: list[str] | None = None
-    _static_list: str | None = None
-    _device_params: list[str] = field(default_factory=list)
-    _min_temp: float = 7.0
-    _max_temp: float = 25.0
-    _info: str | None = None
-    _auth: BasicAuth | None = None
-    _close_session: bool = False
-
-    def __init__(
-        self,
-        config: BSBLANConfig,
-        session: ClientSession | None = None,
-    ) -> None:
-        """Initialize the BSBLAN object.
-
-        Args:
-        ----
-            config: Configuration for the BSBLAN object.
-            session: The aiohttp session to use for the connection.
-
-        """
-        self.config = config
-        self.session = session
-        self._close_session = session is None
-        self._firmware_version: str | None = None
-
-    async def _fetch_firmware_version(self) -> None:
-        """Fetch the firmware version if not already available."""
-        if self._firmware_version is None:
-            device = await self.device()
-            self._firmware_version = device.version
-            logger.debug("BSBLAN version: %s", self._firmware_version)
-
-    async def __aenter__(self) -> Self:
-        """Enter method for the context manager.
-
-        Returns
-        -------
-            Self: The current instance of the context manager.
-
-        """
-        if self.session is None:
-            self.session = aiohttp.ClientSession()
-            self._close_session = True
-        return self
-
-    async def __aexit__(self, *args: object) -> None:
-        """Exit method for the context manager.
-
-        Args:
-        ----
-            *args: Arguments passed to the exit method.
-
-        """
-        if self._close_session and self.session:
-            await self.session.close()
-
-    # cSpell:ignore BSBLAN
-    async def _request(
-        self,
-        method: str = METH_POST,
-        base_path: str = "/JQ",
-        data: dict[str, object] | None = None,
-        params: Mapping[str, str | int] | str | None = None,
-    ) -> dict[str, Any]:
-        """Handle a request to a BSBLAN device.
-
-        A generic method for sending/handling HTTP requests done against
-        the BSBLAN API.
-
-        Args:
-        ----
-            method: HTTP method to use.
-            base_path: Base path to use.
-            data: Dictionary of data to send to the BSBLAN device.
-            params: string of parameters to send to the BSBLAN device to
-                retrieve certain data.
-
-        Returns:
-        -------
-            A Python dictionary (JSON decoded) with the response from
-            the BSBLAN API.
-
-        Raises:
-        ------
-            BSBLANConnectionError: If the connection to the BSBLAN device
-                fails.
-            BSBLANError: If receiving from the BSBLAN device an unexpected
-                response.
-
-        """
-        # retrieve passkey for custom url
-        if self.config.passkey:
-            base_path = f"/{self.config.passkey}{base_path}"
-
-        url = URL.build(
-            scheme="http",
-            host=self.config.host,
-            port=self.config.port,
-            path=base_path,
-        )
-
-        auth = None
-        if self.config.username and self.config.password:
-            auth = BasicAuth(self.config.username, self.config.password)
-
-        headers = {
-            "User-Agent": f"PythonBSBLAN/{self._firmware_version}",
-            "Accept": "application/json, */*",
-        }
-
-        if self.session is None:
-            self.session = ClientSession()
-            self._close_session = True
-
-        try:
-            async with asyncio.timeout(self.config.request_timeout):
-                async with self.session.request(
-                    method,
-                    url,
-                    auth=auth,
-                    params=params,
-                    json=data,
-                    headers=headers,
-                ) as response:
-                    response.raise_for_status()
-                    return cast(dict[str, Any], await response.json())
-        except asyncio.TimeoutError as e:
-            raise BSBLANConnectionError(BSBLANConnectionError.message_timeout) from e
-        except aiohttp.ClientError as e:
-            raise BSBLANConnectionError(BSBLANConnectionError.message_error) from e
-        except ValueError as e:
-            raise BSBLANError(str(e)) from e
-
-    async def state(self) -> State:
-        """Get the current state from BSBLAN device.
-
-        Returns
-        -------
-            A BSBLAN state object.
-
-        """
-        if not self._string_circuit1 or not self._heating_params:
-            # retrieve heating circuit 1
-            data = await self._get_dict_version()
-            data = await self._get_parameters(data["heating"])
-            self._string_circuit1 = str(data["string_par"])
-            self._heating_params = list(data["list"])
-
-        # retrieve heating circuit 1 and heating params so we can build the
-        # data structure (its circuit 1 because it can support 2 circuits)
-        data = await self._request(params={"Parameter": f"{self._string_circuit1}"})
-        data = dict(zip(self._heating_params, list(data.values()), strict=True))
-
-        # set hvac_mode with correct value
-        data["hvac_mode"]["value"] = HVAC_MODE_DICT[int(data["hvac_mode"]["value"])]
-        return State.from_dict(data)
-
-    async def sensor(self) -> Sensor:
-        """Get the sensor information from BSBLAN device.
-
-        Returns
-        -------
-            A BSBLAN sensor object.
-
-        """
-        if not self._sensor_params:
-            data = await self._get_dict_version()
-            data = await self._get_parameters(data["sensor"])
-            self._sensor_list = str(data["string_par"])
-            self._sensor_params = list(data["list"])
-
-        # retrieve sensor params so we can build the data structure
-        data = await self._request(params={"Parameter": f"{self._sensor_list}"})
-        data = dict(zip(self._sensor_params, list(data.values()), strict=True))
-        return Sensor.from_dict(data)
-
-    async def static_values(self) -> StaticState:
-        """Get the static information from BSBLAN device.
-
-        Returns
-        -------
-            A BSBLAN staticState object.
-
-        """
-        if not self._static_params:
-            data = await self._get_dict_version()
-            data = await self._get_parameters(data["staticValues"])
-            self._static_list = str(data["string_par"])
-            self._static_params = list(data["list"])
-
-        # retrieve sensor params so we can build the data structure
-        data = await self._request(params={"Parameter": f"{self._static_list}"})
-        data = dict(zip(self._static_params, list(data.values()), strict=True))
-        self._min_temp = data["min_temp"]["value"]
-        self._max_temp = data["max_temp"]["value"]
-        return StaticState.from_dict(data)
-
-    async def _get_dict_version(self) -> dict[Any, Any]:
-        """Get the version from device.
-
-        Returns
-        -------
-            A dictionary with dicts
-
-        """
-        await self._fetch_firmware_version()
-
-        if self._firmware_version is None:
-            msg = "Unable to fetch firmware version"
-            raise BSBLANError(msg)
-
-        if pkg_version.parse(self._firmware_version) < pkg_version.parse("1.2.0"):
-            return {
-                "heating": HEATING_CIRCUIT1_API_V1,
-                "staticValues": STATIC_VALUES_API_V1,
-                "device": DEVICE_INFO_API_V1,
-                "sensor": SENSORS_API_V1,
-            }
-        if pkg_version.parse(self._firmware_version) > pkg_version.parse("3.0.0"):
-            return {
-                "heating": HEATING_CIRCUIT1_API_V3,
-                "staticValues": STATIC_VALUES_API_V3,
-                "device": DEVICE_INFO_API_V3,
-                "sensor": SENSORS_API_V3,
-            }
-        raise BSBLANVersionError(VERSION_ERROR_MSG)
-
-    async def device(self) -> Device:
-        """Get BSBLAN device info.
-
-        Returns
-        -------
-            A BSBLAN device info object.
-
-        """
-        device_info = await self._request(base_path="/JI")
-        return Device.from_dict(device_info)
-
-    async def info(self) -> Info:
-        """Get information about the current heating system config.
-
-        Returns
-        -------
-            A BSBLAN info object about the heating system.
-
-        """
-        if not self._info or not self._device_params:
-            device_dict = await self._get_dict_version()
-            data = await self._get_parameters(device_dict["device"])
-            self._info = str(data["string_par"])
-            self._device_params = data["list"]
-
-        data = await self._request(params={"Parameter": f"{self._info}"})
-        data = dict(zip(self._device_params, list(data.values()), strict=True))
-        return Info.from_dict(data)
-
-    async def _get_parameters(self, params: dict[Any, Any]) -> dict[Any, Any]:
-        """Get the parameters info from BSBLAN device.
-
-        Args:
-        ----
-            params: A dictionary with the parameters to get.
-
-        Returns:
-        -------
-            A dict of 2 objects [str, list].
-
-        """
-        _string_params = [*params]
-        list_params = list(params.values())
-        # convert list of string to string
-        string_params = ",".join(map(str, _string_params))
-
-        return {"string_par": string_params, "list": list_params}
-
-    async def thermostat(
-        self,
-        target_temperature: str | None = None,
-        hvac_mode: str | None = None,
-    ) -> None:
-        """Change the state of the thermostat through BSB-Lan.
-
-        Args:
-        ----
-            target_temperature: Target temperature to set.
-            hvac_mode: Preset mode to set.
-
-        Raises:
-        ------
-            BSBLANError: The provided values are invalid.
-
-        """
-
-        class ThermostatState(  # lgtm [py/unused-local-variable]
-            TypedDict,
-            total=False,
-        ):
-            """Describe state dictionary that can be set on the thermostat."""
-
-            target_temperature: str
-            hvac_mode: str
-            Parameter: str
-            Value: str
-            Type: str
-            EnumValue: int
-
-        state: ThermostatState = {}
-
-        if target_temperature is not None:
-            if not (
-                float(self._min_temp)
-                <= float(target_temperature)
-                <= float(self._max_temp)
-            ):
-                raise BSBLANInvalidParameterError(
-                    INVALID_VALUES_ERROR_MSG + ": " + str(target_temperature),
-                )
-            state["Parameter"] = "710"
-            state["Value"] = target_temperature
-            state["Type"] = "1"
-
-        if hvac_mode is not None:
-            if hvac_mode not in HVAC_MODE_DICT_REVERSE:
-                raise BSBLANInvalidParameterError(
-                    INVALID_VALUES_ERROR_MSG + ": " + str(hvac_mode),
-                )
-            state["Parameter"] = "700"
-            state["EnumValue"] = HVAC_MODE_DICT_REVERSE[hvac_mode]
-            state["Type"] = "1"
-
-        if not state:
-            raise BSBLANError(NO_STATE_ERROR_MSG)
-
-        # Type needs to be 1 to really set value.
-        # Now it only checks if it could set value.
-        response = await self._request(base_path="/JS", data=dict(state))
-        logger.debug("response for setting: %s", response)

python_bsblan-0.6.2/src/bsblan/constants.py

@@ -1,81 +0,0 @@
-"""BSBLAN constants."""
-
-DEVICE_INFO_API_V1 = {
-    "6224": "device_identification",
-    "6225": "controller_family",
-    "6226": "controller_variant",
-}
-
-DEVICE_INFO_API_V3 = {
-    "6224.0": "device_identification",
-    "6225.0": "controller_family",
-    "6226.0": "controller_variant",
-}
-
-HEATING_CIRCUIT1_API_V1 = {
-    "700": "hvac_mode",
-    "710": "target_temperature",
-    "900": "hvac_mode2",
-    "8000": "hvac_action",
-    "8740": "current_temperature",
-    "8749": "room1_thermostat_mode",
-}
-
-HEATING_CIRCUIT1_API_V3 = {
-    "700.0": "hvac_mode",
-    "710.0": "target_temperature",
-    "900.0": "hvac_mode2",
-    "8000.0": "hvac_action",
-    "8740.0": "current_temperature",
-    "8749.0": "room1_thermostat_mode",
-}
-
-STATIC_VALUES_API_V1 = {
-    "714": "min_temp",
-    "730": "max_temp",
-}
-
-STATIC_VALUES_API_V3 = {
-    "714.0": "min_temp",
-    "716.0": "max_temp",
-}
-
-SENSORS_API_V1 = {
-    "8700": "outside_temperature",
-    "8740": "current_temperature",
-}
-SENSORS_API_V3 = {
-    "8700.0": "outside_temperature",
-    "8740.0": "current_temperature",
-}
-
-HEATING_CIRCUIT2 = [
-    "1000",
-    "1010",
-    "1011",
-    "1012",
-    "1014",
-    "1030",
-    "1200",
-    "8001",  # status_heating_circuit2
-    "8770",
-]
-
-# homeassistant values
-HVAC_MODE_DICT = {
-    0: "off",
-    1: "auto",
-    2: "eco",
-    3: "heat",
-}
-
-HVAC_MODE_DICT_REVERSE = {
-    "off": 0,
-    "auto": 1,
-    "eco": 2,
-    "heat": 3,
-}
-
-INVALID_VALUES_ERROR_MSG = "Invalid values provided."
-NO_STATE_ERROR_MSG = "No state provided."
-VERSION_ERROR_MSG = "Version not supported"

python_bsblan-0.6.2/src/bsblan/exceptions.py

@@ -1,78 +0,0 @@
-"""Exceptions for for BSB-Lan."""
-
-from __future__ import annotations
-
-
-class BSBLANError(Exception):
-    """Generic BSBLAN exception."""
-
-    message: str = "Unexpected response from the BSBLAN device."
-
-    def __init__(self, message: str | None = None) -> None:
-        """Initialize a new instance of the BSBLANError class.
-
-        Args:
-        ----
-            message: Optional error message to include in the exception.
-
-        Returns:
-        -------
-            None.
-
-        """
-        if message is not None:
-            self.message = message
-        super().__init__(self.message)
-
-
-class BSBLANConnectionError(BSBLANError):
-    """BSBLAN connection exception.
-
-    Attributes
-    ----------
-        response: The response received from the BSBLAN device.
-
-    """
-
-    message_timeout = "Timeout occurred while connecting to BSBLAN device."
-    message_error = "Error occurred while connecting to BSBLAN device."
-
-    def __init__(self, response: str | None = None) -> None:
-        """Initialize a new instance of the BSBLANConnectionError class.
-
-        Args:
-        ----
-            response: Optional error message to include in the exception.
-
-        Returns:
-        -------
-            None.
-
-        """
-        self.response = response
-        super().__init__(self.message)
-
-
-class BSBLANVersionError(BSBLANError):
-    """Raised when the BSBLAN device has an unsupported version."""
-
-    message = "The BSBLAN device has an unsupported version."
-
-
-class BSBLANInvalidParameterError(BSBLANError):
-    """Raised when an invalid parameter is provided."""
-
-    def __init__(self, parameter: str) -> None:
-        """Initialize a new instance of the BSBLANInvalidParameterError class.
-
-        Args:
-        ----
-            parameter: The invalid parameter.
-
-        Returns:
-        -------
-            None.
-
-        """
-        self.message = f"Invalid parameter: {parameter}"
-        super().__init__(self.message)