casambi-bt-revamped 0.3.7.dev3__py3-none-any.whl → 0.3.12.dev15__py3-none-any.whl

CasambiBt/__init__.py

@@ -3,6 +3,7 @@
 # Import everything that should be public
 # ruff: noqa: F401
 
+from ._version import __version__
 from ._casambi import Casambi
 from ._discover import discover
 from ._unit import (

CasambiBt/_cache.py

@@ -6,28 +6,28 @@ import shutil
 from types import TracebackType
 from typing import Final
 
-from aiopath import AsyncPath  # type: ignore
+from anyio import Path
 
 _LOGGER = logging.getLogger(__name__)
 
-CACHE_PATH_DEFAULT: Final = AsyncPath(os.getcwd()) / "casambi-bt-store"
+CACHE_PATH_DEFAULT: Final = Path(os.getcwd()) / "casambi-bt-store"
 CACHE_VERSION: Final = 2
 
-# We need a global lock since there could be multiple Caambi instances
+# We need a global lock since there could be multiple Casambi instances
 # with their own cache instances pointing to the same folder.
 _cacheLock = asyncio.Lock()
 
 
-def _blocking_delete(path: AsyncPath) -> None:
+def _blocking_delete(path: Path) -> None:
     shutil.rmtree(pathlib.Path(path))
 
 
 class Cache:
-    def __init__(self, cachePath: AsyncPath | pathlib.Path | None) -> None:
+    def __init__(self, cachePath: Path | pathlib.Path | None) -> None:
         if cachePath is None:
             self._cachePath = CACHE_PATH_DEFAULT
-        elif not isinstance(cachePath, AsyncPath):
-            self._cachePath = AsyncPath(cachePath)
+        elif not isinstance(cachePath, Path):
+            self._cachePath = Path(cachePath)
         else:
             self._cachePath = cachePath
 
@@ -69,7 +69,7 @@ class Cache:
             await self._cachePath.mkdir(mode=0o700)
             await self._cacheVersionFile.write_text(str(CACHE_VERSION))
 
-    async def __aenter__(self) -> AsyncPath:
+    async def __aenter__(self) -> Path:
         await _cacheLock.acquire()
 
         if self._uuid is None:
@@ -78,7 +78,7 @@ class Cache:
         try:
             await self._ensureCacheValid()
 
-            cacheDir = AsyncPath(self._cachePath / self._uuid)
+            cacheDir = Path(self._cachePath / self._uuid)
             if not await cacheDir.exists():
                 _LOGGER.debug("Creating cache entry for id %s", self._uuid)
                 await cacheDir.mkdir()

CasambiBt/_casambi.py

@@ -10,7 +10,7 @@ from bleak.backends.device import BLEDevice
 from httpx import AsyncClient, RequestError
 
 from ._cache import Cache
-from ._client import CasambiClient, ConnectionState, IncommingPacketType
+from ._client import CasambiClient, ConnectionState, IncommingPacketType, ProtocolMode
 from ._network import Network
 from ._operation import OpCode, OperationsContext
 from ._unit import Group, Scene, Unit, UnitControlType, UnitState
@@ -98,6 +98,16 @@ class Casambi:
             and self._casaClient._connectionState == ConnectionState.AUTHENTICATED
         )
 
+    @property
+    def rawNetworkData(self) -> dict | None:
+        """Get the raw network configuration data if available.
+        
+        :return: The raw network JSON data or None if not connected.
+        """
+        if self._casaNetwork:
+            return self._casaNetwork.rawNetworkData
+        return None
+
     async def connect(
         self,
         addr_or_device: str | BLEDevice,
@@ -159,8 +169,15 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            await self._casaClient.exchangeKey()
-            await self._casaClient.authenticate()
+            if self._casaClient.protocolMode == ProtocolMode.EVO:
+                # EVO requires key exchange + authenticate.
+                await self._casaClient.exchangeKey()
+                await self._casaClient.authenticate()
+            elif self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+                # Classic needs an init write to trigger state broadcasts.
+                # In EVO the key exchange/auth handshake implicitly signals the
+                # device; Classic has no such handshake so we send a time-sync.
+                await self._casaClient.classicSendInit()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e
@@ -191,6 +208,40 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        # Classic protocol uses signed command frames (u1.C1753e / u1.EnumC1754f).
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Check if we should use the alternative simple format from BLE captures
+            import os
+            use_simple = os.environ.get("CASAMBI_BT_CLASSIC_FORMAT", "").lower() == "simple"
+
+            if use_simple:
+                # Simple format: [counter][unit_id][param_len][dimmer]
+                # For "all units", use unit_id=0xFF
+                if isinstance(target, Unit):
+                    cmd = self._casaClient.buildClassicCommandSimple(target.deviceId, level)
+                elif isinstance(target, Group):
+                    # Groups in simple format: not fully confirmed, try group ID
+                    cmd = self._casaClient.buildClassicCommandSimple(target.groudId, level)
+                elif target is None:
+                    cmd = self._casaClient.buildClassicCommandSimple(0xFF, level)
+                else:
+                    raise TypeError(f"Unkown target type {type(target)}")
+            else:
+                # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
+                # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+                if isinstance(target, Unit):
+                    cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+                elif isinstance(target, Group):
+                    cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+                elif target is None:
+                    cmd = self._casaClient.buildClassicCommand(4, payload)
+                else:
+                    raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetLevel)
 
     async def setVertical(self, target: Unit | Group | None, vertical: int) -> None:
@@ -209,6 +260,21 @@ class Casambi:
             raise ValueError()
 
         payload = vertical.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsVertical=22, UnitVertical=24, GroupVertical=29
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(24, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(29, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(22, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetVertical)
 
     async def setSlider(self, target: Unit | Group | None, value: int) -> None:
@@ -245,6 +311,21 @@ class Casambi:
             raise ValueError()
 
         payload = level.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsWhite=23, UnitWhite=25, GroupWhite=30
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(25, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(30, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(23, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetWhite)
 
     async def setColor(
@@ -262,6 +343,27 @@ class Casambi:
         :raises ValueError: The supplied rgbColor isn't in range
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses RGB payload (3 bytes) directly.
+            r, g, b = rgbColor
+            if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+                raise ValueError("rgbColor out of range.")
+            payload = bytes([r & 0xFF, g & 0xFF, b & 0xFF])
+
+            # EnumC1754f ordinals: AllUnitsColor=6, UnitColor=9, GroupColor=28
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(9, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(28, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(6, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
+        # Evolution uses HS payload (hue 10-bit + sat 8-bit) for SetColor.
         state = UnitState()
         state.rgb = rgbColor
         hs: tuple[float, float] = state.hs  # type: ignore[assignment]
@@ -290,6 +392,21 @@ class Casambi:
 
         temperature = int(temperature / 50)
         payload = temperature.to_bytes(1, byteorder="big", signed=False)
+
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # EnumC1754f ordinals: AllUnitsTemperature=5, UnitTemperature=8, GroupTemperature=27
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(8, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(27, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(5, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         await self._send(target, payload, OpCode.SetTemperature)
 
     async def setColorXY(
@@ -307,6 +424,10 @@ class Casambi:
         :raises ValueError: The supplied XYColor isn't in range or not supported by the supplied unit.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic command set (u1.EnumC1754f) only exposes RGB color control.
+            raise ValueError("XY color control is not supported on Classic networks.")
+
         if xyColor[0] < 0.0 or xyColor[0] > 1.0 or xyColor[1] < 0.0 or xyColor[1] > 1.0:
             raise ValueError("Color out of range.")
 
@@ -335,6 +456,22 @@ class Casambi:
         :return: Nothing is returned by this function. To get the new state register a change handler.
         """
 
+        if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a longer payload for "restore last level" (ground truth: casambi-android u1.C1751c.o()).
+            payload = bytes([0xFF, 0x01, 0x00, 0x00, 0x01])
+            # EnumC1754f ordinals: AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+            if isinstance(target, Unit):
+                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+            elif isinstance(target, Group):
+                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+            elif target is None:
+                cmd = self._casaClient.buildClassicCommand(4, payload)
+            else:
+                raise TypeError(f"Unkown target type {type(target)}")
+
+            await self._casaClient.send(cmd)
+            return
+
         # Use -1 to indicate special packet format
         # Use RestoreLastLevel flag (1) and UseFullTimeFlag (4).
         # Not sure what UseFullTime does but this is what the app uses.
@@ -357,6 +494,11 @@ class Casambi:
                 ConnectionState.AUTHENTICATED,
                 ConnectionState.NONE,
             )
+        if self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+            # Classic uses a completely different command encoding (u1.C1753e/u1.EnumC1754f).
+            # Public APIs that support Classic handle it explicitly; anything reaching here would
+            # send an EVO INVOCATION packet which is not valid on Classic.
+            raise ProtocolError(f"Operation {opcode.name} is not supported on Classic networks via INVOCATION.")
 
         targetCode = 0
         if isinstance(target, Unit):
@@ -390,7 +532,7 @@ class Casambi:
     def _dataCallback(
         self, packetType: IncommingPacketType, data: dict[str, Any]
     ) -> None:
-        self._logger.info(f"Incomming data callback of type {packetType}")
+        self._logger.debug("Incomming data callback of type %s", packetType)
         if packetType == IncommingPacketType.UnitState:
             self._logger.debug(
                 f"Handling changed state {b2a(data['state'])} for unit {data['id']}"
@@ -463,13 +605,17 @@ class Casambi:
         """Register a new handler for switch events.
 
         This handler is called whenever a switch event is received.
-        The handler is supplied with a dictionary containing:
-        - unit_id: The ID of the switch unit
-        - button: The button number that was pressed/released
-        - event: Either "button_press" or "button_release"
-        - message_type: The raw message type (0x08 or 0x10)
-        - flags: Additional flags from the message
-        - extra_data: Any additional data from the message
+        The handler is supplied with a dictionary containing (at minimum):
+        - unit_id: target unit id (from INVOCATION target high byte)
+        - button: best-effort "label" (typically 1..4 for 4-gang switches)
+        - event: "button_press" | "button_release" | "input_event"
+
+        Switch events are parsed from decrypted packet type=7 (INVOCATION stream),
+        matching casambi-android `v1.C1775b.Q(Q2.h)`. Extra diagnostic keys include:
+        - invocation_flags, opcode, origin, target, target_type, age, origin_handle
+        - button_event_index (0..7), param_p, param_s
+        - input_index (0..7), input_code, input_b1, input_channel, input_value16, input_mapped_event
+        - packet_sequence, arrival_sequence, raw_packet, decrypted_data, payload_hex, frame_offset, event_id
 
         :param handler: The method to call when a switch event is received.
         """
@@ -541,6 +687,270 @@ class Casambi:
                     exc_info=True,
                 )
 
+    async def setParameter(self, unitId: int, parameterTag: int, parameterData: bytes) -> None:
+        """Send a SetParameter command to a unit.
+        
+        Args:
+            unitId: The ID of the unit to send the command to
+            parameterTag: The parameter tag/ID to update
+            parameterData: The raw parameter data to send
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        
+        # Build payload: [parameter_tag][parameter_data]
+        # Note: SetParameter supports max 31 bytes after the tag.
+        payload = bytes([parameterTag]) + parameterData[:31]
+        
+        # Send using OpCode.SetParameter (26)
+        opPkt = self._opContext.prepareOperation(OpCode.SetParameter, (unitId << 8) | 0x01, payload)
+        await self._casaClient.send(opPkt)
+
+    async def send_ext_packet(self, unit_id: int, seq: int, chunk: bytes, *, lifetime: int = 9) -> None:
+        """Send an extended packet (ExtPacketSend / opcode 43) to a unit.
+
+        Payload is framed as: [0x29][seq][chunk...]
+
+        Notes:
+        - Total payload must be <= 63 bytes, so len(chunk) <= 61.
+        - Lifetime defaults to 9 to mirror longer-running multi-chunk ops seen on Android.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+
+        if seq < 0 or seq > 255:
+            raise ValueError("seq must be 0..255")
+        if len(chunk) > 61:
+            raise ValueError("chunk too large; max 61 bytes to fit ExtPacket payload")
+
+        payload = bytes([0x29, seq & 0xFF]) + chunk
+        target = (int(unit_id) << 8) | 0x01
+        opPkt = self._opContext.prepareOperation(
+            OpCode.ExtPacketSend,
+            target,
+            payload,
+            lifetime=lifetime,
+        )
+        await self._casaClient.send(opPkt)
+
+    async def start_switch_session(self, unit_id: int, *, payload: bytes = b"", lifetime: int = 9) -> None:
+        """Experimental: send AcquireSwitchSession (opcode 42).
+
+        Payload is device-specific and currently unknown for switchConfig; by default
+        sends an empty payload. Use for experimentation only until framing is confirmed.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if len(payload) > 63:
+            raise ValueError("payload too large; max 63 bytes")
+        target = (int(unit_id) << 8) | 0x01
+        opPkt = self._opContext.prepareOperation(
+            OpCode.AcquireSwitchSession,
+            target,
+            payload,
+            lifetime=lifetime,
+        )
+        await self._casaClient.send(opPkt)
+
+    async def apply_switch_config_ble(self, unit_id: int, *, parameter_tag: int | None = None) -> None:
+        """Attempt to push the unit's switchConfig to the device over BLE.
+
+        This method currently supports only very small configurations that fit
+        into a single SetParameter payload (max 31 bytes after the tag).
+
+        Args:
+            unit_id: The ID of the unit to update.
+            parameter_tag: Optional override for the parameter tag; if not provided,
+                           a default of 1 is used (subject to device variation).
+
+        Raises:
+            RuntimeError: If not connected or no raw network data.
+            ValueError: If the encoded switchConfig is too large for SetParameter.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if not self._casaNetwork or not self._casaNetwork.rawNetworkData:
+            raise RuntimeError("No raw network data available; connect and update first")
+
+        units = self._casaNetwork.rawNetworkData.get("network", {}).get("units", [])
+        unit_data = next((u for u in units if u.get("deviceID") == unit_id), None)
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+
+        import json
+        config_bytes = json.dumps(switch_config, separators=(",", ":")).encode("utf-8")
+
+        # Protocol restriction: SetParameter accepts max 31 bytes after tag.
+        if len(config_bytes) > 31:
+            raise ValueError(
+                "switchConfig exceeds 31 bytes; multi-packet BLE apply is required. "
+                "This library will need an extended writer (AcquireSwitchSession/ExtPacketSend) to support large configs."
+            )
+
+        tag = 1 if parameter_tag is None else int(parameter_tag)
+        await self.setParameter(unit_id, tag, config_bytes)
+        self._logger.info(
+            "Applied switchConfig via SetParameter (tag=%s, bytes=%s) for unit %s",
+            tag,
+            len(config_bytes),
+            unit_id,
+        )
+
+    async def apply_switch_config_ble_large(self, unit_id: int) -> None:
+        """Experimental: attempt to push switchConfig using ExtPacketSend in chunks.
+
+        WARNING: Framing is not fully confirmed for switchConfig updates. This method
+        sends raw JSON bytes chunked as consecutive ExtPacket frames with header
+        [0x29][seq]. Use only for experimentation and logs; correctness is not guaranteed.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if not self._casaNetwork or not self._casaNetwork.rawNetworkData:
+            raise RuntimeError("No raw network data available; connect and update first")
+
+        units = self._casaNetwork.rawNetworkData.get("network", {}).get("units", [])
+        unit_data = next((u for u in units if u.get("deviceID") == unit_id), None)
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+        import json
+        data = json.dumps(switch_config, separators=(",", ":")).encode("utf-8")
+
+        # Attempt to start a switch session before sending chunks. Some devices
+        # expect an AcquireSwitchSession (opcode 42) handshake prior to ExtPacketSend.
+        try:
+            await self.start_switch_session(unit_id)
+            self._logger.info("Started switch session (AcquireSwitchSession) for unit %s", unit_id)
+        except Exception as e:
+            # Non-fatal: proceed without session if device doesn't require it.
+            self._logger.info(
+                "AcquireSwitchSession not acknowledged or unsupported for unit %s (%s); proceeding with ExtPacketSend only.",
+                unit_id,
+                e,
+            )
+
+        # Chunk into 61-byte pieces (ExtPacket payload allows 63 total minus 2-byte header)
+        max_chunk = 61
+        seq = 0
+        for off in range(0, len(data), max_chunk):
+            chunk = data[off : off + max_chunk]
+            await self.send_ext_packet(unit_id, seq, chunk, lifetime=9)
+            self._logger.debug(
+                "ExtPacket chunk sent: unit=%s seq=%s size=%s/%s", unit_id, seq, len(chunk), len(data)
+            )
+            seq = (seq + 1) & 0xFF
+        self._logger.info(
+            "ExtPacket switchConfig attempt complete (unit=%s, total_bytes=%s, chunks=%s)",
+            unit_id,
+            len(data),
+            (len(data) + max_chunk - 1) // max_chunk,
+        )
+
+    async def update_button_config(
+        self,
+        unit_id: int,
+        button_index: int,
+        action_type: str,
+        target_id: int | None = None,
+        *,
+        exclusive_scenes: bool | None = None,
+        long_press_all_off: bool | None = None,
+        toggle_disabled: bool | None = None,
+    ) -> dict:
+        """Update one button entry in a unit's switchConfig in the cached network data.
+
+        Android mapping for actions (EnumC0105q):
+        - none -> 0, target 0
+        - scene -> 1, target=sceneID
+        - control_unit -> 2, target=deviceID
+        - control_group -> 3, target=groupID
+        - all_units -> 4, target=255
+        - resume_automation -> 6, target=0
+        - resume_automation_group -> 7, target=groupID
+
+        Returns the updated switchConfig dict.
+        """
+        if button_index < 0 or button_index > 7:
+            raise ValueError("button_index must be in range 0..7")
+
+        raw = self.rawNetworkData
+        if not raw:
+            raise RuntimeError("No raw network data loaded. Connect and update first.")
+
+        # Locate the unit's JSON entry
+        units = raw.get("network", {}).get("units", [])
+        unit_data = None
+        for u in units:
+            if u.get("deviceID") == unit_id:
+                unit_data = u
+                break
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+        buttons: list[dict] = switch_config.get("buttons") or []
+
+        action_map = {
+            "none": 0,
+            "scene": 1,
+            "control_unit": 2,
+            "control_group": 3,
+            "all_units": 4,
+            "resume_automation": 6,
+            "resume_automation_group": 7,
+        }
+        if action_type not in action_map:
+            raise ValueError(
+                "Unsupported action_type. Use one of: none, scene, control_unit, "
+                "control_group, all_units, resume_automation, resume_automation_group"
+            )
+        action_code = action_map[action_type]
+
+        if action_type == "all_units":
+            resolved_target = 255
+        elif action_type in ("none", "resume_automation"):
+            resolved_target = 0
+        else:
+            if target_id is None:
+                raise ValueError(f"target_id is required for action_type '{action_type}'")
+            resolved_target = int(target_id)
+
+        # Find or create entry for this button index
+        existing = None
+        for b in buttons:
+            if b.get("type") == button_index:
+                existing = b
+                break
+        entry = existing or {"type": button_index, "action": 0, "target": 0}
+        entry["action"] = action_code
+        entry["target"] = resolved_target
+        if not existing:
+            buttons.append(entry)
+
+        # Persist and apply optional flags
+        switch_config["buttons"] = buttons
+        if exclusive_scenes is not None:
+            switch_config["exclusiveScenes"] = bool(exclusive_scenes)
+        if long_press_all_off is not None:
+            switch_config["longPressAllOff"] = bool(long_press_all_off)
+        if toggle_disabled is not None:
+            switch_config["toggleDisabled"] = bool(toggle_disabled)
+
+        unit_data["switchConfig"] = switch_config
+
+        self._logger.info(
+            "Updated switchConfig (unit=%s, button=%s, action=%s, target=%s)",
+            unit_id,
+            button_index,
+            action_type,
+            resolved_target,
+        )
+
+        return switch_config
+
     async def disconnect(self) -> None:
         """Disconnect from the network."""
         if self._casaClient: