python-bsblan 0.6.4__tar.gz → 0.6.6__tar.gz

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/PKG-INFO

@@ -1,23 +1,24 @@
 Metadata-Version: 2.1
 Name: python-bsblan
-Version: 0.6.4
-Summary: Asynchronous Python client for BSBLAN
+Version: 0.6.6
+Summary: Asynchronous Python client for BSBLAN API
 Home-page: https://github.com/liudger/python-bsblan
 License: MIT
-Keywords: bsblan,thermostat,client,api
+Keywords: bsblan,thermostat,client,api,async
 Author: Willem-Jan van Rootselaar
 Author-email: liudgervr@gmail.com
 Maintainer: Willem-Jan van Rootselaar
 Maintainer-email: liudgervr@gmail.com
-Requires-Python: >=3.12,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: aiohttp (>=3.8.1)
 Requires-Dist: async-timeout (>=4.0.3,<5.0.0)

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "python-bsblan"
-version = "0.6.4"
-description = "Asynchronous Python client for BSBLAN"
+version = "0.6.6"
+description = "Asynchronous Python client for BSBLAN API"
 authors = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
 maintainers = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
 license = "MIT"
@@ -9,7 +9,7 @@ readme = "README.md"
 homepage = "https://github.com/liudger/python-bsblan"
 repository = "https://github.com/liudger/python-bsblan"
 documentation = "https://github.com/liudger/python-bsblan"
-keywords = ["bsblan", "thermostat", "client" , "api"]
+keywords = ["bsblan", "thermostat", "client" , "api", "async"]
 classifiers = [
   "Development Status :: 3 - Alpha",
   "Framework :: AsyncIO",
@@ -25,7 +25,7 @@ packages = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.12"
+python = "^3.11"
 aiohttp = ">=3.8.1"
 yarl = ">=1.7.2"
 packaging = ">=21.3"
@@ -34,9 +34,13 @@ async-timeout = "^4.0.3"
 mashumaro = "^3.13.1"
 orjson = "^3.9.10"
 
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/liudger/python-bsblan/issues"
+Changelog = "https://github.com/liudger/python-bsblan/releases"
+
 [tool.poetry.dev-dependencies]
 covdefaults = "^2.3.0"
-ruff = "^0.6.0"
+ruff = "^0.7.0"
 aresponses = "^3.0.0"
 black = "^24.0.0"
 blacken-docs = "^1.13.0"
@@ -44,8 +48,8 @@ coverage = "^7.0.5"
 flake8 = "^7.0.0"
 isort = "^5.11.4"
 mypy = "^1.0.0"
-pre-commit = "^3.0.0"
-pre-commit-hooks = "^4.3.0"
+pre-commit = "^4.0.0"
+pre-commit-hooks = "^5.0.0"
 pylint = "^3.0.0"
 pytest = "^8.0.0"
 pytest-asyncio = "^0.24.0"
@@ -59,27 +63,21 @@ safety = "^3.0.0"
 codespell = "^2.2.2"
 bandit = "^1.7.4"
 
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/liudger/python-bsblan/issues"
-Changelog = "https://github.com/liudger/python-bsblan/releases"
-
-[tool.coverage.report]
-show_missing = true
-fail_under = 53
 
 [tool.coverage.run]
 plugins = ["covdefaults"]
 source = ["bsblan"]
 
-[tool.isort]
-profile = "black"
-multi_line_output = 3
+[tool.coverage.report]
+show_missing = true
+fail_under = 53
 
 [tool.mypy]
 # Specify the target platform details in config, so your developers are
 # free to run mypy on Windows, Linux, or macOS and get consistent
 # results.
 platform = "linux"
+python_version = "3.11"
 
 # show error messages from unrelated files
 follow_imports = "normal"
@@ -106,9 +104,6 @@ warn_unused_configs = true
 warn_unused_ignores = true
 
 [tool.pylint.MASTER]
-extension-pkg-whitelist = [
-  "pydantic"
-]
 ignore= [
   "tests"
 ]
@@ -128,11 +123,11 @@ good-names = [
 ]
 
 [tool.pylint.DESIGN]
-max-attributes = 20
+max-attributes = 10
 
 [tool.pylint."MESSAGES CONTROL"]
 disable= [
-    "too-few-public-methods",
+    # "too-few-public-methods",
     "duplicate-code",
     "format",
     "unsubscriptable-object",
@@ -153,11 +148,16 @@ asyncio_mode = "auto"
 select = ["ALL"]
 ignore = [
   "ANN101", # Self... explanatory
+  "ANN102", # cls... Not classy enough
   "ANN401", # Opinioated warning on disallowing dynamically typed expressions
   "D203", # Conflicts with other rules
   "D213", # Conflicts with other rules
   "D417", # False positives in some occasions
   "PLR2004", # Just annoying, not really useful
+
+  # Conflicts with the Ruff formatter
+  "COM812",
+  "ISC001",
 ]
 
 [tool.ruff.lint.flake8-pytest-style]
@@ -167,9 +167,12 @@ fixture-parentheses = false
 [tool.ruff.lint.isort]
 known-first-party = ["bsblan"]
 
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = ["mashumaro.mixins.orjson.DataClassORJSONMixin"]
+
 [tool.ruff.lint.mccabe]
 max-complexity = 25
 
 [build-system]
-build-backend = "poetry.core.masonry.api"
 requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/src/bsblan/bsblan.py

@@ -11,7 +11,6 @@ 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 (
@@ -38,6 +37,7 @@ from .models import Device, HotWaterState, Info, Sensor, State, StaticState
 
 if TYPE_CHECKING:
     from aiohttp.client import ClientSession
+    from typing_extensions import Self
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
@@ -71,7 +71,12 @@ class BSBLAN:
     _initialized: bool = False
 
     async def __aenter__(self) -> Self:
-        """Enter the context manager."""
+        """Enter the context manager.
+
+        Returns:
+            Self: The initialized BSBLAN instance.
+
+        """
         if self.session is None:
             self.session = aiohttp.ClientSession()
             self._close_session = True
@@ -79,7 +84,12 @@ class BSBLAN:
         return self
 
     async def __aexit__(self, *args: object) -> None:
-        """Exit the context manager."""
+        """Exit the context manager.
+
+        Args:
+            *args: Variable length argument list.
+
+        """
         if self._close_session and self.session:
             await self.session.close()
 
@@ -100,7 +110,13 @@ class BSBLAN:
             self._set_api_version()
 
     def _set_api_version(self) -> None:
-        """Set the API version based on the firmware version."""
+        """Set the API version based on the firmware version.
+
+        Raises:
+            BSBLANError: If the firmware version is not set.
+            BSBLANVersionError: If the firmware version is not supported.
+
+        """
         if not self._firmware_version:
             raise BSBLANError(FIRMWARE_VERSION_ERROR_MSG)
 
@@ -126,7 +142,15 @@ class BSBLAN:
             )
 
     async def _initialize_api_data(self) -> APIConfig:
-        """Initialize and cache the API data."""
+        """Initialize and cache the API data.
+
+        Returns:
+            APIConfig: The API configuration data.
+
+        Raises:
+            BSBLANError: If the API version or data is not initialized.
+
+        """
         if self._api_data is None:
             if self._api_version is None:
                 raise BSBLANError(API_VERSION_ERROR_MSG)
@@ -143,7 +167,23 @@ class BSBLAN:
         data: dict[str, object] | None = None,
         params: Mapping[str, str | int] | str | None = None,
     ) -> dict[str, Any]:
-        """Handle a request to a BSBLAN device."""
+        """Handle a request to a BSBLAN device.
+
+        Args:
+            method (str): The HTTP method to use for the request.
+            base_path (str): The base path for the URL.
+            data (dict[str, object] | None): The data to send in the request body.
+            params (Mapping[str, str | int] | str | None): The query parameters
+                to include in the request.
+
+        Returns:
+            dict[str, Any]: The JSON response from the BSBLAN device.
+
+        Raises:
+            BSBLANConnectionError: If there is a connection error.
+            BSBLANError: If there is an error with the request.
+
+        """
         if self.session is None:
             raise BSBLANError(SESSION_NOT_INITIALIZED_ERROR_MSG)
         url = self._build_url(base_path)
@@ -170,7 +210,15 @@ class BSBLAN:
             raise BSBLANError(str(e)) from e
 
     def _build_url(self, base_path: str) -> URL:
-        """Build the URL for the request."""
+        """Build the URL for the request.
+
+        Args:
+            base_path (str): The base path for the URL.
+
+        Returns:
+            URL: The constructed URL.
+
+        """
         if self.config.passkey:
             base_path = f"/{self.config.passkey}{base_path}"
         return URL.build(
@@ -181,30 +229,63 @@ class BSBLAN:
         )
 
     def _get_auth(self) -> BasicAuth | None:
-        """Get the authentication for the request."""
+        """Get the authentication for the request.
+
+        Returns:
+            BasicAuth | None: The authentication object or None if no authentication
+                is required.
+
+        """
         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."""
+        """Get the headers for the request.
+
+        Returns:
+            dict[str, str]: 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."""
+        """Validate that exactly one parameter is provided.
+
+        Args:
+            *params: Variable length argument list of parameters to validate.
+            error_msg (str): The error message to raise if validation fails.
+
+        Raises:
+            BSBLANError: If the validation fails.
+
+        """
         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."""
+        """Get the parameters info from BSBLAN device.
+
+        Args:
+            params (dict[Any, Any]): The parameters to get info for.
+
+        Returns:
+            dict[Any, Any]: The parameters info from the 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."""
+        """Get the current state from BSBLAN device.
+
+        Returns:
+            State: The current state of the 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"]})
@@ -213,7 +294,12 @@ class BSBLAN:
         return State.from_dict(data)
 
     async def sensor(self) -> Sensor:
-        """Get the sensor information from BSBLAN device."""
+        """Get the sensor information from BSBLAN device.
+
+        Returns:
+            Sensor: The sensor information from the 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"]})
@@ -221,7 +307,12 @@ class BSBLAN:
         return Sensor.from_dict(data)
 
     async def static_values(self) -> StaticState:
-        """Get the static information from BSBLAN device."""
+        """Get the static information from BSBLAN device.
+
+        Returns:
+            StaticState: The static information from the 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"]})
@@ -229,12 +320,22 @@ class BSBLAN:
         return StaticState.from_dict(data)
 
     async def device(self) -> Device:
-        """Get BSBLAN device info."""
+        """Get BSBLAN device info.
+
+        Returns:
+            Device: The BSBLAN device information.
+
+        """
         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."""
+        """Get information about the current heating system config.
+
+        Returns:
+            Info: The 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"]})
@@ -246,7 +347,13 @@ class BSBLAN:
         target_temperature: str | None = None,
         hvac_mode: str | None = None,
     ) -> None:
-        """Change the state of the thermostat through BSB-Lan."""
+        """Change the state of the thermostat through BSB-Lan.
+
+        Args:
+            target_temperature (str | None): The target temperature to set.
+            hvac_mode (str | None): The HVAC mode to set.
+
+        """
         await self._initialize_temperature_range()
 
         self._validate_single_parameter(
@@ -263,11 +370,22 @@ class BSBLAN:
         target_temperature: str | None,
         hvac_mode: str | None,
     ) -> dict[str, Any]:
-        """Prepare the thermostat state for setting."""
+        """Prepare the thermostat state for setting.
+
+        Args:
+            target_temperature (str | None): The target temperature to set.
+            hvac_mode (str | None): The HVAC mode to set.
+
+        Returns:
+            dict[str, Any]: The prepared state for the thermostat.
+
+        """
         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"})
+            state.update(
+                {"Parameter": "710", "Value": target_temperature, "Type": "1"},
+            )
         if hvac_mode is not None:
             self._validate_hvac_mode(hvac_mode)
             state.update(
@@ -280,7 +398,16 @@ class BSBLAN:
         return state
 
     def _validate_target_temperature(self, target_temperature: str) -> None:
-        """Validate the target temperature."""
+        """Validate the target temperature.
+
+        Args:
+            target_temperature (str): The target temperature to validate.
+
+        Raises:
+            BSBLANError: If the temperature range is not initialized.
+            BSBLANInvalidParameterError: If the target temperature is invalid.
+
+        """
         if self._min_temp is None or self._max_temp is None:
             raise BSBLANError(TEMPERATURE_RANGE_ERROR_MSG)
 
@@ -292,17 +419,35 @@ class BSBLAN:
             raise BSBLANInvalidParameterError(target_temperature) from err
 
     def _validate_hvac_mode(self, hvac_mode: str) -> None:
-        """Validate the HVAC mode."""
+        """Validate the HVAC mode.
+
+        Args:
+            hvac_mode (str): The HVAC mode to validate.
+
+        Raises:
+            BSBLANInvalidParameterError: If the HVAC mode is invalid.
+
+        """
         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."""
+        """Set the thermostat state.
+
+        Args:
+            state (dict[str, Any]): The state to set for the thermostat.
+
+        """
         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."""
+        """Get the current hot water state from BSBLAN device.
+
+        Returns:
+            HotWaterState: The current hot water state.
+
+        """
         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"]})
@@ -311,20 +456,23 @@ class BSBLAN:
 
     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."""
+        """Change the state of the hot water system through BSB-Lan.
+
+        Args:
+            nominal_setpoint (float | None): The nominal setpoint temperature to set.
+            reduced_setpoint (float | None): The reduced setpoint temperature to set.
+
+        """
         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,
         )
@@ -332,16 +480,23 @@ class BSBLAN:
 
     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."""
+        """Prepare the hot water state for setting.
+
+        Args:
+            nominal_setpoint (float | None): The nominal setpoint temperature to set.
+            reduced_setpoint (float | None): The reduced setpoint temperature to set.
+
+        Returns:
+            dict[str, Any]: The prepared state for the hot water.
+
+        Raises:
+            BSBLANError: If no state is provided.
+
+        """
         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"},
@@ -355,6 +510,11 @@ class BSBLAN:
         return state
 
     async def _set_hot_water_state(self, state: dict[str, Any]) -> None:
-        """Set the hot water state."""
+        """Set the hot water state.
+
+        Args:
+            state (dict[str, Any]): The state to set for the hot water.
+
+        """
         response = await self._request(base_path="/JS", data=state)
         logger.debug("Response for setting: %s", response)

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/src/bsblan/constants.py

@@ -75,11 +75,14 @@ API_V3: Final[APIConfig] = {
     "hot_water": {
         "1600": "operating_mode",
         "1610": "nominal_setpoint",
+        "1614": "nominal_setpoint_max",
         "1612": "reduced_setpoint",
         "1620": "release",
         "1640": "legionella_function",
         "1645": "legionella_setpoint",
         "1641": "legionella_periodically",
+        "8830": "dhw_actual_value_top_temperature",
+        "8820": "state_dhw_pump",
     },
 }
 

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/src/bsblan/exceptions.py

@@ -9,7 +9,12 @@ class BSBLANError(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."""
+        """Initialize a new instance of the BSBLANError class.
+
+        Args:
+            message: Optional custom error message.
+
+        """
         if message is not None:
             self.message = message
         super().__init__(self.message)
@@ -22,7 +27,12 @@ class BSBLANConnectionError(BSBLANError):
     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."""
+        """Initialize a new instance of the BSBLANConnectionError class.
+
+        Args:
+            response: Optional response message.
+
+        """
         self.response = response
         super().__init__(self.message)
 
@@ -37,6 +47,11 @@ class BSBLANInvalidParameterError(BSBLANError):
     """Raised when an invalid parameter is provided."""
 
     def __init__(self, parameter: str) -> None:
-        """Initialize a new instance of the BSBLANInvalidParameterError class."""
+        """Initialize a new instance of the BSBLANInvalidParameterError class.
+
+        Args:
+            parameter: The invalid parameter that caused the error.
+
+        """
         self.message = f"Invalid values provided: {parameter}"
         super().__init__(self.message)

{python_bsblan-0.6.4 → python_bsblan-0.6.6}/src/bsblan/models.py

@@ -93,11 +93,14 @@ class HotWaterState(DataClassJSONMixin):
 
     operating_mode: EntityInfo
     nominal_setpoint: EntityInfo
+    nominal_setpoint_max: EntityInfo  # 1614
     reduced_setpoint: EntityInfo
     release: EntityInfo
     legionella_function: EntityInfo
     legionella_setpoint: EntityInfo
     legionella_periodically: EntityInfo
+    dhw_actual_value_top_temperature: EntityInfo  # 8830
+    state_dhw_pump: EntityInfo  # 8820
 
 
 @dataclass