Add BLE RPC support (#975)

Author: bdraco

aioshelly/block_device/device.py

@@ -84,6 +84,8 @@ def __init__(
         options: ConnectionOptions,
     ) -> None:
         """Device init."""
+        if options.ip_address is None:
+            raise ValueError("Block devices require ip_address")
         self.coap_context: COAP = coap_context
         self.aiohttp_session: ClientSession = aiohttp_session
         self.options: ConnectionOptions = options
@@ -114,6 +116,8 @@ async def create(
     ) -> BlockDevice:
         """Device creation."""
         options = await process_ip_or_options(ip_or_options)
+        if options.ip_address is None:
+            raise ValueError("Block devices require ip_address")
         # Try sending cit/s request to trigger a sleeping device
         try:
             await coap_context.request(options.ip_address, "s")
@@ -129,6 +133,8 @@ async def create(
     @property
     def ip_address(self) -> str:
         """Device ip address."""
+        if self.options.ip_address is None:
+            raise RuntimeError("Block device ip_address is None")
         return self.options.ip_address
 
     async def initialize(self) -> None:
@@ -150,10 +156,10 @@ async def initialize(self) -> None:
             self.initialized = False
             self.coap_s = None
 
-        ip = self.options.ip_address
+        ip = self.ip_address
         try:
             self._shelly = await get_info(
-                self.aiohttp_session, self.options.ip_address, self.options.device_mac
+                self.aiohttp_session, self.ip_address, self.options.device_mac
             )
 
             if self.requires_auth and not self.options.auth:
@@ -293,7 +299,7 @@ async def update_settings(self) -> None:
 
     async def update_shelly(self) -> None:
         """Device update for /shelly (HTTP)."""
-        self._shelly = await get_info(self.aiohttp_session, self.options.ip_address)
+        self._shelly = await get_info(self.aiohttp_session, self.ip_address)
 
     async def _update_cit_d(self) -> None:
         """Update CoAP cit/d.
@@ -349,7 +355,7 @@ async def http_request(
         if self.options.auth is None and self.requires_auth:
             raise InvalidAuthError("auth missing and required")
 
-        host = self.options.ip_address
+        host = self.ip_address
         _LOGGER.debug("host %s: http request: /%s (params=%s)", host, path, params)
         try:
             resp: ClientResponse = await self.aiohttp_session.request(

aioshelly/common.py

@@ -7,11 +7,14 @@
 import logging
 from dataclasses import dataclass
 from socket import gethostbyname
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from aiohttp import BasicAuth, ClientSession, ClientTimeout
 from yarl import URL
 
+if TYPE_CHECKING:
+    from bleak import BLEDevice
+
 from .const import (
     CONNECT_ERRORS,
     DEFAULT_HTTP_PORT,
@@ -37,16 +40,23 @@
 class ConnectionOptions:
     """Shelly options for connection."""
 
-    ip_address: str
+    ip_address: str | None = None
     username: str | None = None
     password: str | None = None
     temperature_unit: str = "C"
     auth: BasicAuth | None = None
     device_mac: str | None = None
     port: int = DEFAULT_HTTP_PORT
+    ble_device: BLEDevice | None = None
 
     def __post_init__(self) -> None:
         """Call after initialization."""
+        if self.ip_address is None and self.ble_device is None:
+            raise ValueError("Must provide either ip_address or ble_device")
+
+        if self.ip_address is not None and self.ble_device is not None:
+            raise ValueError("Cannot provide both ip_address and ble_device")
+
         if self.username is not None:
             if self.password is None:
                 raise ValueError("Supply both username and password")
@@ -60,17 +70,19 @@ def __post_init__(self) -> None:
 async def process_ip_or_options(ip_or_options: IpOrOptionsType) -> ConnectionOptions:
     """Return ConnectionOptions class from ip str or ConnectionOptions."""
     if isinstance(ip_or_options, str):
-        options = ConnectionOptions(ip_or_options)
+        options = ConnectionOptions(ip_address=ip_or_options)
     else:
         options = ip_or_options
 
-    try:
-        ipaddress.ip_address(options.ip_address)
-    except ValueError:
-        loop = asyncio.get_running_loop()
-        options.ip_address = await loop.run_in_executor(
-            None, gethostbyname, options.ip_address
-        )
+    # Only process IP address if provided (not for BLE connections)
+    if options.ip_address is not None:
+        try:
+            ipaddress.ip_address(options.ip_address)
+        except ValueError:
+            loop = asyncio.get_running_loop()
+            options.ip_address = await loop.run_in_executor(
+                None, gethostbyname, options.ip_address
+            )
 
     return options
 

aioshelly/exceptions.py

@@ -39,6 +39,14 @@ class DeviceConnectionTimeoutError(DeviceConnectionError):
     """Exception indicates device connection timeout errors."""
 
 
+class BleConnectionError(DeviceConnectionError):
+    """Exception indicates Bluetooth Low Energy connection errors."""
+
+
+class BleCharacteristicNotFoundError(BleConnectionError):
+    """Exception indicates required BLE GATT characteristic not found."""
+
+
 class InvalidAuthError(ShellyError):
     """Raised to indicate invalid or missing authentication error."""