PySwitchbot 0.68.0__tar.gz → 0.68.2__tar.gz

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.68.0
+Version: 0.68.2
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/PySwitchbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.68.0
+Version: 0.68.2
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/setup.py

@@ -20,7 +20,7 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.68.0",
+    version="0.68.2",
     description="A library to communicate with Switchbot",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/switchbot/__init__.py

@@ -43,7 +43,11 @@ from .devices.humidifier import SwitchbotHumidifier
 from .devices.light_strip import SwitchbotLightStrip, SwitchbotStripLight3
 from .devices.lock import SwitchbotLock
 from .devices.plug import SwitchbotPlugMini
-from .devices.relay_switch import SwitchbotRelaySwitch, SwitchbotRelaySwitch2PM
+from .devices.relay_switch import (
+    SwitchbotGarageDoorOpener,
+    SwitchbotRelaySwitch,
+    SwitchbotRelaySwitch2PM,
+)
 from .devices.roller_shade import SwitchbotRollerShade
 from .devices.vacuum import SwitchbotVacuum
 from .discovery import GetSwitchbotDevices
@@ -77,6 +81,7 @@ __all__ = [
     "SwitchbotEncryptedDevice",
     "SwitchbotEvaporativeHumidifier",
     "SwitchbotFan",
+    "SwitchbotGarageDoorOpener",
     "SwitchbotHumidifier",
     "SwitchbotLightStrip",
     "SwitchbotLock",

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/switchbot/devices/device.py

@@ -127,6 +127,8 @@ class SwitchbotBaseDevice:
 
     _turn_on_command: str | None = None
     _turn_off_command: str | None = None
+    _open_command: str | None = None
+    _close_command: str | None = None
     _press_command: str | None = None
 
     def __init__(
@@ -719,6 +721,20 @@ class SwitchbotBaseDevice:
         result = await self._send_command(self._turn_off_command)
         return self._check_command_result(result, 0, {1})
 
+    @update_after_operation
+    async def open(self) -> bool:
+        """Open the device."""
+        self._check_function_support(self._open_command)
+        result = await self._send_command(self._open_command)
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def close(self) -> bool:
+        """Close the device."""
+        self._check_function_support(self._close_command)
+        result = await self._send_command(self._close_command)
+        return self._check_command_result(result, 0, {1})
+
     @update_after_operation
     async def press(self) -> bool:
         """Press the device."""
@@ -955,6 +971,12 @@ class SwitchbotEncryptedDevice(SwitchbotDevice):
         if len(data) == 0:
             return b""
         if self._iv is None:
+            if self._expected_disconnect:
+                _LOGGER.debug(
+                    "%s: Cannot decrypt, IV is None during expected disconnect",
+                    self.name,
+                )
+                return b""
             raise RuntimeError("Cannot decrypt: IV is None")
         decryptor = self._get_cipher().decryptor()
         return decryptor.update(data) + decryptor.finalize()

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/switchbot/devices/lock.py

@@ -37,7 +37,12 @@ COMMAND_LOCK = {
     SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0f4e0101000000",
     SwitchbotModel.LOCK_ULTRA: f"{COMMAND_HEADER}0f4e0101000000",
 }
-COMMAND_ENABLE_NOTIFICATIONS = f"{COMMAND_HEADER}0e01001e00008101"
+COMMAND_ENABLE_NOTIFICATIONS = {
+    SwitchbotModel.LOCK: f"{COMMAND_HEADER}0e01001e00008101",
+    SwitchbotModel.LOCK_LITE: f"{COMMAND_HEADER}0e01001e00008101",
+    SwitchbotModel.LOCK_PRO: f"{COMMAND_HEADER}0e01001e00008104",
+    SwitchbotModel.LOCK_ULTRA: f"{COMMAND_HEADER}0e01001e00008107",
+}
 COMMAND_DISABLE_NOTIFICATIONS = f"{COMMAND_HEADER}0e00"
 
 MOVING_STATUSES = {LockStatus.LOCKING, LockStatus.UNLOCKING}
@@ -197,12 +202,8 @@ class SwitchbotLock(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         return _data
 
     async def _enable_notifications(self) -> bool:
-        if self._notifications_enabled:
-            return True
-        result = await self._send_command(COMMAND_ENABLE_NOTIFICATIONS)
-        if self._check_command_result(result, 0, COMMAND_RESULT_EXPECTED_VALUES):
-            self._notifications_enabled = True
-        return self._notifications_enabled
+        result = await self._send_command(COMMAND_ENABLE_NOTIFICATIONS[self._model])
+        return self._check_command_result(result, 0, COMMAND_RESULT_EXPECTED_VALUES)
 
     async def _disable_notifications(self) -> bool:
         if not self._notifications_enabled:
@@ -213,7 +214,13 @@ class SwitchbotLock(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         return not self._notifications_enabled
 
     def _notification_handler(self, _sender: int, data: bytearray) -> None:
-        if self._notifications_enabled and self._check_command_result(data, 0, {0xF}):
+        if self._check_command_result(data, 0, {0xF}):
+            if self._expected_disconnect:
+                _LOGGER.debug(
+                    "%s: Ignoring lock notification during expected disconnect",
+                    self.name,
+                )
+                return
             self._update_lock_status(data)
         else:
             super()._notification_handler(_sender, data)

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/switchbot/devices/relay_switch.py

@@ -61,7 +61,6 @@ class SwitchbotRelaySwitch(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
 
     _turn_on_command = f"{COMMAND_CONTROL}010100"
     _turn_off_command = f"{COMMAND_CONTROL}010000"
-    _press_command = f"{COMMAND_CONTROL}110329"  # for garage door opener toggle
 
     def __init__(
         self,
@@ -205,6 +204,29 @@ class SwitchbotRelaySwitch(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         """Return switch state from cache."""
         return self._get_adv_value("isOn")
 
+    def door_open(self) -> bool | None:
+        """Return garage door state from cache."""
+        return self._get_adv_value("door_open")
+
+
+class SwitchbotGarageDoorOpener(SwitchbotRelaySwitch):
+    """Representation of a Switchbot garage door opener."""
+
+    _open_command = f"{COMMAND_CONTROL}110129"
+    _close_command = f"{COMMAND_CONTROL}110229"
+    _press_command = f"{COMMAND_CONTROL}110329"  # for garage door opener toggle
+
+    def __init__(
+        self,
+        device: BLEDevice,
+        key_id: str,
+        encryption_key: str,
+        interface: int = 0,
+        model: SwitchbotModel = SwitchbotModel.GARAGE_DOOR_OPENER,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(device, key_id, encryption_key, interface, model, **kwargs)
+
 
 class SwitchbotRelaySwitch2PM(SwitchbotRelaySwitch):
     """Representation of a Switchbot relay switch 2pm."""

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/tests/test_encrypted_device.py

@@ -365,3 +365,22 @@ async def test_empty_data_encryption_decryption() -> None:
     # Test empty decryption
     decrypted = device._decrypt(bytearray())
     assert decrypted == b""
+
+
+@pytest.mark.asyncio
+async def test_decrypt_with_none_iv_during_disconnect() -> None:
+    """Test that decryption returns empty bytes when IV is None during expected disconnect."""
+    device = create_encrypted_device()
+
+    # Simulate disconnection in progress
+    device._expected_disconnect = True
+    device._iv = None
+
+    # Should return empty bytes instead of raising
+    result = device._decrypt(bytearray(b"encrypted_data"))
+    assert result == b""
+
+    # Verify it still raises when not disconnecting
+    device._expected_disconnect = False
+    with pytest.raises(RuntimeError, match="Cannot decrypt: IV is None"):
+        device._decrypt(bytearray(b"encrypted_data"))

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/tests/test_lock.py

@@ -1,3 +1,4 @@
+import logging
 from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
@@ -371,27 +372,6 @@ async def test_enable_notifications(model: str):
     with patch.object(device, "_send_command", return_value=b"\x01\x00"):
         result = await device._enable_notifications()
         assert result is True
-        assert device._notifications_enabled is True
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "model",
-    [
-        SwitchbotModel.LOCK,
-        SwitchbotModel.LOCK_LITE,
-        SwitchbotModel.LOCK_PRO,
-        SwitchbotModel.LOCK_ULTRA,
-    ],
-)
-async def test_enable_notifications_already_enabled(model: str):
-    """Test _enable_notifications when already enabled."""
-    device = create_device_for_command_testing(model)
-    device._notifications_enabled = True
-    with patch.object(device, "_send_command") as mock_send:
-        result = await device._enable_notifications()
-        assert result is True
-        mock_send.assert_not_called()
 
 
 @pytest.mark.asyncio
@@ -466,7 +446,7 @@ def test_notification_handler_not_enabled(model: str):
     """Test _notification_handler when notifications not enabled."""
     device = create_device_for_command_testing(model)
     device._notifications_enabled = False
-    data = bytearray(b"\x0f\x00\x00\x00\x80\x00\x00\x00\x00\x00")
+    data = bytearray(b"\x01\x00\x00\x00\x80\x00\x00\x00\x00\x00")
     with (
         patch.object(device, "_update_lock_status") as mock_update,
         patch.object(
@@ -478,6 +458,34 @@ def test_notification_handler_not_enabled(model: str):
         mock_super.assert_called_once()
 
 
+@pytest.mark.parametrize(
+    "model",
+    [
+        SwitchbotModel.LOCK,
+        SwitchbotModel.LOCK_LITE,
+        SwitchbotModel.LOCK_PRO,
+        SwitchbotModel.LOCK_ULTRA,
+    ],
+)
+def test_notification_handler_during_disconnect(
+    model: str, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Test _notification_handler during expected disconnect."""
+    device = create_device_for_command_testing(model)
+    device._notifications_enabled = True
+    device._expected_disconnect = True
+    data = bytearray(b"\x0f\x00\x00\x00\x80\x00\x00\x00\x00\x00")
+    with (
+        patch.object(device, "_update_lock_status") as mock_update,
+        caplog.at_level(logging.DEBUG),
+    ):
+        device._notification_handler(0, data)
+        # Should not update lock status during disconnect
+        mock_update.assert_not_called()
+        # Should log debug message
+        assert "Ignoring lock notification during expected disconnect" in caplog.text
+
+
 @pytest.mark.parametrize(
     "model",
     [

{pyswitchbot-0.68.0 → pyswitchbot-0.68.2}/tests/test_relay_switch.py

@@ -30,11 +30,12 @@ def create_device_for_command_testing(
 ):
     """Create a device for command testing."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
-    device_class = (
-        relay_switch.SwitchbotRelaySwitch2PM
-        if model == SwitchbotModel.RELAY_SWITCH_2PM
-        else relay_switch.SwitchbotRelaySwitch
-    )
+    if model == SwitchbotModel.GARAGE_DOOR_OPENER:
+        device_class = relay_switch.SwitchbotGarageDoorOpener
+    elif model == SwitchbotModel.RELAY_SWITCH_2PM:
+        device_class = relay_switch.SwitchbotRelaySwitch2PM
+    else:
+        device_class = relay_switch.SwitchbotRelaySwitch
     device = device_class(
         ble_device, "ff", "ffffffffffffffffffffffffffffffff", model=model
     )
@@ -453,12 +454,49 @@ def test_merge_data(old_data, new_data, expected_result):
     assert result == expected_result
 
 
+@pytest.mark.asyncio
+async def test_garage_door_opener_open():
+    """Test open the garage door."""
+    device = create_device_for_command_testing(
+        b">\x00\x00\x00", SwitchbotModel.GARAGE_DOOR_OPENER
+    )
+
+    await device.open()
+    device._send_command.assert_awaited_once_with(device._open_command)
+
+
+@pytest.mark.asyncio
+async def test_garage_door_opener_close():
+    """Test close the garage door."""
+    device = create_device_for_command_testing(
+        b">\x00\x00\x00", SwitchbotModel.GARAGE_DOOR_OPENER
+    )
+
+    await device.close()
+    device._send_command.assert_awaited_once_with(device._close_command)
+
+
+@pytest.mark.parametrize(
+    "door_open",
+    [
+        True,
+        False,
+    ],
+)
+@pytest.mark.asyncio
+async def test_garage_door_opener_door_open(door_open):
+    """Test get garage door state."""
+    device = create_device_for_command_testing(
+        b">\x00\x00\x00", SwitchbotModel.GARAGE_DOOR_OPENER, {"door_open": door_open}
+    )
+    assert device.door_open() is door_open
+
+
 @pytest.mark.asyncio
 async def test_press():
     """Test the press command for garage door opener."""
     device = create_device_for_command_testing(
         b">\x00\x00\x00", SwitchbotModel.GARAGE_DOOR_OPENER
     )
-
     await device.press()
     device._send_command.assert_awaited_once_with(device._press_command)