Feature/websocket connection (#105)

* First tests

* Websocket Connection to device Messages, rework folder structure.

* Wallbox control

* Improved message handling

* Pylint

* fix tests

* Fix tests

* Fix update dropdown for wallbox charge mode

Author: derolli1976

custom_components/enpal_webparser/__init__.py

@@ -26,12 +26,19 @@
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
+from .wallbox_api import WallboxApiClient
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def _get_enpal_base_url(options: dict) -> str:
+    """Derive the Enpal Box base URL from the configured deviceMessages URL."""
+    url = options.get("url", "")
+    return url.replace("/deviceMessages", "").rstrip("/")
+
+
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     _LOGGER.info("[Enpal] async_setup called during Home Assistant startup")
     return True
@@ -41,17 +48,53 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     _LOGGER.info("[Enpal] async_setup_entry started for entry_id: %s", entry.entry_id)
     hass.data.setdefault(DOMAIN, {})
 
-    use_wallbox_addon = entry.options.get("use_wallbox_addon", False)
+    # Migration: Update existing config options
+    new_options = dict(entry.options)
+    needs_update = False
+    if "data_source" not in new_options:
+        _LOGGER.info("[Enpal] Migrating existing config - setting data_source to 'html'")
+        new_options["data_source"] = "html"
+        needs_update = True
+    # Rename use_wallbox_addon -> use_wallbox
+    if "use_wallbox_addon" in new_options:
+        new_options["use_wallbox"] = new_options.pop("use_wallbox_addon")
+        needs_update = True
+    if needs_update:
+        hass.config_entries.async_update_entry(entry, options=new_options)
+
+    use_wallbox = entry.options.get("use_wallbox", False)
 
     platforms = ["sensor"]
-    if use_wallbox_addon:
+    if use_wallbox:
         platforms.extend(["button", "switch", "select"])
 
-    hass.data[DOMAIN][entry.entry_id] = {
+    entry_data = {
         "config": entry.data,
         "platforms": platforms,
     }
 
+    # Create shared wallbox client for all wallbox platforms
+    if use_wallbox:
+        data_source = entry.options.get("data_source", "html")
+        enpal_base_url = _get_enpal_base_url(entry.options)
+
+        if data_source == "websocket":
+            # Native Blazor mode: connect directly to Enpal Box /wallbox page
+            wallbox_client = WallboxApiClient(
+                hass,
+                enpal_base_url=enpal_base_url,
+                use_native=True,
+            )
+            _LOGGER.info("[Enpal] Created native wallbox client for %s", enpal_base_url)
+        else:
+            # Legacy addon mode: HTTP calls to localhost:36725
+            wallbox_client = WallboxApiClient(hass, use_native=False)
+            _LOGGER.info("[Enpal] Created legacy addon wallbox client")
+
+        entry_data["wallbox_client"] = wallbox_client
+
+    hass.data[DOMAIN][entry.entry_id] = entry_data
+
     _LOGGER.debug("[Enpal] Entry options: %s", entry.options)
     _LOGGER.info("[Enpal] Setting up platforms for entry: %s", platforms)
 
@@ -61,14 +104,43 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         _LOGGER.exception("[Enpal] Failed to set up entry platforms: %s", e)
         raise ConfigEntryNotReady(f"Error setting up entry: {e}")
 
+    # Reload integration when options change (e.g. wallbox enabled/disabled)
+    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
+
     _LOGGER.info("[Enpal] async_setup_entry completed successfully for entry_id: %s", entry.entry_id)
     return True
 
 
+async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Reload integration when options change."""
+    _LOGGER.info("[Enpal] Options changed, reloading integration")
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     _LOGGER.info("[Enpal] async_unload_entry called for entry_id: %s", entry.entry_id)
 
-    platforms = hass.data[DOMAIN].get(entry.entry_id, {}).get("platforms", [])
+    entry_data = hass.data.get(DOMAIN, {}).get(entry.entry_id, {})
+
+    # Close wallbox client if exists
+    wallbox_client = entry_data.get("wallbox_client")
+    if wallbox_client:
+        try:
+            await wallbox_client.close()
+            _LOGGER.info("[Enpal] Wallbox client connection closed")
+        except Exception as e:
+            _LOGGER.warning("[Enpal] Error closing wallbox client: %s", e)
+
+    # Close API client if exists
+    coordinator = hass.data.get(DOMAIN, {}).get("coordinator")
+    if coordinator and hasattr(coordinator, 'api_client'):
+        try:
+            await coordinator.api_client.close()
+            _LOGGER.info("[Enpal] API client connection closed")
+        except Exception as e:
+            _LOGGER.warning("[Enpal] Error closing API client: %s", e)
+
+    platforms = entry_data.get("platforms", [])
     _LOGGER.debug("[Enpal] Unloading platforms: %s", platforms)
 
     unloaded = await hass.config_entries.async_unload_platforms(entry, platforms)

custom_components/enpal_webparser/api/__init__.py

@@ -0,0 +1,7 @@
+"""Enpal API Client Package"""
+from .base import EnpalApiClient
+from .websocket_client import EnpalWebSocketClient
+from .html_client import EnpalHtmlClient
+from .wallbox_client import WallboxBlazorClient
+
+__all__ = ["EnpalApiClient", "EnpalWebSocketClient", "EnpalHtmlClient", "WallboxBlazorClient"]

custom_components/enpal_webparser/api/base.py

@@ -0,0 +1,67 @@
+"""Abstract Base Class for Enpal API Clients"""
+from abc import ABC, abstractmethod
+from typing import Dict, List, Any, Optional, Callable, Awaitable
+
+
+class EnpalApiClient(ABC):
+    """Abstract base class for Enpal API clients"""
+
+    @abstractmethod
+    async def connect(self) -> bool:
+        """
+        Establish connection to Enpal Box.
+        
+        Returns:
+            True if connection successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    async def fetch_data(self) -> Dict:
+        """
+        Fetch data from Enpal Box.
+        
+        Returns:
+            Dictionary with structure:
+            {
+                'sensors': List[Dict[str, Any]],  # Sensor dictionaries
+                'source': str,  # 'html' or 'websocket'
+            }
+            
+            Sensor dict format:
+            {
+                'name': str,              # Friendly name with group prefix
+                'value': str,             # String representation of value
+                'unit': Optional[str],    # Unit (kWh, W, V, etc.)
+                'device_class': Optional[str],  # HA device class
+                'enabled': bool,          # If sensor group is enabled
+                'enpal_last_update': Optional[str],  # ISO timestamp
+                'group': str,             # Group name (Battery, Inverter, etc.)
+            }
+            
+        Raises:
+            RuntimeError: If not connected
+            TimeoutError: If data fetch times out
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close connection to Enpal Box"""
+        pass
+
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """
+        Check connection status.
+        
+        Returns:
+            True if connected, False otherwise
+        """
+        pass
+
+    def set_data_callback(
+        self, callback: Optional[Callable[[Dict], Awaitable[None]]]
+    ) -> None:
+        """Register a push-data callback. Only meaningful for push-capable clients."""
+        pass

custom_components/enpal_webparser/api/html_client.py

@@ -0,0 +1,108 @@
+"""HTML client for Enpal Box using existing HTML parser"""
+import logging
+from typing import Dict, List, Any
+import aiohttp
+from bs4 import BeautifulSoup
+
+from .base import EnpalApiClient
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EnpalHtmlClient(EnpalApiClient):
+    """HTML parser client for Enpal Box (legacy/fallback mode)"""
+    
+    def __init__(self, base_url: str, groups: List[str]):
+        """
+        Initialize HTML client.
+        
+        Args:
+            base_url: Base URL of Enpal Box (e.g., http://192.168.1.100)
+            groups: List of sensor groups to parse
+        """
+        self.base_url = base_url.rstrip('/')
+        self.groups = groups
+        self.session: aiohttp.ClientSession = None
+        self.connected: bool = False
+    
+    async def connect(self) -> bool:
+        """
+        Establish HTTP session.
+        
+        Returns:
+            True (HTTP doesn't need explicit connection)
+        """
+        self.session = aiohttp.ClientSession()
+        self.connected = True
+        _LOGGER.info("[Enpal HTML Client] HTTP session ready for %s", self.base_url)
+        return True
+    
+    async def fetch_data(self) -> Dict:
+        """
+        Fetch data from Enpal Box via HTTP and parse HTML.
+        
+        Returns:
+            Dictionary with 'sensors' key containing List[Dict[str, Any]]
+            
+        Raises:
+            RuntimeError: If not connected
+            Exception: If HTTP request fails
+        """
+        if not self.connected:
+            raise RuntimeError("Not connected to Enpal Box")
+        
+        url = f"{self.base_url}/deviceMessages"
+        
+        try:
+            _LOGGER.debug("[Enpal HTML Client] Fetching HTML from %s", url)
+            
+            async with self.session.get(url, timeout=30) as resp:
+                if resp.status != 200:
+                    raise Exception(f"HTTP {resp.status} from {url}")
+                
+                html = await resp.text()
+            
+            _LOGGER.debug("[Enpal HTML Client] HTML fetched, parsing...")
+            
+            # Parse HTML with BeautifulSoup
+            from bs4 import BeautifulSoup
+            
+            # Import parse function - handle both package and standalone mode
+            try:
+                from ..utils import parse_enpal_html_sensors
+            except ImportError:
+                # Standalone mode - import directly
+                import sys
+                from pathlib import Path
+                parent_dir = Path(__file__).parent.parent
+                sys.path.insert(0, str(parent_dir))
+                from utils import parse_enpal_html_sensors
+            
+            sensors = parse_enpal_html_sensors(html, self.groups)
+            
+            _LOGGER.info(
+                "[Enpal HTML Client] Parsed %d sensors from HTML",
+                len(sensors)
+            )
+            
+            return {
+                'sensors': sensors,
+                'source': 'html',
+            }
+            
+        except Exception as e:
+            _LOGGER.error("[Enpal HTML Client] Fetch failed: %s", e)
+            raise
+    
+    async def close(self) -> None:
+        """Close HTTP session"""
+        self.connected = False
+        
+        if self.session:
+            await self.session.close()
+        
+        _LOGGER.info("[Enpal HTML Client] Session closed")
+    
+    def is_connected(self) -> bool:
+        """Check if session is ready"""
+        return self.connected