weishaupt-webif-api 0.1.0__py3-none-any.whl

weishaupt_webif_api/__init__.py

@@ -0,0 +1,24 @@
+"""Asynchronous API for Weishaupt WebIF (Heat Pumps)."""
+
+__version__ = "0.1.0"
+
+from .api import WebifConnection
+from .const import EXPECTED_COUNTS, ColoredFormatter, Info
+from .exceptions import (
+    ConnectionTimeoutError,
+    McuResourceError,
+    SessionExpiredError,
+    WeishauptWebifError,
+)
+
+__all__ = [
+    "EXPECTED_COUNTS",
+    "ColoredFormatter",
+    "ConnectionTimeoutError",
+    "Info",
+    "McuResourceError",
+    "SessionExpiredError",
+    "WebifConnection",
+    "WeishauptWebifError",
+    "__version__",
+]

weishaupt_webif_api/__main__.py

@@ -0,0 +1,158 @@
+"""Command line interface for the Weishaupt WebIF API."""
+
+import argparse
+import asyncio
+import contextlib
+import logging
+import os
+from pathlib import Path
+
+from .api import WebifConnection
+from .const import ColoredFormatter
+
+
+async def _main(args: argparse.Namespace) -> None:
+    storage_path = Path(args.path) if args.path else Path.cwd()
+
+    # Configure logging for the console
+    logger = logging.getLogger("weishaupt_webif_api")
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logger.setLevel(log_level)
+
+    # Console Handler (Colored)
+    sh = logging.StreamHandler()
+    sh.setFormatter(ColoredFormatter())
+    logger.addHandler(sh)
+
+    # File Handler (Persistent log)
+    log_file = storage_path / "weishaupt_webif_api.log"
+    fh = logging.FileHandler(str(log_file))
+    fh.setFormatter(
+        logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s"),
+    )
+    logger.addHandler(fh)
+
+    logger.info("Starting Weishaupt WebIF API monitor for %s...", args.ip)
+    async with WebifConnection(
+        args.ip,
+        args.user,
+        args.password,
+        request_delay=args.request_delay,
+        cooldown_delay=args.cooldown_delay,
+        storage_path=storage_path,
+    ) as con:
+        try:
+            while True:
+                try:
+                    # Fetch all data
+                    if args.mock:
+                        data = await con.update_all_mock()
+                    else:
+                        data = await con.update_all()
+                    summary = ", ".join(
+                        [f"[{cat}]: {len(vals)}" for cat, vals in data.items()],
+                    )
+                    logger.info(
+                        "Update Success: %s. Next check in %ds.",
+                        summary,
+                        args.interval,
+                    )
+                    await asyncio.sleep(args.interval)
+                except (asyncio.CancelledError, KeyboardInterrupt):
+                    raise
+                except Exception as err:  # noqa: BLE001
+                    logger.error(  # noqa: TRY400
+                        "Update failed: %s. Retrying in %ds...",
+                        err,
+                        args.retry_interval,
+                    )
+                    await asyncio.sleep(args.retry_interval)
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            # Graceful exit on Ctrl+C
+            pass
+        except Exception as err:  # noqa: BLE001
+            logger.critical("Monitor encountered an error: %s", err)
+        finally:
+            logger.info("--- Final Communication Statistics ---")
+            for key, value in con.stats.items():
+                logger.info("%-20s: %s", key, value)
+
+
+def main() -> None:
+    """Sync wrapper for the entry point."""
+    parser = argparse.ArgumentParser(
+        description="Weishaupt WebIF API CLI",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "ip",
+        nargs="?" if os.environ.get("WEISHAUPT_IP") else None,
+        default=os.environ.get("WEISHAUPT_IP"),
+        help="IP address of the Weishaupt module (env: WEISHAUPT_IP)",
+    )
+    parser.add_argument(
+        "user",
+        nargs="?" if os.environ.get("WEISHAUPT_USER") else None,
+        default=os.environ.get("WEISHAUPT_USER"),
+        help="Login username (env: WEISHAUPT_USER)",
+    )
+    parser.add_argument(
+        "password",
+        nargs="?" if os.environ.get("WEISHAUPT_PASSWORD") else None,
+        default=os.environ.get("WEISHAUPT_PASSWORD"),
+        help="Login password (env: WEISHAUPT_PASSWORD)",
+    )
+    parser.add_argument(
+        "--path",
+        help="Directory to store logs and state files (defaults to execution folder)",
+        default=None,
+    )
+    parser.add_argument(
+        "--interval",
+        type=int,
+        help="Polling interval in seconds (default: 300)",
+        default=300,
+    )
+    parser.add_argument(
+        "--retry-interval",
+        type=int,
+        help="Retry interval after failure in seconds",
+        default=60,
+    )
+    parser.add_argument(
+        "--request-delay",
+        type=float,
+        help="Internal breather delay between requests in seconds",
+        default=60.0,
+    )
+    parser.add_argument(
+        "--cooldown-delay",
+        type=float,
+        help="Internal cooldown penalty after failure in seconds",
+        default=300.0,
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    parser.add_argument(
+        "--mock",
+        action="store_true",
+        help="Use mock data for development without polling the device",
+    )
+
+    args = parser.parse_args()
+
+    if not all([args.ip, args.user, args.password]):
+        parser.error(
+            "IP, user, and password must be provided via arguments or "
+            "environment variables.",
+        )
+
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(_main(args))
+
+
+if __name__ == "__main__":
+    main()

weishaupt_webif_api/api.py

@@ -0,0 +1,545 @@
+"""Main API module for Weishaupt WebIF communication."""
+
+import asyncio
+import json
+import logging
+import time
+import types
+from http.cookiejar import LWPCookieJar
+from pathlib import Path
+from typing import Any, Self
+
+import httpx
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+
+from .const import EXPECTED_COUNTS, UNITS, Info
+from .exceptions import (
+    ConnectionTimeoutError,
+    McuResourceError,
+    SessionExpiredError,
+    WeishauptWebifError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+MAX_STATS_REQS = 100
+HTTP_OK = 200
+
+
+class WebifConnection:
+    """A connection handler for the Weishaupt WebIF module.
+
+    This class manages an asynchronous HTTP session, handles authentication
+    via cookies, and provides methods to fetch and parse heat pump data.
+    It includes built-in rate-limiting and error recovery logic to avoid
+    overwhelming the heat pump microcontroller.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        ip: str,
+        user: str,
+        password: str,
+        *,
+        request_delay: float = 60.0,
+        cooldown_delay: float = 300.0,
+        storage_path: str | Path | None = None,
+    ) -> None:
+        """Initialize the connection.
+
+        :param ip: The IP address of the heat pump module.
+        :param user: The username for login.
+        :param password: The password for login.
+        :param storage_path: Optional path for storing cookies and state files.
+        :param request_delay: Breather delay between requests in seconds.
+        :param cooldown_delay: Cooldown penalty after failure in seconds.
+        """
+        self._ip = ip
+        self._username = user
+        self._password = password
+        self._client: httpx.AsyncClient | None = None
+        self._storage_path = Path(storage_path) if storage_path else Path.cwd()
+        self._storage_path.mkdir(parents=True, exist_ok=True)
+
+        self._state_file = self._storage_path / "lwp_state.json"
+        self._request_lock = asyncio.Lock()
+        self._request_delay = request_delay
+        self._cooldown_delay = cooldown_delay
+        self._last_request_time = 0.0  # Monotonic
+        self._cooldown_until = 0.0  # Monotonic
+        self._base_url = f"http://{self._ip}"
+        self._values: dict[str, dict[str, dict[str, Any]]] = {}
+        self._stats = {
+            "requests": 0,
+            "successes": 0,
+            "integrity_failures": 0,
+            "timeouts": 0,
+            "cooldowns": 0,
+            "max_duration": 0.0,
+        }
+
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """Load persisted timers from the state file."""
+        try:
+            with self._state_file.open(encoding="utf-8") as f:
+                state = json.load(f)
+                # Recover cooldown relative to current wall clock
+                expiry = state.get("cooldown_expiry", 0.0)
+                remaining = expiry - time.time()
+                if remaining > 0:
+                    self._cooldown_until = time.monotonic() + remaining
+                else:
+                    self._cooldown_until = 0.0
+        except (FileNotFoundError, json.JSONDecodeError):
+            self._cooldown_until = 0.0
+
+    def _save_state(self) -> None:
+        """Persist current timers to the state file."""
+        # Calculate wall-clock expiry for persistence
+        remaining = max(0, self._cooldown_until - time.monotonic())
+        state = {"cooldown_expiry": time.time() + remaining if remaining > 0 else 0.0}
+        with self._state_file.open("w", encoding="utf-8") as f:
+            json.dump(state, f)
+
+    def _get_client(self) -> httpx.AsyncClient:
+        """Initialize or return the existing httpx AsyncClient.
+
+        Sets up default headers and loads cookies from the local lwp_cookies.txt file
+        to maintain session state between script restarts.
+
+        :return: An active httpx.AsyncClient instance.
+        """
+        if self._client is None:
+            headers = {
+                "User-Agent": "Mozilla/5.0 Weishaupt-Webif-API/0.1.0",
+                "Accept": (
+                    "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+                ),
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Origin": self._base_url,
+                "Referer": f"{self._base_url}/login.html",
+                "Connection": "close",
+            }
+            cookie_file = self._storage_path / "lwp_cookies.txt"
+            cookies = LWPCookieJar(filename=str(cookie_file))
+            try:
+                cookies.load(ignore_discard=True)
+            except FileNotFoundError:
+                _LOGGER.debug("Starting with empty cookie jar.")
+
+            self._client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers=headers,
+                follow_redirects=True,
+                timeout=httpx.Timeout(60.0, connect=20.0),
+                limits=httpx.Limits(max_connections=1, max_keepalive_connections=0),
+                cookies=cookies,
+            )
+        return self._client
+
+    async def __aenter__(self) -> Self:
+        """Support async context manager."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
+        """Close client on exit."""
+        await self.close()
+
+    def _check_and_reset_stats(self, *, force: bool = False) -> None:
+        """Check if request count reached threshold, log and reset stats."""
+        req_count = self._stats["requests"]
+        if req_count >= MAX_STATS_REQS or (force and req_count > 0):
+            period = "final" if force else f"last {MAX_STATS_REQS} requests"
+            _LOGGER.info("Communication Statistics (%s): %s", period, self._stats)
+            # Update in place to maintain reference integrity
+            self._stats.update(
+                {
+                    "requests": 0,
+                    "successes": 0,
+                    "integrity_failures": 0,
+                    "timeouts": 0,
+                    "cooldowns": 0,
+                    "max_duration": 0.0,
+                },
+            )
+
+    @property
+    def stats(self) -> dict[str, int | float]:
+        """Return communication statistics."""
+        return self._stats
+
+    async def close(self) -> None:
+        """Gracefully close the underlying HTTP client."""
+        self._check_and_reset_stats(force=True)
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> httpx.Response:
+        """Perform a serialized HTTP request.
+
+        Ensures that only one request is active at a time and enforces cooldown
+        or breather delays before execution.
+
+        :param method: HTTP method (e.g., 'GET', 'POST').
+        :param url: The relative or absolute URL to request.
+        :return: The httpx.Response object.
+        """
+        async with self._request_lock:
+            now = time.monotonic()
+            if now < self._cooldown_until:
+                self._stats["cooldowns"] += 1
+                wait_time = self._cooldown_until - now
+                _LOGGER.warning("In COOLDOWN period. Waiting %.1fs", wait_time)
+                await asyncio.sleep(wait_time)
+                now = time.monotonic()
+
+            elapsed = now - self._last_request_time
+            if elapsed < self._request_delay:
+                time_to_wait = self._request_delay - elapsed
+                _LOGGER.debug("Breather delay: waiting %.1fs", time_to_wait)
+                await asyncio.sleep(time_to_wait)
+                now = time.monotonic()
+
+            return await self._do_request(method, url, **kwargs)
+
+    async def _do_request(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> httpx.Response:
+        """Execute an HTTP request and handle session expiration."""
+        self._check_and_reset_stats()
+        client = self._get_client()
+        self._stats["requests"] += 1
+        start_time = time.monotonic()
+
+        try:
+            response = await client.request(method, url, **kwargs)
+        except httpx.ConnectTimeout as err:
+            self._stats["timeouts"] += 1
+            self._last_request_time = time.monotonic()
+            self._cooldown_until = self._last_request_time + self._cooldown_delay
+            self._save_state()
+            msg = f"Connect timeout to {url}"
+            raise ConnectionTimeoutError(msg) from err
+        except httpx.ConnectError as err:
+            self._last_request_time = time.monotonic()
+            self._cooldown_until = self._last_request_time + self._cooldown_delay
+            self._save_state()
+            msg = f"Connection refused at {url}"
+            raise WeishauptWebifError(msg) from err
+        except httpx.ReadTimeout as err:
+            self._stats["timeouts"] += 1
+            self._last_request_time = time.monotonic()
+            self._cooldown_until = self._last_request_time + self._cooldown_delay
+            self._save_state()
+            msg = f"Read timeout from {url}"
+            raise ConnectionTimeoutError(msg) from err
+        except Exception as err:
+            if isinstance(err, WeishauptWebifError):
+                raise
+            msg = f"Unexpected error: {err}"
+            raise WeishauptWebifError(msg) from err
+        else:
+            duration = time.monotonic() - start_time
+            self._stats["max_duration"] = max(self._stats["max_duration"], duration)
+            self._last_request_time = time.monotonic()
+            self._save_state()
+
+            if "login.html" in str(response.url) or 'name="pass"' in response.text:
+                return await self._handle_expired_session(method, url, **kwargs)
+
+            _LOGGER.debug(
+                "WEBIF %s %s -> %s",
+                method,
+                response.url,
+                response.status_code,
+            )
+            return response
+
+    async def _handle_expired_session(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> httpx.Response:
+        """Handle re-authentication when session expires."""
+        if url != "/login.html":
+            _LOGGER.info("Session expired. Re-authenticating...")
+            await self._login()
+            # Retry original request after re-login
+            self._stats["requests"] += 1
+            start_retry = time.monotonic()
+            response = await self._get_client().request(method, url, **kwargs)
+            duration_retry = time.monotonic() - start_retry
+
+            self._stats["max_duration"] = max(
+                self._stats["max_duration"],
+                duration_retry,
+            )
+            self._last_request_time = time.monotonic()
+            self._save_state()
+            _LOGGER.debug(
+                "WEBIF %s %s -> %s (retry)",
+                method,
+                response.url,
+                response.status_code,
+            )
+            return response
+        msg = "Authentication failed: Redirected to login."
+        raise SessionExpiredError(msg)
+
+    async def _login(self) -> None:
+        """Perform the authentication process.
+
+        Sends a POST request with credentials and verifies the redirection URL.
+        Saves valid session cookies to the disk upon success.
+        """
+        client = self._get_client()
+        _LOGGER.info("Attempting login to Weishaupt WebIF...")
+
+        # Explicit direct request to avoid recursion through _do_request
+        self._stats["requests"] += 1
+        start_time = time.monotonic()
+
+        try:
+            response = await client.post(
+                "/login.html",
+                data={"user": self._username, "pass": self._password},
+            )
+            end_time = time.monotonic()
+            self._last_request_time = end_time
+            self._stats["max_duration"] = max(
+                self._stats["max_duration"],
+                end_time - start_time,
+            )
+            self._save_state()
+        except httpx.HTTPError as err:
+            # Errors during login are caught by the caller (_do_request or update_all)
+            msg = f"HTTP error during login: {err}"
+            raise WeishauptWebifError(msg) from err
+
+        final_url = str(response.url)
+        if "wrongpassword" in final_url:
+            msg = "Authentication failed: Invalid credentials."
+            raise WeishauptWebifError(msg)
+        if "nocon" in final_url:
+            msg = "MCU database connection failure."
+            raise McuResourceError(msg)
+        if "home.html" in final_url:
+            _LOGGER.info("✅ Successful Login!")
+            if self._client and isinstance(self._client.cookies.jar, LWPCookieJar):
+                self._client.cookies.jar.save(ignore_discard=True, ignore_expires=True)
+        else:
+            msg = "Login failed: Unexpected response."
+            raise WeishauptWebifError(msg)
+
+    async def update_all(
+        self,
+        categories: list[str] | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        """Fetch and update data categories from the heat pump.
+
+        :param categories: List of categories to fetch (e.g., ['Statistik']).
+        :return: A dictionary containing the updated data grouped by category.
+        :raises ValueError: If an invalid category name is provided.
+        :raises McuResourceError: If data integrity check fails.
+        """
+        requested = self._validate_categories(categories)
+
+        info_header = "0C00000100000000008000F9AF010002000301"
+        self._values.setdefault("Info", {})
+
+        # Respect original safe batching structure but filter for requested items
+        safe_batches = [["Heizkreis", "2WEZ", "Statistik"], ["Waermepumpe"]]
+        active_batches = []
+        for batch in safe_batches:
+            filtered = [c for c in batch if c in requested]
+            if filtered:
+                active_batches.append(filtered)
+
+        for batch_cats in active_batches:
+            stack_string = f"{info_header}," + ",".join([Info[c] for c in batch_cats])
+            url = f"/settings_export.html?stack={stack_string}"
+            response = await self._request("GET", url)
+            if response.status_code != HTTP_OK:
+                msg = f"HTTP {response.status_code}"
+                raise WeishauptWebifError(msg)
+
+            soup = BeautifulSoup(markup=response.text, features="html.parser")
+            cols = soup.find_all("div", class_="col-3")
+            if len(cols) < (2 + len(batch_cats)):
+                self._cooldown_until = time.monotonic() + self._cooldown_delay
+                self._stats["integrity_failures"] += 1
+                self._save_state()
+                msg = "Incomplete HTML: missing columns"
+                raise McuResourceError(msg)
+
+            for i, category in enumerate(batch_cats):
+                section_data = self._get_values(cols[i + 2])
+                found, expected = (
+                    len(section_data),
+                    EXPECTED_COUNTS.get(category, 0),
+                )
+                _LOGGER.debug(
+                    "Section [%s]: %d/%d entries",
+                    category,
+                    found,
+                    expected,
+                )
+                if found != expected or found == 0:
+                    self._stats["integrity_failures"] += 1
+                    self._cooldown_until = time.monotonic() + self._cooldown_delay
+                    self._save_state()
+                    msg = f"Data integrity error in {category}"
+                    raise McuResourceError(msg)
+                self._values["Info"][category] = section_data
+
+            self._stats["successes"] += 1
+
+        _LOGGER.debug("Update cycle successful.")
+        return self._values["Info"]
+
+    async def update_all_mock(
+        self,
+        categories: list[str] | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        """Return realistic data from a provided sample without polling.
+
+        :param categories: List of categories to fetch (e.g., ['Statistik']).
+        :return: A dictionary containing the mock data grouped by category.
+        :raises ValueError: If an invalid category name is provided.
+        """
+        requested = self._validate_categories(categories)
+
+        _LOGGER.debug("Returning static mock data for development.")
+        mock_data = self._get_mock_data()
+        return {cat: mock_data.get(cat, {}) for cat in requested}
+
+    def _validate_categories(self, categories: list[str] | None) -> list[str]:
+        """Validate requested categories against available ones."""
+        valid_categories = list(Info.keys())
+        requested = categories if categories is not None else valid_categories
+
+        for cat in requested:
+            if cat not in valid_categories:
+                msg = f"Invalid category '{cat}'. Valid options: {valid_categories}"
+                raise ValueError(msg)
+        return requested
+
+    def _get_mock_data(self) -> dict[str, dict[str, Any]]:
+        """Return the real-world data sample provided for development purposes."""
+        return {
+            "Heizkreis": {
+                "Außentemperatur": "24.5",
+                "AT Mittelwert": "25.0",
+                "AT Langzeitwert": "25.5",
+                "Raumsolltemperatur": "16.0",
+                "Vorlaufsolltemperatur": "--",
+                "Vorlauftemperatur": "62.0",
+            },
+            "Waermepumpe": {
+                "Betrieb": "PV Optimierung",
+                "Störmeldung": "--",
+                "Warmwassertemperatur": "53.0",
+                "Leistungsanforderung": "100",
+                "Solltemperatur": "59.5",
+                "Anforderung": "4.3",
+                "Schaltdifferenz dynamisch": "5.0",
+                "Vorlauftemperatur": "63.0",
+                "Rücklauftemperatur": "57.5",
+                "Drehzahl Pumpe M1": "80",
+                "Volumenstrom": "1.7",
+                "Stellung Umschaltventil": "Warmwasser",
+                "Version WWP-SG": "V3.0",
+                "Version WWP-EC WBB": "V5.3",
+                "Soll Leistung": "9.9",
+                "Ist Leistung": "9.6",
+                "Expansionsventil AG Eintr": "46.0",
+                "Luftansaugtemperatur": "24.5",
+                "Wärmetauscher AG Austrit": "15.0",
+                "Verdichtersauggastemp.": "23.0",
+                "EVI Sauggastemperatur": "57.5",
+                "Kältemittel IG Austritt": "54.0",
+                "Ölsumpftemperatur": "41.5",
+                "Druckgastemperatur": "95.0",
+                "Niederdruck": "10.3",
+                "Verdampfungstemperatur": "11.5",
+                "Hochdruck": "39.1",
+                "Kondensationstemperatur": "62.0",
+                "Mitteldruck": "20.8",
+                "Sättigungstemperatur EVI": "36.0",
+                "Überhitzung Heizen": "3.0",
+                "Öffnungsgrad EXV Heizen": "22",
+                "Überhitzung Verdichter": "11.0",
+                "Öffnungsgrad EXV Kühlen": "0",
+                "Überhitzung EVI": "21.5",
+                "Öffnungsgrad EVI": "48",
+                "Betriebsstd. Verdichter": "7704",
+                "Schaltspiele Verdichter": "3712",
+                "Schaltspiele Abtauen": "1490",
+                "Verdichter": "5013",
+                "Außengerät Variante": "RMHA-10",
+            },
+            "2WEZ": {
+                "Status": "0",
+                "Status E-Heizung 1": "Aus",
+                "Status E-Heizung 2": "Aus",
+                "Betriebsstunden E1": "106",
+                "Betriebsstunden E2": "71",
+                "Schaltspiele E1": "58",
+                "Schaltspiele E2": "20",
+            },
+            "Statistik": {
+                "th. Energie Heizen Tag": "1.630h",
+                "th. Energie WW Tag": "5.498h",
+                "th. Energie gesamt Tag": "7.129h",
+                "elektrische Energie Tag": "1.882h",
+                "th. Energie Heizen Monat": "3.832h",
+                "th. Energie WW Monat": "42.393h",
+                "th. Energie gesamt Monat": "46.226h",
+                "elektrische Energie Monat": "14.420h",
+                "th. Energie Heizen Jahr": "8474.162h",
+                "th. Energie WW Jahr": "1594.194h",
+                "th. Energie gesamt Jahr": "10068.356h",
+                "elektrische Energie Jahr": "3157.207h",
+            },
+        }
+
+    def _get_values(self, soup: Tag) -> dict[str, Any]:
+        """Parse parameter names and values from a specific HTML column.
+
+        This method strips known units (like °C or KWh) from the values
+        to return clean data.
+
+        :param soup: A BeautifulSoup Tag representing an HTML 'col-3' div.
+        :return: A dictionary of parameter names and their cleaned values.
+        """
+        soup_links = soup.find_all(name="div", class_="nav-link browseobj")
+        values: dict[str, Any] = {}
+        for item in soup_links:
+            if not isinstance(item, Tag):
+                continue
+            h5_tag = item.find("h5")
+            if h5_tag and h5_tag.text:
+                name = h5_tag.text.strip()
+                value = "".join(item.find_all(string=True, recursive=False))
+                for unit in UNITS:
+                    value = value.replace(unit, "").strip()
+                values[name] = value
+        return values

weishaupt_webif_api/const.py

@@ -0,0 +1,50 @@
+"""Constants and formatters for the Weishaupt WebIF API."""
+
+import logging
+from typing import ClassVar
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom logging formatter that applies ANSI color codes to output.
+
+    Designed to improve visibility of log levels in terminal environments.
+    """
+
+    grey = "\x1b[38;21m"
+    blue = "\x1b[34m"
+    yellow = "\x1b[33m"
+    red = "\x1b[31m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format_str = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+
+    FORMATS: ClassVar[dict[int, str]] = {
+        logging.DEBUG: grey + format_str + reset,
+        logging.INFO: blue + format_str + reset,
+        logging.WARNING: yellow + format_str + reset,
+        logging.ERROR: red + format_str + reset,
+        logging.CRITICAL: bold_red + format_str + reset,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format the log record with ANSI color codes."""
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+UNITS = ["m3/h", " KWh", " KW", " °C", " BAR", " rpm", " %", " K", " h"]
+
+Info = {
+    "Heizkreis": "0C000C1900000000000000F9AF020003000401",
+    "Waermepumpe": "0C000C2200000000000000F9AF020003000401",
+    "2WEZ": "0C000C2300000000000000F9AF020003000401",
+    "Statistik": "0C000C2700000000000000F9AF020003000401",
+}
+
+EXPECTED_COUNTS = {
+    "Heizkreis": 6,
+    "Waermepumpe": 41,
+    "2WEZ": 7,
+    "Statistik": 12,
+}

weishaupt_webif_api/exceptions.py

@@ -0,0 +1,17 @@
+"""Exception definitions for the Weishaupt WebIF API."""
+
+
+class WeishauptWebifError(Exception):
+    """Base class for all library errors."""
+
+
+class McuResourceError(WeishauptWebifError):
+    """Raised when the MCU is under memory pressure or rendering fails."""
+
+
+class SessionExpiredError(WeishauptWebifError):
+    """Raised when the session cookie is no longer valid."""
+
+
+class ConnectionTimeoutError(WeishauptWebifError):
+    """Raised when a request to the web server times out."""

weishaupt_webif_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: weishaupt-webif-api
+Version: 0.1.0
+Summary: Async Python library for the Weishaupt WebIF heat pump interface.
+Author-email: Mad_One <madone85@googlemail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MadOne/weishaupt_webif_api
+Project-URL: Repository, https://github.com/MadOne/weishaupt_webif_api
+Project-URL: Issues, https://github.com/MadOne/weishaupt_webif_api/issues
+Keywords: weishaupt,heatpump,heat-pump,home-assistant,hvac,webif
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Requires-Dist: beautifulsoup4>=4.12
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: respx>=0.20.0; extra == "test"
+Dynamic: license-file
+
+# Weishaupt WebIF API
+
+A Python library for interacting asynchronously with the Weishaupt heating system web interface (WebIF). This library allows you to programmatically retrieve telemetry data and system statistics.
+
+## Features
+
+- **Asynchronous Design**: Built on `httpx` and `asyncio` for non-blocking I/O.
+- **Selective Updates**: Fetch only the categories you need (e.g., "Statistik", "Heizkreis") to minimize load on the device's MCU.
+- **Persistence**: Automatically manages session cookies and internal state (cooldowns, request timing) across restarts using local storage.
+- **Smart Batching**: Includes logic to batch requests safely, preventing resource exhaustion on the hardware interface.
+- **Robust Error Handling**: Detects session expiration, login redirections, and MCU resource errors.
+- **Mock Mode**: Access real-world sample data without polling the device—perfect for developing Home Assistant integrations.
+- **CLI Monitor**: A built-in command-line tool to monitor your heat pump telemetry in real-time.
+
+## Installation
+
+Currently, this library can be installed locally:
+
+```bash
+pip install .
+```
+
+## Quick Start
+
+```python
+import asyncio
+from weishaupt_webif_api import WebifConnection
+
+async def main():
+    # Initialize the connection
+    async with WebifConnection(
+        ip="10.10.1.225", 
+        username="user", 
+        password="pass",
+        storage_path="./data"
+    ) as api:
+        # Fetch specific categories
+        data = await api.update_all(["Statistik", "Heizkreis"])
+
+        # Fetch mockup data for developement puposes. This is no real data and wont change!
+        mcok_data = await api.update_all_mock(["Statistik", "Heizkreis"])
+        
+        for category, values in data.items():
+            print(f"--- {category} ---")
+            for key, value in values.items():
+                print(f"{key}: {value}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+
+## Configuration & State
+
+The library creates several files in the `storage_path` to maintain state:
+
+- `lwp_cookies.txt`: Stores session cookies to avoid redundant logins.
+- `lwp_state.json`: Stores internal metadata, such as request cooldown timers.
+- `weishaupt_webif_api.log`: Contains diagnostic logs for troubleshooting.
+
+These files are excluded from version control by default via `.gitignore`.
+
+## Development
+
+### Running Tests
+
+The project uses `pytest` with `pytest-asyncio` and `respx` for mocking API responses.
+
+```bash
+pytest
+```
+
+Tests utilize HTML fixtures located in `tests/fixtures/` to simulate real device responses without requiring access to physical hardware.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Disclaimer
+
+*This project is not affiliated with or endorsed by Weishaupt. Use it at your own risk. Frequent polling can put significant stress on the device's web interface.*

weishaupt_webif_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+weishaupt_webif_api/__init__.py,sha256=7Mx1sZKivVrXuEx6X2PWsr_t_oGA6w5CkZUi5A5RzEk,525
+weishaupt_webif_api/__main__.py,sha256=uqWyGwLg25KGbgJJn_VhhntxkyrnMHHBIOU9xNvhhqk,5049
+weishaupt_webif_api/api.py,sha256=94SLSUeASAMqpJMm2g3HBwK0oaQJbH7Dv9D4wC4Qo5Y,21555
+weishaupt_webif_api/const.py,sha256=K5KBJKwNI0tn42-VDSOoarQreeStbrdDVFtJFFF9Uo0,1503
+weishaupt_webif_api/exceptions.py,sha256=O4RqJDB56nffgIIvWi7o7mPHp9YEtUVrUdiGV0LNKrg,489
+weishaupt_webif_api-0.1.0.dist-info/licenses/LICENSE,sha256=KNAADYhXKAIGySYjfCVq6P4ZDhIUFfHxeZFYa3-32ec,1055
+weishaupt_webif_api-0.1.0.dist-info/METADATA,sha256=hj4_uFJXwJ0k20xBScoGCpcbMVnTEj4lx6s6onwREyU,4103
+weishaupt_webif_api-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+weishaupt_webif_api-0.1.0.dist-info/entry_points.txt,sha256=muqMrVTiRAZShxx1hI-kbZY5aIqX2yc3r5dvSCwtu_o,68
+weishaupt_webif_api-0.1.0.dist-info/top_level.txt,sha256=Z571xeG36iafUuE_yPT_-skRoUDy0gxa9kXLYrY6yz4,20
+weishaupt_webif_api-0.1.0.dist-info/RECORD,,

weishaupt_webif_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

weishaupt_webif_api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+weishaupt-api = weishaupt_webif_api.__main__:main

weishaupt_webif_api-0.1.0.dist-info/licenses/LICENSE

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

weishaupt_webif_api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+weishaupt_webif_api