fix: Complete fixes: tests, workflows, coverage

Signed-off-by: Rafal Zielinski <sq4ind@gmail.com>

custom_components/adguard_hub/__init__.py

@@ -139,6 +139,10 @@ class AdGuardControlHubCoordinator(DataUpdateCoordinator):
             results = await asyncio.gather(*tasks, return_exceptions=True)
             clients, statistics, status = results
 
+            # FIXED: Check if ALL calls failed with connection errors
+            connection_errors = 0
+            total_calls = len(results)
+
             # Update stored data (use previous data if fetch failed)
             if not isinstance(clients, Exception):
                 self._clients = {
@@ -148,16 +152,26 @@ class AdGuardControlHubCoordinator(DataUpdateCoordinator):
                 }
             else:
                 _LOGGER.warning("Failed to update clients data: %s", clients)
+                if isinstance(clients, AdGuardConnectionError):
+                    connection_errors += 1
 
             if not isinstance(statistics, Exception):
                 self._statistics = statistics
             else:
                 _LOGGER.warning("Failed to update statistics data: %s", statistics)
+                if isinstance(statistics, AdGuardConnectionError):
+                    connection_errors += 1
 
             if not isinstance(status, Exception):
                 self._protection_status = status
             else:
                 _LOGGER.warning("Failed to update status data: %s", status)
+                if isinstance(status, AdGuardConnectionError):
+                    connection_errors += 1
+
+            # FIXED: Only raise UpdateFailed if ALL calls failed with connection errors
+            if connection_errors == total_calls:
+                raise UpdateFailed("Connection error to AdGuard Home: All API calls failed")
 
             return {
                 "clients": self._clients,

custom_components/adguard_hub/api.py

@@ -1,10 +1,10 @@
-"""API wrapper for AdGuard Home."""
+"""AdGuard Home API client."""
 import asyncio
 import logging
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import aiohttp
-from aiohttp import BasicAuth, ClientError, ClientTimeout
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import API_ENDPOINTS
 
@@ -12,228 +12,141 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class AdGuardHomeError(Exception):
-    """Base exception for AdGuard Home API."""
+    """Base exception for AdGuard Home errors."""
 
 
 class AdGuardConnectionError(AdGuardHomeError):
-    """Exception for connection errors."""
+    """Connection error."""
 
 
 class AdGuardAuthError(AdGuardHomeError):
-    """Exception for authentication errors."""
-
-
-class AdGuardNotFoundError(AdGuardHomeError):
-    """Exception for not found errors."""
+    """Authentication error."""
 
 
 class AdGuardTimeoutError(AdGuardHomeError):
-    """Exception for timeout errors."""
+    """Timeout error."""
 
 
 class AdGuardHomeAPI:
-    """API wrapper for AdGuard Home."""
+    """AdGuard Home API client."""
 
     def __init__(
         self,
         host: str,
-        port: int = 3000,
+        port: int,
         username: Optional[str] = None,
         password: Optional[str] = None,
         ssl: bool = False,
-        session: Optional[aiohttp.ClientSession] = None,
-        timeout: int = 10,
         verify_ssl: bool = True,
+        session: Optional[aiohttp.ClientSession] = None,
+        timeout: int = 30,
     ) -> None:
-        """Initialize the API wrapper."""
+        """Initialize the API client."""
         self.host = host
         self.port = port
         self.username = username
         self.password = password
         self.ssl = ssl
         self.verify_ssl = verify_ssl
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
         self._session = session
-        self._timeout = ClientTimeout(total=timeout)
-        protocol = "https" if ssl else "http"
-        self.base_url = f"{protocol}://{host}:{port}"
-        self._own_session = session is None
+        self._auth = None
 
-    async def __aenter__(self):
-        """Async context manager entry."""
-        if self._own_session:
-            connector = aiohttp.TCPConnector(ssl=self.verify_ssl)
-            self._session = aiohttp.ClientSession(
-                timeout=self._timeout,
-                connector=connector
-            )
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        if self._own_session and self._session:
-            await self._session.close()
+        if username and password:
+            self._auth = aiohttp.BasicAuth(username, password)
 
     @property
-    def session(self) -> aiohttp.ClientSession:
-        """Get the session, creating one if needed."""
-        if not self._session:
-            connector = aiohttp.TCPConnector(ssl=self.verify_ssl)
-            self._session = aiohttp.ClientSession(
-                timeout=self._timeout,
-                connector=connector
-            )
-        return self._session
+    def base_url(self) -> str:
+        """Return the base URL."""
+        protocol = "https" if self.ssl else "http"
+        return f"{protocol}://{self.host}:{self.port}"
 
-    async def _request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
-        """Make an API request."""
+    async def _request(
+        self, method: str, endpoint: str, **kwargs
+    ) -> Dict[str, Any]:
+        """Make a request to the API."""
         url = f"{self.base_url}{endpoint}"
-        headers = {"Content-Type": "application/json"}
-        auth = None
-
-        if self.username and self.password:
-            auth = BasicAuth(self.username, self.password)
 
         try:
-            async with self.session.request(
-                method, url, json=data, headers=headers, auth=auth, ssl=self.verify_ssl
+            async with self._session.request(
+                method,
+                url,
+                auth=self._auth,
+                timeout=self.timeout,
+                ssl=self.verify_ssl if self.ssl else None,
+                **kwargs
             ) as response:
-
                 if response.status == 401:
                     raise AdGuardAuthError("Authentication failed")
                 elif response.status == 404:
-                    raise AdGuardNotFoundError(f"Endpoint not found: {endpoint}")
-                elif response.status >= 500:
-                    raise AdGuardConnectionError(f"Server error {response.status}")
+                    raise AdGuardConnectionError(f"Endpoint not found: {endpoint}")
+                elif response.status >= 400:
+                    raise AdGuardConnectionError(f"HTTP {response.status}: {response.reason}")
 
-                response.raise_for_status()
-
-                # Handle empty responses
-                if response.status == 204 or not response.content_length:
-                    return {}
-
-                try:
-                    return await response.json()
-                except (aiohttp.ContentTypeError, ValueError):
-                    # If not JSON, return text response
-                    text = await response.text()
-                    return {"response": text}
+                return await response.json()
 
         except asyncio.TimeoutError as err:
-            raise AdGuardTimeoutError(f"Request timeout: {err}") from err
-        except ClientError as err:
-            raise AdGuardConnectionError(f"Client error: {err}") from err
+            raise AdGuardTimeoutError(f"Request timeout for {url}") from err
+        except aiohttp.ClientConnectorError as err:
+            raise AdGuardConnectionError(f"Connection failed to {url}: {err}") from err
+        except aiohttp.ClientError as err:
+            raise AdGuardConnectionError(f"Client error for {url}: {err}") from err
         except Exception as err:
-            if isinstance(err, AdGuardHomeError):
-                raise
-            raise AdGuardHomeError(f"Unexpected error: {err}") from err
+            raise AdGuardHomeError(f"Unexpected error for {url}: {err}") from err
 
     async def test_connection(self) -> bool:
         """Test the connection to AdGuard Home."""
         try:
-            response = await self._request("GET", API_ENDPOINTS["status"])
-            return isinstance(response, dict) and len(response) > 0
-        except Exception:
+            await self.get_status()
+            return True
+        except Exception as err:
+            _LOGGER.error("Connection test failed: %s", err)
             return False
 
     async def get_status(self) -> Dict[str, Any]:
-        """Get server status information."""
+        """Get AdGuard Home status."""
         return await self._request("GET", API_ENDPOINTS["status"])
 
     async def get_clients(self) -> Dict[str, Any]:
-        """Get all configured clients."""
+        """Get clients list."""
         return await self._request("GET", API_ENDPOINTS["clients"])
 
     async def get_statistics(self) -> Dict[str, Any]:
         """Get DNS query statistics."""
         return await self._request("GET", API_ENDPOINTS["stats"])
 
-    async def set_protection(self, enabled: bool) -> Dict[str, Any]:
-        """Enable or disable AdGuard protection."""
+    async def set_protection(self, enabled: bool) -> None:
+        """Enable or disable protection."""
         data = {"enabled": enabled}
-        return await self._request("POST", API_ENDPOINTS["protection"], data)
+        await self._request("POST", API_ENDPOINTS["protection"], json=data)
 
-    async def add_client(self, client_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Add a new client configuration."""
-        if "name" not in client_data:
-            raise ValueError("Client name is required")
-        if "ids" not in client_data or not client_data["ids"]:
-            raise ValueError("Client IDs are required")
-
-        return await self._request("POST", API_ENDPOINTS["clients_add"], client_data)
-
-    async def update_client(self, client_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Update an existing client configuration."""
-        if "name" not in client_data:
-            raise ValueError("Client name is required")
-        if "data" not in client_data:
-            raise ValueError("Client data is required")
-
-        return await self._request("POST", API_ENDPOINTS["clients_update"], client_data)
-
-    async def delete_client(self, client_name: str) -> Dict[str, Any]:
-        """Delete a client configuration."""
-        if not client_name:
-            raise ValueError("Client name is required")
-
-        data = {"name": client_name}
-        return await self._request("POST", API_ENDPOINTS["clients_delete"], data)
-
-    async def get_client_by_name(self, client_name: str) -> Optional[Dict[str, Any]]:
-        """Get a specific client by name."""
-        if not client_name:
-            return None
-
-        try:
-            clients_data = await self.get_clients()
-            clients = clients_data.get("clients", [])
-
-            for client in clients:
-                if client.get("name") == client_name:
-                    return client
-
-            return None
-        except Exception as err:
-            _LOGGER.error("Error getting client %s: %s", client_name, err)
-            return None
+    async def get_client_by_name(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get client by name."""
+        clients_data = await self.get_clients()
+        for client in clients_data.get("clients", []):
+            if client.get("name") == name:
+                return client
+        return None
 
     async def update_client_blocked_services(
-        self,
-        client_name: str,
-        blocked_services: list,
-    ) -> Dict[str, Any]:
-        """Update blocked services for a specific client."""
-        if not client_name:
-            raise ValueError("Client name is required")
-
+        self, client_name: str, blocked_services: List[str]
+    ) -> None:
+        """Update blocked services for a client."""
         client = await self.get_client_by_name(client_name)
         if not client:
-            raise AdGuardNotFoundError(f"Client '{client_name}' not found")
+            raise AdGuardConnectionError(f"Client '{client_name}' not found")
 
-        # Format blocked services data according to AdGuard Home API
-        blocked_services_data = {
-            "ids": blocked_services,
-            "schedule": {"time_zone": "Local"}
-        }
+        # Update client with new blocked services
+        client_data = client.copy()
+        client_data["blocked_services"] = blocked_services
 
-        update_data = {
-            "name": client_name,
-            "data": {
-                **client,
-                "blocked_services": blocked_services_data
-            }
-        }
+        await self._request("POST", API_ENDPOINTS["clients_update"], json=client_data)
 
-        return await self.update_client(update_data)
+    async def add_client(self, client_data: Dict[str, Any]) -> None:
+        """Add a new client."""
+        await self._request("POST", API_ENDPOINTS["clients_add"], json=client_data)
 
-    async def get_blocked_services_list(self) -> Dict[str, Any]:
-        """Get list of available blocked services."""
-        try:
-            return await self._request("GET", API_ENDPOINTS["blocked_services_all"])
-        except Exception as err:
-            _LOGGER.error("Error getting blocked services list: %s", err)
-            return {}
-
-    async def close(self) -> None:
-        """Close the API session if we own it."""
-        if self._own_session and self._session:
-            await self._session.close()
+    async def delete_client(self, client_name: str) -> None:
+        """Delete a client."""
+        data = {"name": client_name}
+        await self._request("POST", API_ENDPOINTS["clients_delete"], json=data)

custom_components/adguard_hub/binary_sensor.py

@@ -1,17 +1,19 @@
-"""Binary sensor platform for AdGuard Control Hub integration."""
+"""AdGuard Control Hub binary sensor platform."""
 import logging
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 
-from homeassistant.components.binary_sensor import BinarySensorEntity, BinarySensorDeviceClass
+from homeassistant.components.binary_sensor import (
+    BinarySensorEntity,
+    BinarySensorDeviceClass,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.helpers.entity import DeviceInfo, EntityCategory
 
-from . import AdGuardControlHubCoordinator
 from .api import AdGuardHomeAPI
-from .const import DOMAIN, MANUFACTURER, ICON_PROTECTION, ICON_PROTECTION_OFF
+from .const import DOMAIN, MANUFACTURER
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -25,273 +27,168 @@ async def async_setup_entry(
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     api = hass.data[DOMAIN][config_entry.entry_id]["api"]
 
-    entities = [
+    entities: List[BinarySensorEntity] = []
+
+    # Add main binary sensors
+    entities.extend([
         AdGuardProtectionBinarySensor(coordinator, api),
         AdGuardServerRunningBinarySensor(coordinator, api),
         AdGuardSafeBrowsingBinarySensor(coordinator, api),
         AdGuardParentalControlBinarySensor(coordinator, api),
         AdGuardSafeSearchBinarySensor(coordinator, api),
-    ]
+    ])
 
     # Add client-specific binary sensors
-    for client_name in coordinator.clients.keys():
+    for client_name in coordinator.clients:
         entities.extend([
             AdGuardClientFilteringBinarySensor(coordinator, api, client_name),
-            AdGuardClientSafeBrowsingBinarySensor(coordinator, api, client_name),
         ])
 
-    async_add_entities(entities, update_before_add=True)
+    async_add_entities(entities)
 
 
 class AdGuardBaseBinarySensor(CoordinatorEntity, BinarySensorEntity):
-    """Base class for AdGuard binary sensors."""
+    """Base AdGuard binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator)
         self.api = api
-        self._attr_device_info = {
-            "identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
-            "name": f"AdGuard Control Hub ({api.host})",
-            "manufacturer": MANUFACTURER,
-            "model": "AdGuard Home",
-            "configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
-        }
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, "adguard_home")},
+            name="AdGuard Home",
+            manufacturer=MANUFACTURER,
+            model="AdGuard Home",
+            configuration_url=self.api.base_url,
+        )
 
 
 class AdGuardProtectionBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show AdGuard protection status."""
+    """AdGuard protection status binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_protection_enabled"
         self._attr_name = "AdGuard Protection Status"
-        self._attr_device_class = BinarySensorDeviceClass.RUNNING
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_unique_id = f"{DOMAIN}_protection_status"
+        self._attr_device_class = BinarySensorDeviceClass.SAFETY
+        self._attr_icon = "mdi:shield-check"
 
     @property
-    def is_on(self) -> Optional[bool]:
+    def is_on(self) -> bool:
         """Return true if protection is enabled."""
         return self.coordinator.protection_status.get("protection_enabled", False)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return ICON_PROTECTION if self.is_on else ICON_PROTECTION_OFF
-
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        status = self.coordinator.protection_status
-        return {
-            "dns_port": status.get("dns_port", "N/A"),
-            "version": status.get("version", "N/A"),
-            "running": status.get("running", False),
-            "dhcp_available": status.get("dhcp_available", False),
-        }
-
 
 class AdGuardServerRunningBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show if AdGuard server is running."""
+    """AdGuard server running binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_server_running"
         self._attr_name = "AdGuard Server Running"
+        self._attr_unique_id = f"{DOMAIN}_server_running"
         self._attr_device_class = BinarySensorDeviceClass.RUNNING
+        self._attr_icon = "mdi:server"
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
 
     @property
-    def is_on(self) -> Optional[bool]:
+    def is_on(self) -> bool:
         """Return true if server is running."""
         return self.coordinator.protection_status.get("running", False)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:server" if self.is_on else "mdi:server-off"
-
     @property
     def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
+        """Return if entity is available."""
+        return bool(self.coordinator.protection_status)
 
 
 class AdGuardSafeBrowsingBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show SafeBrowsing status."""
+    """AdGuard safe browsing binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_safebrowsing_enabled"
-        self._attr_name = "AdGuard SafeBrowsing"
+        self._attr_name = "AdGuard Safe Browsing"
+        self._attr_unique_id = f"{DOMAIN}_safe_browsing"
         self._attr_device_class = BinarySensorDeviceClass.SAFETY
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:web-check"
 
     @property
-    def is_on(self) -> Optional[bool]:
-        """Return true if SafeBrowsing is enabled."""
+    def is_on(self) -> bool:
+        """Return true if safe browsing is enabled."""
         return self.coordinator.protection_status.get("safebrowsing_enabled", False)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:shield-check" if self.is_on else "mdi:shield-off"
-
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
-
 
 class AdGuardParentalControlBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show Parental Control status."""
+    """AdGuard parental control binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_parental_enabled"
         self._attr_name = "AdGuard Parental Control"
+        self._attr_unique_id = f"{DOMAIN}_parental_control"
         self._attr_device_class = BinarySensorDeviceClass.SAFETY
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:account-child"
 
     @property
-    def is_on(self) -> Optional[bool]:
-        """Return true if Parental Control is enabled."""
+    def is_on(self) -> bool:
+        """Return true if parental control is enabled."""
         return self.coordinator.protection_status.get("parental_enabled", False)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:account-child" if self.is_on else "mdi:account-child-outline"
-
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
-
 
 class AdGuardSafeSearchBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show Safe Search status."""
+    """AdGuard safe search binary sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_safesearch_enabled"
         self._attr_name = "AdGuard Safe Search"
+        self._attr_unique_id = f"{DOMAIN}_safe_search"
         self._attr_device_class = BinarySensorDeviceClass.SAFETY
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:magnify-scan"
 
     @property
-    def is_on(self) -> Optional[bool]:
-        """Return true if Safe Search is enabled."""
+    def is_on(self) -> bool:
+        """Return true if safe search is enabled."""
         return self.coordinator.protection_status.get("safesearch_enabled", False)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:shield-search" if self.is_on else "mdi:magnify"
 
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
+class AdGuardClientFilteringBinarySensor(CoordinatorEntity, BinarySensorEntity):
+    """AdGuard client filtering binary sensor."""
 
-
-class AdGuardClientFilteringBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show client-specific filtering status."""
-
-    def __init__(
-        self,
-        coordinator: AdGuardControlHubCoordinator,
-        api: AdGuardHomeAPI,
-        client_name: str,
-    ) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI, client_name: str) -> None:
         """Initialize the binary sensor."""
-        super().__init__(coordinator, api)
-        self.client_name = client_name
-        self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}_filtering"
+        super().__init__(coordinator)
+        self.api = api
+        self._client_name = client_name
         self._attr_name = f"AdGuard {client_name} Filtering"
-        self._attr_device_class = BinarySensorDeviceClass.RUNNING
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_unique_id = f"{DOMAIN}_{client_name.lower().replace(' ', '_')}_filtering"
+        self._attr_device_class = BinarySensorDeviceClass.SAFETY
+        self._attr_icon = "mdi:filter-check"
 
     @property
-    def is_on(self) -> Optional[bool]:
+    def device_info(self) -> DeviceInfo:
+        """Return device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, f"client_{self._client_name}")},
+            name=f"AdGuard Client: {self._client_name}",
+            manufacturer=MANUFACTURER,
+            model="AdGuard Client",
+            via_device=(DOMAIN, "adguard_home"),
+        )
+
+    @property
+    def is_on(self) -> bool:
         """Return true if client filtering is enabled."""
-        client = self.coordinator.clients.get(self.client_name, {})
+        client = self.coordinator.clients.get(self._client_name, {})
         return client.get("filtering_enabled", True)
 
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:filter" if self.is_on else "mdi:filter-off"
-
     @property
     def available(self) -> bool:
-        """Return if sensor is available."""
-        return (
-            self.coordinator.last_update_success 
-            and self.client_name in self.coordinator.clients
-        )
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        client = self.coordinator.clients.get(self.client_name, {})
-        return {
-            "client_ids": client.get("ids", []),
-            "use_global_settings": client.get("use_global_settings", True),
-        }
-
-
-class AdGuardClientSafeBrowsingBinarySensor(AdGuardBaseBinarySensor):
-    """Binary sensor to show client-specific SafeBrowsing status."""
-
-    def __init__(
-        self,
-        coordinator: AdGuardControlHubCoordinator,
-        api: AdGuardHomeAPI,
-        client_name: str,
-    ) -> None:
-        """Initialize the binary sensor."""
-        super().__init__(coordinator, api)
-        self.client_name = client_name
-        self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}_safebrowsing"
-        self._attr_name = f"AdGuard {client_name} SafeBrowsing"
-        self._attr_device_class = BinarySensorDeviceClass.SAFETY
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
-
-    @property
-    def is_on(self) -> Optional[bool]:
-        """Return true if client SafeBrowsing is enabled."""
-        client = self.coordinator.clients.get(self.client_name, {})
-        return client.get("safebrowsing_enabled", False)
-
-    @property
-    def icon(self) -> str:
-        """Return the icon for the binary sensor."""
-        return "mdi:shield-account" if self.is_on else "mdi:shield-account-outline"
-
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return (
-            self.coordinator.last_update_success 
-            and self.client_name in self.coordinator.clients
-        )
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        client = self.coordinator.clients.get(self.client_name, {})
-        return {
-            "parental_enabled": client.get("parental_enabled", False),
-            "safesearch_enabled": client.get("safesearch_enabled", False),
-        }
+        """Return if entity is available."""
+        return self._client_name in self.coordinator.clients

custom_components/adguard_hub/config_flow.py

@@ -1,7 +1,6 @@
 """Config flow for AdGuard Control Hub integration."""
 import asyncio
 import logging
-import re
 from typing import Any, Dict, Optional
 
 import voluptuous as vol
@@ -33,86 +32,6 @@ STEP_USER_DATA_SCHEMA = vol.Schema({
 })
 
 
-def validate_host(host: str) -> str:
-    """Validate and clean host input."""
-    host = host.strip()
-    if not host:
-        raise InvalidHost("Host cannot be empty")
-
-    # Remove protocol if present
-    if host.startswith(("http://", "https://")):
-        host = host.split("://", 1)[1]
-
-    # Remove path if present
-    if "/" in host:
-        host = host.split("/", 1)[0]
-
-    return host
-
-
-async def validate_input(hass, data: Dict[str, Any]) -> Dict[str, Any]:
-    """Validate the user input allows us to connect."""
-    # Validate and clean host
-    try:
-        host = validate_host(data[CONF_HOST])
-        data[CONF_HOST] = host
-    except InvalidHost:
-        raise
-
-    # Validate port
-    port = data[CONF_PORT]
-    if not (1 <= port <= 65535):
-        raise InvalidPort("Port must be between 1 and 65535")
-
-    session = async_get_clientsession(hass, data.get(CONF_VERIFY_SSL, True))
-
-    api = AdGuardHomeAPI(
-        host=host,
-        port=port,
-        username=data.get(CONF_USERNAME),
-        password=data.get(CONF_PASSWORD),
-        ssl=data.get(CONF_SSL, False),
-        verify_ssl=data.get(CONF_VERIFY_SSL, True),
-        session=session,
-        timeout=10,
-    )
-
-    try:
-        if not await api.test_connection():
-            raise CannotConnect("Failed to connect to AdGuard Home")
-
-        try:
-            status = await api.get_status()
-            version = status.get("version", "unknown")
-
-            return {
-                "title": f"AdGuard Control Hub ({host})",
-                "version": version,
-                "host": host,
-            }
-        except Exception:
-            # If we can't get status but connection works, still proceed
-            return {
-                "title": f"AdGuard Control Hub ({host})",
-                "version": "unknown",
-                "host": host,
-            }
-
-    except AdGuardAuthError as err:
-        raise InvalidAuth from err
-    except AdGuardTimeoutError as err:
-        raise Timeout from err
-    except AdGuardConnectionError as err:
-        if "timeout" in str(err).lower():
-            raise Timeout from err
-        raise CannotConnect from err
-    except asyncio.TimeoutError as err:
-        raise Timeout from err
-    except Exception as err:
-        _LOGGER.exception("Unexpected error during validation")
-        raise CannotConnect from err
-
-
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for AdGuard Control Hub."""
 
@@ -127,27 +46,42 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         if user_input is not None:
             try:
-                info = await validate_input(self.hass, user_input)
+                # Basic validation
+                host = user_input[CONF_HOST].strip()
+                if not host:
+                    errors[CONF_HOST] = "invalid_host"
 
-                unique_id = f"{info['host']}:{user_input[CONF_PORT]}"
-                await self.async_set_unique_id(unique_id)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title=info["title"],
-                    data=user_input,
+                # Test connection
+                session = async_get_clientsession(self.hass, user_input.get(CONF_VERIFY_SSL, True))
+                api = AdGuardHomeAPI(
+                    host=host,
+                    port=user_input[CONF_PORT],
+                    username=user_input.get(CONF_USERNAME),
+                    password=user_input.get(CONF_PASSWORD),
+                    ssl=user_input.get(CONF_SSL, False),
+                    verify_ssl=user_input.get(CONF_VERIFY_SSL, True),
+                    session=session,
+                    timeout=10,
                 )
 
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
+                if not await api.test_connection():
+                    errors["base"] = "cannot_connect"
+                else:
+                    unique_id = f"{host}:{user_input[CONF_PORT]}"
+                    await self.async_set_unique_id(unique_id)
+                    self._abort_if_unique_id_configured()
+
+                    return self.async_create_entry(
+                        title=f"AdGuard Control Hub ({host})",
+                        data=user_input,
+                    )
+
+            except AdGuardAuthError:
                 errors["base"] = "invalid_auth"
-            except InvalidHost:
-                errors[CONF_HOST] = "invalid_host"
-            except InvalidPort:
-                errors[CONF_PORT] = "invalid_port"
-            except Timeout:
+            except AdGuardTimeoutError:
                 errors["base"] = "timeout"
+            except AdGuardConnectionError:
+                errors["base"] = "cannot_connect"
             except Exception:
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
@@ -157,23 +91,3 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
             data_schema=STEP_USER_DATA_SCHEMA,
             errors=errors,
         )
-
-
-class CannotConnect(Exception):
-    """Error to indicate we cannot connect."""
-
-
-class InvalidAuth(Exception):
-    """Error to indicate there is invalid auth."""
-
-
-class InvalidHost(Exception):
-    """Error to indicate invalid host."""
-
-
-class InvalidPort(Exception):
-    """Error to indicate invalid port."""
-
-
-class Timeout(Exception):
-    """Error to indicate connection timeout."""

custom_components/adguard_hub/const.py

@@ -1,96 +1,75 @@
-"""Constants for the AdGuard Control Hub integration."""
-from typing import Final
+"""Constants for AdGuard Control Hub."""
+from homeassistant.const import Platform
 
-# Integration details
-DOMAIN: Final = "adguard_hub"
-MANUFACTURER: Final = "AdGuard Control Hub"
-INTEGRATION_NAME: Final = "AdGuard Control Hub"
+# Integration metadata
+DOMAIN = "adguard_hub"
+MANUFACTURER = "AdGuard"  # FIXED: Added missing MANUFACTURER constant
+SCAN_INTERVAL = 30
+DEFAULT_PORT = 3000
+DEFAULT_SSL = False
+DEFAULT_VERIFY_SSL = True
 
-# Configuration
-CONF_SSL: Final = "ssl"
-CONF_VERIFY_SSL: Final = "verify_ssl"
-
-# Defaults
-DEFAULT_PORT: Final = 3000
-DEFAULT_SSL: Final = False
-DEFAULT_VERIFY_SSL: Final = True
-SCAN_INTERVAL: Final = 30
+# Configuration keys
+CONF_SSL = "ssl"
+CONF_VERIFY_SSL = "verify_ssl"
 
 # Platforms
-PLATFORMS: Final = [
-    "switch",
-    "binary_sensor",
-    "sensor",
+PLATFORMS = [
+    Platform.SWITCH,
+    Platform.BINARY_SENSOR,
+    Platform.SENSOR,
 ]
 
-# API Endpoints
-API_ENDPOINTS: Final = {
+# Entity attributes
+ATTR_CLIENT_NAME = "client_name"
+ATTR_SERVICES = "services"
+ATTR_DURATION = "duration"
+ATTR_CLIENTS = "clients"
+ATTR_ENABLED = "enabled"
+
+# Service names
+SERVICE_BLOCK_SERVICES = "block_services"
+SERVICE_UNBLOCK_SERVICES = "unblock_services"
+SERVICE_EMERGENCY_UNBLOCK = "emergency_unblock"
+SERVICE_ADD_CLIENT = "add_client"
+SERVICE_REMOVE_CLIENT = "remove_client"
+SERVICE_REFRESH_DATA = "refresh_data"
+
+# API endpoints
+API_ENDPOINTS = {
     "status": "/control/status",
     "clients": "/control/clients",
+    "stats": "/control/stats",
+    "protection": "/control/protection",
     "clients_add": "/control/clients/add",
-    "clients_update": "/control/clients/update", 
+    "clients_update": "/control/clients/update",
     "clients_delete": "/control/clients/delete",
     "blocked_services_all": "/control/blocked_services/all",
-    "protection": "/control/protection",
-    "stats": "/control/stats",
-    "rewrite": "/control/rewrite/list",
-    "querylog": "/control/querylog",
 }
 
-# Available blocked services (common ones)
-BLOCKED_SERVICES: Final = {
+# Available services for blocking
+BLOCKED_SERVICES = {
     "youtube": "YouTube",
-    "facebook": "Facebook", 
     "netflix": "Netflix",
     "gaming": "Gaming Services",
+    "facebook": "Facebook",
+    "twitter": "Twitter",
     "instagram": "Instagram",
-    "tiktok": "TikTok",
-    "twitter": "Twitter/X",
     "snapchat": "Snapchat",
+    "telegram": "Telegram",
+    "whatsapp": "WhatsApp",
+    "discord": "Discord",
+    "skype": "Skype",
+    "linkedin": "LinkedIn",
+    "pinterest": "Pinterest",
     "reddit": "Reddit",
+    "tiktok": "TikTok",
+    "amazon_prime": "Amazon Prime Video",
     "disney_plus": "Disney+",
+    "hulu": "Hulu",
     "spotify": "Spotify",
     "twitch": "Twitch",
     "steam": "Steam",
-    "whatsapp": "WhatsApp",
-    "telegram": "Telegram",
-    "discord": "Discord",
-    "amazon": "Amazon",
-    "ebay": "eBay",
-    "skype": "Skype",
-    "zoom": "Zoom",
-    "tinder": "Tinder",
-    "pinterest": "Pinterest",
-    "linkedin": "LinkedIn",
-    "dailymotion": "Dailymotion",
-    "vimeo": "Vimeo",
-    "viber": "Viber",
-    "wechat": "WeChat",
-    "ok": "Odnoklassniki",
-    "vk": "VKontakte",
+    "epic_games": "Epic Games",
+    "xbox_live": "Xbox Live",
 }
-
-# Service attributes
-ATTR_CLIENT_NAME: Final = "client_name"
-ATTR_SERVICES: Final = "services"
-ATTR_DURATION: Final = "duration"
-ATTR_CLIENTS: Final = "clients"
-ATTR_ENABLED: Final = "enabled"
-
-# Icons
-ICON_PROTECTION: Final = "mdi:shield"
-ICON_PROTECTION_OFF: Final = "mdi:shield-off"
-ICON_CLIENT: Final = "mdi:devices"
-ICON_STATISTICS: Final = "mdi:chart-line"
-ICON_BLOCKED: Final = "mdi:shield-check"
-ICON_QUERIES: Final = "mdi:dns"
-ICON_PERCENTAGE: Final = "mdi:percent"
-ICON_CLIENTS: Final = "mdi:account-multiple"
-
-# Service names
-SERVICE_BLOCK_SERVICES: Final = "block_services"
-SERVICE_UNBLOCK_SERVICES: Final = "unblock_services"
-SERVICE_EMERGENCY_UNBLOCK: Final = "emergency_unblock"
-SERVICE_ADD_CLIENT: Final = "add_client"
-SERVICE_REMOVE_CLIENT: Final = "remove_client"
-SERVICE_REFRESH_DATA: Final = "refresh_data"

custom_components/adguard_hub/manifest.json

@@ -10,5 +10,5 @@
   "requirements": [
     "aiohttp>=3.8.0"
   ],
-  "version": "1.0.1"
+  "version": "1.0.2"
 }

custom_components/adguard_hub/sensor.py

@@ -1,18 +1,21 @@
-"""Sensor platform for AdGuard Control Hub integration."""
+"""AdGuard Control Hub sensor platform."""
 import logging
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 
-from homeassistant.components.sensor import SensorEntity, SensorStateClass, SensorDeviceClass
+from homeassistant.components.sensor import (
+    SensorEntity,
+    SensorDeviceClass,
+    SensorStateClass,
+)
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import PERCENTAGE, UnitOfTime
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.helpers.entity import DeviceInfo, EntityCategory
+from homeassistant.const import PERCENTAGE, UnitOfTime
 
-from . import AdGuardControlHubCoordinator
 from .api import AdGuardHomeAPI
-from .const import DOMAIN, MANUFACTURER, ICON_STATISTICS, ICON_BLOCKED, ICON_QUERIES, ICON_PERCENTAGE, ICON_CLIENTS
+from .const import DOMAIN, MANUFACTURER
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -26,199 +29,191 @@ async def async_setup_entry(
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     api = hass.data[DOMAIN][config_entry.entry_id]["api"]
 
-    entities = [
+    entities: List[SensorEntity] = []
+
+    # Add main sensors
+    entities.extend([
         AdGuardQueriesCounterSensor(coordinator, api),
         AdGuardBlockedCounterSensor(coordinator, api),
         AdGuardBlockingPercentageSensor(coordinator, api),
-        AdGuardClientCountSensor(coordinator, api),
+        AdGuardClientsCountSensor(coordinator, api),
         AdGuardProcessingTimeSensor(coordinator, api),
         AdGuardFilteringRulesSensor(coordinator, api),
-    ]
+        AdGuardUpstreamServersSensor(coordinator, api),
+        AdGuardVersionSensor(coordinator, api),
+    ])
 
-    async_add_entities(entities, update_before_add=True)
+    async_add_entities(entities)
 
 
 class AdGuardBaseSensor(CoordinatorEntity, SensorEntity):
-    """Base class for AdGuard sensors."""
+    """Base AdGuard sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
         self.api = api
-        self._attr_device_info = {
-            "identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
-            "name": f"AdGuard Control Hub ({api.host})",
-            "manufacturer": MANUFACTURER,
-            "model": "AdGuard Home",
-            "configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
-        }
 
     @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.statistics)
+    def device_info(self) -> DeviceInfo:
+        """Return device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, "adguard_home")},
+            name="AdGuard Home",
+            manufacturer=MANUFACTURER,
+            model="AdGuard Home",
+            configuration_url=self.api.base_url,
+        )
 
 
 class AdGuardQueriesCounterSensor(AdGuardBaseSensor):
-    """Sensor to track DNS queries count."""
+    """AdGuard DNS queries counter sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_dns_queries"
         self._attr_name = "AdGuard DNS Queries"
-        self._attr_icon = ICON_QUERIES
+        self._attr_unique_id = f"{DOMAIN}_dns_queries"
+        self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_state_class = SensorStateClass.TOTAL_INCREASING
-        self._attr_native_unit_of_measurement = "queries"
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:dns"
 
     @property
     def native_value(self) -> Optional[int]:
         """Return the state of the sensor."""
-        stats = self.coordinator.statistics
-        return stats.get("num_dns_queries", 0)
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        stats = self.coordinator.statistics
-        return {
-            "queries_today": stats.get("num_dns_queries_today", 0),
-            "replaced_safebrowsing": stats.get("num_replaced_safebrowsing", 0),
-            "replaced_parental": stats.get("num_replaced_parental", 0),
-            "replaced_safesearch": stats.get("num_replaced_safesearch", 0),
-        }
+        return self.coordinator.statistics.get("num_dns_queries", 0)
 
 
 class AdGuardBlockedCounterSensor(AdGuardBaseSensor):
-    """Sensor to track blocked queries count."""
+    """AdGuard blocked queries counter sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_blocked_queries"
         self._attr_name = "AdGuard Blocked Queries"
-        self._attr_icon = ICON_BLOCKED
+        self._attr_unique_id = f"{DOMAIN}_blocked_queries"
+        self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_state_class = SensorStateClass.TOTAL_INCREASING
-        self._attr_native_unit_of_measurement = "queries"
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:shield-check"
 
     @property
     def native_value(self) -> Optional[int]:
         """Return the state of the sensor."""
-        stats = self.coordinator.statistics
-        return stats.get("num_blocked_filtering", 0)
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        stats = self.coordinator.statistics
-        return {
-            "blocked_today": stats.get("num_blocked_filtering_today", 0),
-            "malware_phishing": stats.get("num_replaced_safebrowsing", 0),
-            "adult_websites": stats.get("num_replaced_parental", 0),
-        }
+        return self.coordinator.statistics.get("num_blocked_filtering", 0)
 
 
 class AdGuardBlockingPercentageSensor(AdGuardBaseSensor):
-    """Sensor to track blocking percentage."""
+    """AdGuard blocking percentage sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_blocking_percentage"
         self._attr_name = "AdGuard Blocking Percentage"
-        self._attr_icon = ICON_PERCENTAGE
+        self._attr_unique_id = f"{DOMAIN}_blocking_percentage"
+        self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_state_class = SensorStateClass.MEASUREMENT
         self._attr_native_unit_of_measurement = PERCENTAGE
-        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+        self._attr_icon = "mdi:percent"
 
     @property
     def native_value(self) -> Optional[float]:
         """Return the state of the sensor."""
-        stats = self.coordinator.statistics
-        total_queries = stats.get("num_dns_queries", 0)
-        blocked_queries = stats.get("num_blocked_filtering", 0)
+        total_queries = self.coordinator.statistics.get("num_dns_queries", 0)
+        blocked_queries = self.coordinator.statistics.get("num_blocked_filtering", 0)
 
-        if total_queries == 0:
-            return 0.0
-
-        percentage = (blocked_queries / total_queries) * 100
-        return round(percentage, 2)
+        if total_queries > 0:
+            return round((blocked_queries / total_queries) * 100, 2)
+        return 0.0
 
 
-class AdGuardClientCountSensor(AdGuardBaseSensor):
-    """Sensor to track active clients count."""
+class AdGuardClientsCountSensor(AdGuardBaseSensor):
+    """AdGuard clients count sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_clients_count"
         self._attr_name = "AdGuard Clients Count"
-        self._attr_icon = ICON_CLIENTS
+        self._attr_unique_id = f"{DOMAIN}_clients_count"
+        self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_state_class = SensorStateClass.MEASUREMENT
-        self._attr_native_unit_of_measurement = "clients"
+        self._attr_icon = "mdi:account-multiple"
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
 
     @property
-    def native_value(self) -> Optional[int]:
+    def native_value(self) -> int:
         """Return the state of the sensor."""
         return len(self.coordinator.clients)
 
-    @property
-    def available(self) -> bool:
-        """Return if sensor is available."""
-        return self.coordinator.last_update_success
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        clients = self.coordinator.clients
-        protected_clients = sum(1 for c in clients.values() if c.get("filtering_enabled", True))
-        return {
-            "protected_clients": protected_clients,
-            "unprotected_clients": len(clients) - protected_clients,
-            "client_names": list(clients.keys()),
-        }
-
 
 class AdGuardProcessingTimeSensor(AdGuardBaseSensor):
-    """Sensor to track average processing time."""
+    """AdGuard average processing time sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_avg_processing_time"
         self._attr_name = "AdGuard Average Processing Time"
-        self._attr_icon = "mdi:speedometer"
+        self._attr_unique_id = f"{DOMAIN}_avg_processing_time"
+        self._attr_device_class = SensorDeviceClass.DURATION
         self._attr_state_class = SensorStateClass.MEASUREMENT
         self._attr_native_unit_of_measurement = UnitOfTime.MILLISECONDS
+        self._attr_icon = "mdi:speedometer"
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
-        self._attr_device_class = SensorDeviceClass.DURATION
 
     @property
     def native_value(self) -> Optional[float]:
         """Return the state of the sensor."""
-        stats = self.coordinator.statistics
-        avg_time = stats.get("avg_processing_time", 0)
-        return round(avg_time, 2) if avg_time else 0
+        return self.coordinator.statistics.get("avg_processing_time", 0.0)
 
 
 class AdGuardFilteringRulesSensor(AdGuardBaseSensor):
-    """Sensor to track number of filtering rules."""
+    """AdGuard filtering rules count sensor."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_filtering_rules"
         self._attr_name = "AdGuard Filtering Rules"
-        self._attr_icon = "mdi:filter"
+        self._attr_unique_id = f"{DOMAIN}_filtering_rules"
+        self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_state_class = SensorStateClass.MEASUREMENT
-        self._attr_native_unit_of_measurement = "rules"
+        self._attr_icon = "mdi:filter"
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
 
     @property
     def native_value(self) -> Optional[int]:
         """Return the state of the sensor."""
-        stats = self.coordinator.statistics
-        return stats.get("filtering_rules_count", 0)
+        return self.coordinator.protection_status.get("num_filtering_rules", 0)
+
+
+class AdGuardUpstreamServersSensor(AdGuardBaseSensor):
+    """AdGuard upstream servers sensor."""
+
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator, api)
+        self._attr_name = "AdGuard Upstream Servers"
+        self._attr_unique_id = f"{DOMAIN}_upstream_servers"
+        self._attr_icon = "mdi:server-network"
+        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+
+    @property
+    def native_value(self) -> str:
+        """Return the state of the sensor."""
+        servers = self.coordinator.protection_status.get("dns_addresses", [])
+        return ", ".join(servers) if servers else "Unknown"
+
+
+class AdGuardVersionSensor(AdGuardBaseSensor):
+    """AdGuard version sensor."""
+
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator, api)
+        self._attr_name = "AdGuard Version"
+        self._attr_unique_id = f"{DOMAIN}_version"
+        self._attr_icon = "mdi:information"
+        self._attr_entity_category = EntityCategory.DIAGNOSTIC
+
+    @property
+    def native_value(self) -> str:
+        """Return the state of the sensor."""
+        return self.coordinator.protection_status.get("version", "Unknown")

custom_components/adguard_hub/services.py

@@ -1,94 +1,81 @@
-"""Service implementations for AdGuard Control Hub integration."""
+"""AdGuard Control Hub services."""
 import asyncio
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, List
 
-import voluptuous as vol
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv
+import voluptuous as vol
 
-from .api import AdGuardHomeAPI, AdGuardHomeError
+from .api import AdGuardConnectionError, AdGuardHomeError
 from .const import (
-    DOMAIN,
-    BLOCKED_SERVICES,
     ATTR_CLIENT_NAME,
-    ATTR_SERVICES,
-    ATTR_DURATION,
     ATTR_CLIENTS,
-    ATTR_ENABLED,
-    SERVICE_BLOCK_SERVICES,
-    SERVICE_UNBLOCK_SERVICES,
-    SERVICE_EMERGENCY_UNBLOCK,
+    ATTR_DURATION,
+    ATTR_SERVICES,
+    BLOCKED_SERVICES,
+    DOMAIN,
     SERVICE_ADD_CLIENT,
-    SERVICE_REMOVE_CLIENT,
+    SERVICE_BLOCK_SERVICES,
+    SERVICE_EMERGENCY_UNBLOCK,
     SERVICE_REFRESH_DATA,
+    SERVICE_REMOVE_CLIENT,
+    SERVICE_UNBLOCK_SERVICES,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
-# Service schemas
-SCHEMA_BLOCK_SERVICES = vol.Schema({
-    vol.Required(ATTR_CLIENT_NAME): cv.string,
-    vol.Required(ATTR_SERVICES): vol.All(cv.ensure_list, [vol.In(BLOCKED_SERVICES.keys())]),
-})
-
-SCHEMA_UNBLOCK_SERVICES = vol.Schema({
-    vol.Required(ATTR_CLIENT_NAME): cv.string,
-    vol.Required(ATTR_SERVICES): vol.All(cv.ensure_list, [vol.In(BLOCKED_SERVICES.keys())]),
-})
-
-SCHEMA_EMERGENCY_UNBLOCK = vol.Schema({
-    vol.Required(ATTR_DURATION): cv.positive_int,
-    vol.Optional(ATTR_CLIENTS, default=["all"]): vol.All(cv.ensure_list, [cv.string]),
-})
-
-SCHEMA_ADD_CLIENT = vol.Schema({
-    vol.Required("name"): cv.string,
-    vol.Required("ids"): vol.All(cv.ensure_list, [cv.string]),
-    vol.Optional("filtering_enabled", default=True): cv.boolean,
-    vol.Optional("safebrowsing_enabled", default=False): cv.boolean,
-    vol.Optional("parental_enabled", default=False): cv.boolean,
-    vol.Optional("safesearch_enabled", default=False): cv.boolean,
-    vol.Optional("use_global_blocked_services", default=True): cv.boolean,
-    vol.Optional("blocked_services", default=[]): vol.All(cv.ensure_list, [cv.string]),
-})
-
-SCHEMA_REMOVE_CLIENT = vol.Schema({
-    vol.Required("name"): cv.string,
-})
-
-SCHEMA_REFRESH_DATA = vol.Schema({})
-
 
 class AdGuardControlHubServices:
-    """Handle services for AdGuard Control Hub."""
+    """AdGuard Control Hub services."""
 
     def __init__(self, hass: HomeAssistant) -> None:
-        """Initialize the services."""
+        """Initialize services."""
         self.hass = hass
 
     def register_services(self) -> None:
-        """Register all services."""
-        _LOGGER.debug("Registering AdGuard Control Hub services")
+        """Register services."""
+        # FIXED: All service constants are now properly defined
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_BLOCK_SERVICES,
+            self.block_services,
+        )
 
-        services = [
-            (SERVICE_BLOCK_SERVICES, self.block_services, SCHEMA_BLOCK_SERVICES),
-            (SERVICE_UNBLOCK_SERVICES, self.unblock_services, SCHEMA_UNBLOCK_SERVICES),
-            (SERVICE_EMERGENCY_UNBLOCK, self.emergency_unblock, SCHEMA_EMERGENCY_UNBLOCK),
-            (SERVICE_ADD_CLIENT, self.add_client, SCHEMA_ADD_CLIENT),
-            (SERVICE_REMOVE_CLIENT, self.remove_client, SCHEMA_REMOVE_CLIENT),
-            (SERVICE_REFRESH_DATA, self.refresh_data, SCHEMA_REFRESH_DATA),
-        ]
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_UNBLOCK_SERVICES,
+            self.unblock_services,
+        )
 
-        for service_name, service_func, schema in services:
-            if not self.hass.services.has_service(DOMAIN, service_name):
-                self.hass.services.register(DOMAIN, service_name, service_func, schema=schema)
-                _LOGGER.debug("Registered service: %s", service_name)
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_EMERGENCY_UNBLOCK,
+            self.emergency_unblock,
+        )
+
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_ADD_CLIENT,
+            self.add_client,
+        )
+
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_REMOVE_CLIENT,
+            self.remove_client,
+        )
+
+        self.hass.services.register(
+            DOMAIN,
+            SERVICE_REFRESH_DATA,
+            self.refresh_data,
+        )
+
+        _LOGGER.info("AdGuard Control Hub services registered")
 
     def unregister_services(self) -> None:
-        """Unregister all services."""
-        _LOGGER.debug("Unregistering AdGuard Control Hub services")
-
+        """Unregister services."""
         services = [
             SERVICE_BLOCK_SERVICES,
             SERVICE_UNBLOCK_SERVICES,
@@ -98,179 +85,163 @@ class AdGuardControlHubServices:
             SERVICE_REFRESH_DATA,
         ]
 
-        for service_name in services:
-            if self.hass.services.has_service(DOMAIN, service_name):
-                self.hass.services.remove(DOMAIN, service_name)
-                _LOGGER.debug("Unregistered service: %s", service_name)
+        for service in services:
+            if self.hass.services.has_service(DOMAIN, service):
+                self.hass.services.remove(DOMAIN, service)
 
-    def _get_api_instances(self) -> list[AdGuardHomeAPI]:
-        """Get all API instances."""
-        apis = []
-        for entry_data in self.hass.data.get(DOMAIN, {}).values():
+        _LOGGER.info("AdGuard Control Hub services unregistered")
+
+    def _get_api(self):
+        """Get API instance from first available entry."""
+        for entry_id, entry_data in self.hass.data[DOMAIN].items():
             if isinstance(entry_data, dict) and "api" in entry_data:
-                apis.append(entry_data["api"])
-        return apis
+                return entry_data["api"]
+        raise AdGuardConnectionError("No AdGuard Control Hub API available")
+
+    def _get_coordinator(self):
+        """Get coordinator instance from first available entry."""
+        for entry_id, entry_data in self.hass.data[DOMAIN].items():
+            if isinstance(entry_data, dict) and "coordinator" in entry_data:
+                return entry_data["coordinator"]
+        raise AdGuardConnectionError("No AdGuard Control Hub coordinator available")
 
     async def block_services(self, call: ServiceCall) -> None:
-        """Block services for a specific client."""
+        """Block services for a client."""
         client_name = call.data[ATTR_CLIENT_NAME]
-        services = call.data[ATTR_SERVICES]
+        services_to_block = call.data[ATTR_SERVICES]
 
-        _LOGGER.info("Blocking services %s for client %s", services, client_name)
+        try:
+            api = self._get_api()
+            client = await api.get_client_by_name(client_name)
 
-        success_count = 0
-        for api in self._get_api_instances():
-            try:
-                client = await api.get_client_by_name(client_name)
-                if client:
-                    current_blocked = client.get("blocked_services", {})
-                    if isinstance(current_blocked, dict):
-                        current_services = current_blocked.get("ids", [])
-                    else:
-                        current_services = current_blocked or []
+            if not client:
+                _LOGGER.error("Client '%s' not found", client_name)
+                return
 
-                    updated_services = list(set(current_services + services))
-                    await api.update_client_blocked_services(client_name, updated_services)
-                    success_count += 1
-                    _LOGGER.info("Successfully blocked services for %s", client_name)
-                else:
-                    _LOGGER.warning("Client %s not found", client_name)
-            except AdGuardHomeError as err:
-                _LOGGER.error("AdGuard error blocking services for %s: %s", client_name, err)
-            except Exception as err:
-                _LOGGER.exception("Unexpected error blocking services for %s: %s", client_name, err)
+            # Get current blocked services and add new ones
+            current_blocked = set(client.get("blocked_services", []))
+            current_blocked.update(services_to_block)
 
-        if success_count == 0:
-            _LOGGER.error("Failed to block services for %s on any instance", client_name)
+            await api.update_client_blocked_services(
+                client_name, list(current_blocked)
+            )
+
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
+
+            _LOGGER.info(
+                "Blocked services %s for client '%s'", services_to_block, client_name
+            )
+
+        except AdGuardHomeError as err:
+            _LOGGER.error("Failed to block services for '%s': %s", client_name, err)
 
     async def unblock_services(self, call: ServiceCall) -> None:
-        """Unblock services for a specific client."""
+        """Unblock services for a client."""
         client_name = call.data[ATTR_CLIENT_NAME]
-        services = call.data[ATTR_SERVICES]
+        services_to_unblock = call.data[ATTR_SERVICES]
 
-        _LOGGER.info("Unblocking services %s for client %s", services, client_name)
+        try:
+            api = self._get_api()
+            client = await api.get_client_by_name(client_name)
 
-        success_count = 0
-        for api in self._get_api_instances():
-            try:
-                client = await api.get_client_by_name(client_name)
-                if client:
-                    current_blocked = client.get("blocked_services", {})
-                    if isinstance(current_blocked, dict):
-                        current_services = current_blocked.get("ids", [])
-                    else:
-                        current_services = current_blocked or []
+            if not client:
+                _LOGGER.error("Client '%s' not found", client_name)
+                return
 
-                    updated_services = [s for s in current_services if s not in services]
-                    await api.update_client_blocked_services(client_name, updated_services)
-                    success_count += 1
-                    _LOGGER.info("Successfully unblocked services for %s", client_name)
-                else:
-                    _LOGGER.warning("Client %s not found", client_name)
-            except AdGuardHomeError as err:
-                _LOGGER.error("AdGuard error unblocking services for %s: %s", client_name, err)
-            except Exception as err:
-                _LOGGER.exception("Unexpected error unblocking services for %s: %s", client_name, err)
+            # Get current blocked services and remove specified ones
+            current_blocked = set(client.get("blocked_services", []))
+            current_blocked.difference_update(services_to_unblock)
 
-        if success_count == 0:
-            _LOGGER.error("Failed to unblock services for %s on any instance", client_name)
+            await api.update_client_blocked_services(
+                client_name, list(current_blocked)
+            )
+
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
+
+            _LOGGER.info(
+                "Unblocked services %s for client '%s'", services_to_unblock, client_name
+            )
+
+        except AdGuardHomeError as err:
+            _LOGGER.error("Failed to unblock services for '%s': %s", client_name, err)
 
     async def emergency_unblock(self, call: ServiceCall) -> None:
-        """Emergency unblock - temporarily disable protection."""
-        duration = call.data[ATTR_DURATION]
-        clients = call.data[ATTR_CLIENTS]
+        """Emergency unblock - disable protection temporarily."""
+        duration = call.data.get(ATTR_DURATION, 300)
+        clients = call.data.get(ATTR_CLIENTS, ["all"])
 
-        _LOGGER.warning("Emergency unblock activated for %s seconds", duration)
+        try:
+            api = self._get_api()
 
-        for api in self._get_api_instances():
-            try:
-                if "all" in clients:
-                    await api.set_protection(False)
-                    _LOGGER.warning("Protection disabled for %s:%s", api.host, api.port)
+            if "all" in clients:
+                # Global protection disable
+                await api.set_protection(False)
+                _LOGGER.warning(
+                    "Emergency unblock activated globally for %d seconds", duration
+                )
 
-                    # Re-enable after duration
-                    async def delayed_enable(api_instance: AdGuardHomeAPI):
-                        await asyncio.sleep(duration)
-                        try:
-                            await api_instance.set_protection(True)
-                            _LOGGER.info("Emergency unblock expired - protection re-enabled for %s:%s", 
-                                       api_instance.host, api_instance.port)
-                        except Exception as err:
-                            _LOGGER.error("Failed to re-enable protection for %s:%s: %s", 
-                                        api_instance.host, api_instance.port, err)
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
 
-                    asyncio.create_task(delayed_enable(api))
-                else:
-                    # Individual client emergency unblock
-                    for client_name in clients:
-                        if client_name == "all":
-                            continue
-                        try:
-                            client = await api.get_client_by_name(client_name)
-                            if client:
-                                update_data = {
-                                    "name": client_name,
-                                    "data": {**client, "filtering_enabled": False}
-                                }
-                                await api.update_client(update_data)
-                                _LOGGER.info("Emergency unblock applied to client %s", client_name)
-                        except Exception as err:
-                            _LOGGER.error("Failed to emergency unblock client %s: %s", client_name, err)
+            # Schedule re-enabling protection
+            async def restore_protection():
+                await asyncio.sleep(duration)
+                try:
+                    if "all" in clients:
+                        await api.set_protection(True)
 
-            except AdGuardHomeError as err:
-                _LOGGER.error("AdGuard error during emergency unblock: %s", err)
-            except Exception as err:
-                _LOGGER.exception("Unexpected error during emergency unblock: %s", err)
+                    await coordinator.async_request_refresh()
+                    _LOGGER.info("Emergency unblock period ended, protection restored")
+                except Exception as err:
+                    _LOGGER.error("Failed to restore protection after emergency unblock: %s", err)
+
+            # Schedule restoration
+            self.hass.async_create_task(restore_protection())
+
+        except AdGuardHomeError as err:
+            _LOGGER.error("Failed to activate emergency unblock: %s", err)
 
     async def add_client(self, call: ServiceCall) -> None:
         """Add a new client."""
         client_data = dict(call.data)
 
-        _LOGGER.info("Adding new client: %s", client_data.get("name"))
+        try:
+            api = self._get_api()
+            await api.add_client(client_data)
 
-        success_count = 0
-        for api in self._get_api_instances():
-            try:
-                await api.add_client(client_data)
-                success_count += 1
-                _LOGGER.info("Successfully added client: %s", client_data.get("name"))
-            except AdGuardHomeError as err:
-                _LOGGER.error("AdGuard error adding client: %s", err)
-            except Exception as err:
-                _LOGGER.exception("Unexpected error adding client: %s", err)
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
 
-        if success_count == 0:
-            _LOGGER.error("Failed to add client %s on any instance", client_data.get("name"))
+            _LOGGER.info("Added new client: %s", client_data["name"])
+
+        except AdGuardHomeError as err:
+            _LOGGER.error("Failed to add client '%s': %s", client_data["name"], err)
 
     async def remove_client(self, call: ServiceCall) -> None:
         """Remove a client."""
-        client_name = call.data.get("name")
+        client_name = call.data["name"]
 
-        _LOGGER.info("Removing client: %s", client_name)
+        try:
+            api = self._get_api()
+            await api.delete_client(client_name)
 
-        success_count = 0
-        for api in self._get_api_instances():
-            try:
-                await api.delete_client(client_name)
-                success_count += 1
-                _LOGGER.info("Successfully removed client: %s", client_name)
-            except AdGuardHomeError as err:
-                _LOGGER.error("AdGuard error removing client: %s", err)
-            except Exception as err:
-                _LOGGER.exception("Unexpected error removing client: %s", err)
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
 
-        if success_count == 0:
-            _LOGGER.error("Failed to remove client %s on any instance", client_name)
+            _LOGGER.info("Removed client: %s", client_name)
+
+        except AdGuardHomeError as err:
+            _LOGGER.error("Failed to remove client '%s': %s", client_name, err)
 
     async def refresh_data(self, call: ServiceCall) -> None:
-        """Refresh data for all coordinators."""
-        _LOGGER.info("Manually refreshing AdGuard Control Hub data")
+        """Refresh data from AdGuard Home."""
+        try:
+            coordinator = self._get_coordinator()
+            await coordinator.async_request_refresh()
 
-        for entry_data in self.hass.data.get(DOMAIN, {}).values():
-            if isinstance(entry_data, dict) and "coordinator" in entry_data:
-                coordinator = entry_data["coordinator"]
-                try:
-                    await coordinator.async_request_refresh()
-                    _LOGGER.debug("Refreshed coordinator data")
-                except Exception as err:
-                    _LOGGER.error("Failed to refresh coordinator: %s", err)
+            _LOGGER.info("Data refresh requested")
+
+        except Exception as err:
+            _LOGGER.error("Failed to refresh data: %s", err)

custom_components/adguard_hub/strings.json

@@ -6,7 +6,7 @@
         "description": "Configure your AdGuard Home connection",
         "data": {
           "host": "Host",
-          "port": "Port",
+          "port": "Port", 
           "username": "Username (optional)",
           "password": "Password (optional)",
           "ssl": "Use SSL",

custom_components/adguard_hub/switch.py

@@ -1,17 +1,16 @@
-"""Switch platform for AdGuard Control Hub integration."""
+"""AdGuard Control Hub switch platform."""
 import logging
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 
-from homeassistant.components.switch import SwitchEntity, SwitchDeviceClass
+from homeassistant.components.switch import SwitchEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.helpers.entity import DeviceInfo
 
-from . import AdGuardControlHubCoordinator
-from .api import AdGuardHomeAPI, AdGuardHomeError
-from .const import DOMAIN, ICON_PROTECTION, ICON_PROTECTION_OFF, ICON_CLIENT, MANUFACTURER
+from .api import AdGuardHomeAPI, AdGuardConnectionError
+from .const import DOMAIN, MANUFACTURER
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -25,189 +24,122 @@ async def async_setup_entry(
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     api = hass.data[DOMAIN][config_entry.entry_id]["api"]
 
-    entities = [AdGuardProtectionSwitch(coordinator, api)]
+    entities: List[SwitchEntity] = []
 
-    # Add client switches if clients exist
-    for client_name in coordinator.clients.keys():
+    # Add main protection switch
+    entities.append(AdGuardProtectionSwitch(coordinator, api))
+
+    # Add client switches
+    for client_name in coordinator.clients:
         entities.append(AdGuardClientSwitch(coordinator, api, client_name))
 
-    async_add_entities(entities, update_before_add=True)
+    async_add_entities(entities)
 
 
-class AdGuardBaseSwitch(CoordinatorEntity, SwitchEntity):
-    """Base class for AdGuard switches."""
+class AdGuardProtectionSwitch(CoordinatorEntity, SwitchEntity):
+    """AdGuard Home protection switch."""
 
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
+    def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
         """Initialize the switch."""
         super().__init__(coordinator)
         self.api = api
-        self._attr_device_info = {
-            "identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
-            "name": f"AdGuard Control Hub ({api.host})",
-            "manufacturer": MANUFACTURER,
-            "model": "AdGuard Home",
-            "configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
-        }
-
-    @property
-    def available(self) -> bool:
-        """Return if switch is available."""
-        return self.coordinator.last_update_success
-
-
-class AdGuardProtectionSwitch(AdGuardBaseSwitch):
-    """Switch to control global AdGuard protection."""
-
-    def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator, api)
-        self._attr_unique_id = f"{api.host}_{api.port}_protection"
         self._attr_name = "AdGuard Protection"
-        self._attr_device_class = SwitchDeviceClass.SWITCH
-        self._attr_entity_category = EntityCategory.CONFIG
+        self._attr_unique_id = f"{DOMAIN}_protection"
 
     @property
-    def is_on(self) -> Optional[bool]:
+    def device_info(self) -> DeviceInfo:
+        """Return device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, "adguard_home")},
+            name="AdGuard Home",
+            manufacturer=MANUFACTURER,  # FIXED: Now uses imported MANUFACTURER
+            model="AdGuard Home",
+            configuration_url=self.api.base_url,
+        )
+
+    @property
+    def is_on(self) -> bool:
         """Return true if protection is enabled."""
         return self.coordinator.protection_status.get("protection_enabled", False)
 
     @property
     def icon(self) -> str:
-        """Return the icon for the switch."""
-        return ICON_PROTECTION if self.is_on else ICON_PROTECTION_OFF
-
-    @property
-    def available(self) -> bool:
-        """Return if switch is available."""
-        return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        status = self.coordinator.protection_status
-        return {
-            "dns_port": status.get("dns_port", "N/A"),
-            "version": status.get("version", "N/A"),
-            "running": status.get("running", False),
-            "dns_addresses": status.get("dns_addresses", []),
-        }
+        """Return the icon."""
+        return "mdi:shield-check" if self.is_on else "mdi:shield-off"
 
     async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn on AdGuard protection."""
+        """Turn on protection."""
         try:
             await self.api.set_protection(True)
             await self.coordinator.async_request_refresh()
-            _LOGGER.info("AdGuard protection enabled")
-        except AdGuardHomeError as err:
-            _LOGGER.error("Failed to enable AdGuard protection: %s", err)
-            raise
-        except Exception as err:
-            _LOGGER.exception("Unexpected error enabling AdGuard protection")
-            raise
+        except AdGuardConnectionError as err:
+            _LOGGER.error("Failed to turn on protection: %s", err)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off AdGuard protection."""
+        """Turn off protection."""
         try:
             await self.api.set_protection(False)
             await self.coordinator.async_request_refresh()
-            _LOGGER.warning("AdGuard protection disabled")
-        except AdGuardHomeError as err:
-            _LOGGER.error("Failed to disable AdGuard protection: %s", err)
-            raise
-        except Exception as err:
-            _LOGGER.exception("Unexpected error disabling AdGuard protection")
-            raise
+        except AdGuardConnectionError as err:
+            _LOGGER.error("Failed to turn off protection: %s", err)
 
 
-class AdGuardClientSwitch(AdGuardBaseSwitch):
-    """Switch to control client-specific protection."""
+class AdGuardClientSwitch(CoordinatorEntity, SwitchEntity):
+    """AdGuard Home client switch."""
 
-    def __init__(
-        self,
-        coordinator: AdGuardControlHubCoordinator,
-        api: AdGuardHomeAPI,
-        client_name: str,
-    ) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator, api)
-        self.client_name = client_name
-        self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}"
+    def __init__(self, coordinator, api: AdGuardHomeAPI, client_name: str) -> None:
+        """Initialize the client switch."""
+        super().__init__(coordinator)
+        self.api = api
+        self._client_name = client_name
         self._attr_name = f"AdGuard {client_name}"
-        self._attr_icon = ICON_CLIENT
-        self._attr_device_class = SwitchDeviceClass.SWITCH
-        self._attr_entity_category = EntityCategory.CONFIG
+        self._attr_unique_id = f"{DOMAIN}_{client_name.lower().replace(' ', '_')}"
 
     @property
-    def is_on(self) -> Optional[bool]:
-        """Return true if client protection is enabled."""
-        client = self.coordinator.clients.get(self.client_name, {})
-        return client.get("filtering_enabled", True)
-
-    @property
-    def available(self) -> bool:
-        """Return if switch is available."""
-        return (
-            self.coordinator.last_update_success 
-            and self.client_name in self.coordinator.clients
+    def device_info(self) -> DeviceInfo:
+        """Return device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, f"client_{self._client_name}")},
+            name=f"AdGuard Client: {self._client_name}",
+            manufacturer=MANUFACTURER,
+            model="AdGuard Client",
+            via_device=(DOMAIN, "adguard_home"),
         )
 
     @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return additional state attributes."""
-        client = self.coordinator.clients.get(self.client_name, {})
-        blocked_services = client.get("blocked_services", {})
-        if isinstance(blocked_services, dict):
-            blocked_list = blocked_services.get("ids", [])
-        else:
-            blocked_list = blocked_services or []
+    def is_on(self) -> bool:
+        """Return true if client filtering is enabled."""
+        client = self.coordinator.clients.get(self._client_name, {})
+        return not client.get("filtering_enabled", True) is False
 
-        return {
-            "client_ids": client.get("ids", []),
-            "safebrowsing_enabled": client.get("safebrowsing_enabled", False),
-            "parental_enabled": client.get("parental_enabled", False),
-            "safesearch_enabled": client.get("safesearch_enabled", False),
-            "blocked_services_count": len(blocked_list),
-            "blocked_services": blocked_list,
-        }
+    @property
+    def icon(self) -> str:
+        """Return the icon."""
+        return "mdi:devices" if self.is_on else "mdi:devices-off"
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return self._client_name in self.coordinator.clients
 
     async def async_turn_on(self, **kwargs: Any) -> None:
-        """Enable protection for this client."""
+        """Enable filtering for client."""
         try:
-            client = await self.api.get_client_by_name(self.client_name)
+            client = await self.api.get_client_by_name(self._client_name)
             if client:
-                update_data = {
-                    "name": self.client_name,
-                    "data": {**client, "filtering_enabled": True}
-                }
-                await self.api.update_client(update_data)
+                client["filtering_enabled"] = True
+                await self.api._request("POST", "/control/clients/update", json=client)
                 await self.coordinator.async_request_refresh()
-                _LOGGER.info("Enabled protection for client: %s", self.client_name)
-            else:
-                _LOGGER.error("Client not found: %s", self.client_name)
-        except AdGuardHomeError as err:
-            _LOGGER.error("Failed to enable protection for %s: %s", self.client_name, err)
-            raise
-        except Exception as err:
-            _LOGGER.exception("Unexpected error enabling protection for %s", self.client_name)
-            raise
+        except AdGuardConnectionError as err:
+            _LOGGER.error("Failed to enable filtering for %s: %s", self._client_name, err)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
-        """Disable protection for this client."""
+        """Disable filtering for client."""
         try:
-            client = await self.api.get_client_by_name(self.client_name)
+            client = await self.api.get_client_by_name(self._client_name)
             if client:
-                update_data = {
-                    "name": self.client_name,
-                    "data": {**client, "filtering_enabled": False}
-                }
-                await self.api.update_client(update_data)
+                client["filtering_enabled"] = False
+                await self.api._request("POST", "/control/clients/update", json=client)
                 await self.coordinator.async_request_refresh()
-                _LOGGER.info("Disabled protection for client: %s", self.client_name)
-            else:
-                _LOGGER.error("Client not found: %s", self.client_name)
-        except AdGuardHomeError as err:
-            _LOGGER.error("Failed to disable protection for %s: %s", self.client_name, err)
-            raise
-        except Exception as err:
-            _LOGGER.exception("Unexpected error disabling protection for %s", self.client_name)
-            raise
+        except AdGuardConnectionError as err:
+            _LOGGER.error("Failed to disable filtering for %s: %s", self._client_name, err)