chore(pre-commit.ci): auto fixes

switchbot/__init__.py

@@ -65,9 +65,9 @@ __all__ = [
     "SwitchbotPlugMini",
     "SwitchbotRelaySwitch",
     "SwitchbotRollerShade",
-    "SwitchbotVacuum",
     "SwitchbotSupportedType",
     "SwitchbotSupportedType",
+    "SwitchbotVacuum",
     "close_stale_connections",
     "close_stale_connections_by_address",
     "get_device",

switchbot/adv_parser.py

@@ -267,7 +267,7 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "modelFriendlyName": "K10+ Pro Vacuum",
         "func": process_vacuum_k,
         "manufacturer_id": 2409,
-    },        
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR = {

switchbot/adv_parsers/vacuum.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import struct
 
-def process_vacuum(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int | str]:
-    """Support for s10, k10+ pro combo, k20 process service data."""
 
+def process_vacuum(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int | str]:
+    """Support for s10, k10+ pro combo, k20 process service data."""
     if mfr_data is None:
         return {}
 
@@ -27,17 +29,18 @@ def process_vacuum(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool
         "work_status": _work_status,
     }
 
+
 def get_device_fw_version(version_bytes: bytes) -> str | None:
-    version1 = version_bytes[0] & 0x0f
+    version1 = version_bytes[0] & 0x0F
     version2 = version_bytes[0] >> 4
-    version3 = struct.unpack('<H', version_bytes[1:])[0]
-    return f'{version1}.{version2}.{version3:>03d}'
-
+    version3 = struct.unpack("<H", version_bytes[1:])[0]
+    return f"{version1}.{version2}.{version3:>03d}"
 
 
-def process_vacuum_k(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int | str]:
+def process_vacuum_k(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int | str]:
     """Support for k10+, k10+ pro process service data."""
-
     if mfr_data is None:
         return {}
 
@@ -54,5 +57,5 @@ def process_vacuum_k(data: bytes | None, mfr_data: bytes | None) -> dict[str, bo
         "dusbin_connected": _dusbin_connected,
         "network_connected": _network_connected,
         "work_status": _work_status,
-        "battery": _battery
-    }
+        "battery": _battery,
+    }

switchbot/devices/vacuum.py

@@ -1,7 +1,9 @@
 """Library to handle connection with Switchbot."""
 
 from __future__ import annotations
+
 from typing import Any
+
 from .device import SwitchbotSequenceDevice, update_after_operation
 
 COMMAND_CLEAN_UP = {
@@ -10,9 +12,10 @@ COMMAND_CLEAN_UP = {
 }
 COMMAND_RETURN_DOCK = {
     1: "570F5A00FFFF7002",
-    2: "5A400101010225",    
+    2: "5A400101010225",
 }
 
+
 class SwitchbotVacuum(SwitchbotSequenceDevice):
     """Representation of a Switchbot Vacuum."""
 
@@ -23,12 +26,12 @@ class SwitchbotVacuum(SwitchbotSequenceDevice):
     async def clean_up(self, protocol_version: int) -> bool:
         """Send command to perform a spot clean-up."""
         return await self._send_command(COMMAND_CLEAN_UP[protocol_version])
-    
+
     @update_after_operation
     async def return_to_dock(self, protocol_version: int) -> bool:
         """Send command to return the dock."""
         return await self._send_command(COMMAND_RETURN_DOCK[protocol_version])
-    
+
     async def get_basic_info(self) -> dict[str, Any] | None:
         """Only support get the ble version through the command."""
         if not (_data := await self._get_basic_info()):
@@ -36,7 +39,7 @@ class SwitchbotVacuum(SwitchbotSequenceDevice):
         return {
             "firmware": _data[2],
         }
-    
+
     def get_soc_version(self) -> str:
         """Return device soc version."""
         return self._get_adv_value("soc_version")
@@ -44,15 +47,15 @@ class SwitchbotVacuum(SwitchbotSequenceDevice):
     def get_last_step(self) -> int:
         """Return device last step after network configuration."""
         return self._get_adv_value("step")
-    
+
     def get_mqtt_connnect_status(self) -> bool:
         """Return device mqtt connect status."""
         return self._get_adv_value("mqtt_connected")
-    
+
     def get_battery(self) -> int:
         """Return device battery."""
         return self._get_adv_value("battery")
-    
+
     def get_work_status(self) -> int:
         """Return device work status."""
         return self._get_adv_value("work_status")
@@ -60,11 +63,11 @@ class SwitchbotVacuum(SwitchbotSequenceDevice):
     def get_dustbin_bound_status(self) -> bool:
         """Return the dustbin bound status"""
         return self._get_adv_value("dustbin_bound")
-    
+
     def get_dustbin_connnected_status(self) -> bool:
         """Return the dustbin connected status"""
         return self._get_adv_value("dusbin_connected")
 
     def get_network_connected_status(self) -> bool:
         """Return the network connected status"""
-        return self._get_adv_value("network_connected")
+        return self._get_adv_value("network_connected")

tests/test_adv_parser.py

@@ -2207,9 +2207,7 @@ def test_k20_active() -> None:
         service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b".\x00d"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K20_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K20_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
@@ -2240,9 +2238,7 @@ def test_k20_passive() -> None:
         manufacturer_data={2409: b"\xb0\xe9\xfe\x01\xf3\x8f'\x01\x11S\x00\x10d\x0f"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K20_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K20_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
@@ -2274,9 +2270,7 @@ def test_k20_with_empty_data() -> None:
         service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b".\x00d"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K20_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K20_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
@@ -2289,14 +2283,14 @@ def test_k20_with_empty_data() -> None:
         rssi=-97,
         active=True,
     )
-    
+
 
 def test_k10_pro_active() -> None:
     """Test parsing k10 pro with active data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfeP\x8d\x8d\x02 d'},
-        service_data={'0000fd3d-0000-1000-8000-00805f9b34fb': b'(\x00'},
+        manufacturer_data={2409: b"\xb0\xe9\xfeP\x8d\x8d\x02 d"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"(\x00"},
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2305,12 +2299,12 @@ def test_k10_pro_active() -> None:
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'(\x00',
+            "rawAdvData": b"(\x00",
             "data": {
                 "sequence_number": 2,
-                'dusbin_connected': False,
-                'dustbin_bound': False,
-                'network_connected': True,
+                "dusbin_connected": False,
+                "dustbin_bound": False,
+                "network_connected": True,
                 "battery": 100,
                 "work_status": 0,
             },
@@ -2329,7 +2323,7 @@ def test_k10_pro_passive() -> None:
     """Test parsing k10 pro with passive data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfeP\x8d\x8d\x02 d'},
+        manufacturer_data={2409: b"\xb0\xe9\xfeP\x8d\x8d\x02 d"},
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2341,9 +2335,9 @@ def test_k10_pro_passive() -> None:
             "rawAdvData": None,
             "data": {
                 "sequence_number": 2,
-                'dusbin_connected': False,
-                'dustbin_bound': False,
-                'network_connected': True,
+                "dusbin_connected": False,
+                "dustbin_bound": False,
+                "network_connected": True,
                 "battery": 100,
                 "work_status": 0,
             },
@@ -2363,7 +2357,7 @@ def test_k10_pro_with_empty_data() -> None:
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
         manufacturer_data={2409: None},
-        service_data={'0000fd3d-0000-1000-8000-00805f9b34fb': b'(\x00'},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"(\x00"},
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2372,7 +2366,7 @@ def test_k10_pro_with_empty_data() -> None:
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'(\x00',
+            "rawAdvData": b"(\x00",
             "data": {},
             "isEncrypted": False,
             "model": "(",
@@ -2387,22 +2381,20 @@ def test_k10_active() -> None:
     """Test parsing k10+ with active data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xca8\x06\xa9_\xf1\x02 d'},
-        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b'}\x00'},
+        manufacturer_data={2409: b"\xca8\x06\xa9_\xf1\x02 d"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"}\x00"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'}\x00',
+            "rawAdvData": b"}\x00",
             "data": {
                 "sequence_number": 2,
-                'dusbin_connected': False,
-                'dustbin_bound': False,
-                'network_connected': True,
+                "dusbin_connected": False,
+                "dustbin_bound": False,
+                "network_connected": True,
                 "battery": 100,
                 "work_status": 0,
             },
@@ -2421,21 +2413,19 @@ def test_k10_passive() -> None:
     """Test parsing k10+ with passive data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xca8\x06\xa9_\xf1\x02 d'},
+        manufacturer_data={2409: b"\xca8\x06\xa9_\xf1\x02 d"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
             "rawAdvData": None,
             "data": {
                 "sequence_number": 2,
-                'dusbin_connected': False,
-                'dustbin_bound': False,
-                'network_connected': True,
+                "dusbin_connected": False,
+                "dustbin_bound": False,
+                "network_connected": True,
                 "battery": 100,
                 "work_status": 0,
             },
@@ -2455,16 +2445,14 @@ def test_k10_with_empty_data() -> None:
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
         manufacturer_data={2409: None},
-        service_data={'0000fd3d-0000-1000-8000-00805f9b34fb': b'}\x00'},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"}\x00"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.K10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.K10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'}\x00',
+            "rawAdvData": b"}\x00",
             "data": {},
             "isEncrypted": False,
             "model": "}",
@@ -2479,8 +2467,10 @@ def test_k10_pro_combo_active() -> None:
     """Test parsing k10+ pro combo with active data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfe\x01\xf4\x1d\x0b\x01\x01\xb1\x03\x118\x01'},
-        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b'3\x00\x00'},
+        manufacturer_data={
+            2409: b"\xb0\xe9\xfe\x01\xf4\x1d\x0b\x01\x01\xb1\x03\x118\x01"
+        },
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"3\x00\x00"},
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2489,7 +2479,7 @@ def test_k10_pro_combo_active() -> None:
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'3\x00\x00',
+            "rawAdvData": b"3\x00\x00",
             "data": {
                 "sequence_number": 11,
                 "soc_version": "1.0.945",
@@ -2513,7 +2503,9 @@ def test_k10_pro_combo_passive() -> None:
     """Test parsing k10+ pro combo with passive data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfe\x01\xf4\x1d\x0b\x01\x01\xb1\x03\x118\x01'},
+        manufacturer_data={
+            2409: b"\xb0\xe9\xfe\x01\xf4\x1d\x0b\x01\x01\xb1\x03\x118\x01"
+        },
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2547,7 +2539,7 @@ def test_k10_pro_combo_with_empty_data() -> None:
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
         manufacturer_data={2409: None},
-        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b'3\x00\x00'},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"3\x00\x00"},
         rssi=-97,
     )
     result = parse_advertisement_data(
@@ -2556,7 +2548,7 @@ def test_k10_pro_combo_with_empty_data() -> None:
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'3\x00\x00',
+            "rawAdvData": b"3\x00\x00",
             "data": {},
             "isEncrypted": False,
             "model": "3",
@@ -2571,17 +2563,15 @@ def test_s10_active() -> None:
     """Test parsing s10 with active data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfe\x00\x08|\n\x01\x11\x05\x00\x10M\x02'},
-        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b'z\x00\x00'},
+        manufacturer_data={2409: b"\xb0\xe9\xfe\x00\x08|\n\x01\x11\x05\x00\x10M\x02"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"z\x00\x00"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.S10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.S10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'z\x00\x00',
+            "rawAdvData": b"z\x00\x00",
             "data": {
                 "sequence_number": 10,
                 "soc_version": "1.1.005",
@@ -2605,12 +2595,10 @@ def test_s10_passive() -> None:
     """Test parsing s10 with passive data."""
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
-        manufacturer_data={2409: b'\xb0\xe9\xfe\x00\x08|\n\x01\x11\x05\x00\x10M\x02'},
+        manufacturer_data={2409: b"\xb0\xe9\xfe\x00\x08|\n\x01\x11\x05\x00\x10M\x02"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.S10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.S10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
@@ -2639,16 +2627,14 @@ def test_s10_with_empty_data() -> None:
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     adv_data = generate_advertisement_data(
         manufacturer_data={2409: None},
-        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b'z\x00\x00'},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"z\x00\x00"},
         rssi=-97,
     )
-    result = parse_advertisement_data(
-        ble_device, adv_data, SwitchbotModel.S10_VACUUM
-    )
+    result = parse_advertisement_data(ble_device, adv_data, SwitchbotModel.S10_VACUUM)
     assert result == SwitchBotAdvertisement(
         address="aa:bb:cc:dd:ee:ff",
         data={
-            "rawAdvData": b'z\x00\x00',
+            "rawAdvData": b"z\x00\x00",
             "data": {},
             "isEncrypted": False,
             "model": "z",

tests/test_vacuum.py

@@ -4,33 +4,37 @@ import pytest
 from bleak.backends.device import BLEDevice
 
 from switchbot import SwitchBotAdvertisement
-from switchbot.devices import vacuum
 from switchbot.adv_parser import SUPPORTED_TYPES
+from switchbot.devices import vacuum
 
 from .test_adv_parser import generate_ble_device
 
 common_params = [
-    (b".\x00d", ".", 2), 
-    (b'z\x00\x00', ".", 2), 
-    (b'3\x00\x00', ".", 2),
-    (b'(\x00', "(", 1),
-    (b'}\x00', "(", 1),
+    (b".\x00d", ".", 2),
+    (b"z\x00\x00", ".", 2),
+    (b"3\x00\x00", ".", 2),
+    (b"(\x00", "(", 1),
+    (b"}\x00", "(", 1),
 ]
 
 
-
-def create_device_for_command_testing(protocol_version: int, rawAdvData: bytes, model: str):
+def create_device_for_command_testing(
+    protocol_version: int, rawAdvData: bytes, model: str
+):
     ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any")
     device = vacuum.SwitchbotVacuum(ble_device)
-    device.update_from_advertisement(make_advertisement_data(ble_device, protocol_version, rawAdvData, model))
+    device.update_from_advertisement(
+        make_advertisement_data(ble_device, protocol_version, rawAdvData, model)
+    )
     device._send_command = AsyncMock()
     device.update = AsyncMock()
     return device
 
 
-def make_advertisement_data(ble_device: BLEDevice, protocol_version: int, rawAdvData: bytes, model: str):
+def make_advertisement_data(
+    ble_device: BLEDevice, protocol_version: int, rawAdvData: bytes, model: str
+):
     """Set advertisement data with defaults."""
-    
     if protocol_version == 1:
         return SwitchBotAdvertisement(
             address="aa:bb:cc:dd:ee:ff",
@@ -38,9 +42,9 @@ def make_advertisement_data(ble_device: BLEDevice, protocol_version: int, rawAdv
                 "rawAdvData": rawAdvData,
                 "data": {
                     "sequence_number": 2,
-                    'dusbin_connected': False,
-                    'dustbin_bound': False,
-                    'network_connected': True,
+                    "dusbin_connected": False,
+                    "dustbin_bound": False,
+                    "network_connected": True,
                     "battery": 100,
                     "work_status": 0,
                 },
@@ -52,7 +56,7 @@ def make_advertisement_data(ble_device: BLEDevice, protocol_version: int, rawAdv
             device=ble_device,
             rssi=-97,
             active=True,
-    )
+        )
     else:
         return SwitchBotAdvertisement(
             address="aa:bb:cc:dd:ee:ff",
@@ -73,17 +77,12 @@ def make_advertisement_data(ble_device: BLEDevice, protocol_version: int, rawAdv
             device=ble_device,
             rssi=-97,
             active=True,
-    )
+        )
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "rawAdvData,model", 
-    [
-        (b".\x00d", "."),
-        (b'z\x00\x00', 'z'),
-        (b'3\x00\x00', "3") 
-    ]
+    "rawAdvData,model", [(b".\x00d", "."), (b"z\x00\x00", "z"), (b"3\x00\x00", "3")]
 )
 async def test_status_from_proceess_adv(rawAdvData, model, protocol_version=2):
     device = create_device_for_command_testing(protocol_version, rawAdvData, model)
@@ -93,14 +92,9 @@ async def test_status_from_proceess_adv(rawAdvData, model, protocol_version=2):
     assert device.get_battery() == 100
     assert device.get_work_status() == 15
 
+
 @pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "rawAdvData,model", 
-    [
-        (b'(\x00', "("), 
-        (b'}\x00', "}")
-    ]
-)
+@pytest.mark.parametrize("rawAdvData,model", [(b"(\x00", "("), (b"}\x00", "}")])
 async def test_status_from_proceess_adv_k(rawAdvData, model, protocol_version=1):
     device = create_device_for_command_testing(protocol_version, rawAdvData, model)
     assert device.get_dustbin_bound_status() is False
@@ -111,33 +105,31 @@ async def test_status_from_proceess_adv_k(rawAdvData, model, protocol_version=1)
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "rawAdvData,model,protocol_version", 
-    common_params
-)
+@pytest.mark.parametrize("rawAdvData,model,protocol_version", common_params)
 async def test_clean_up(rawAdvData, model, protocol_version):
     device = create_device_for_command_testing(protocol_version, rawAdvData, model)
     await device.clean_up(protocol_version)
-    device._send_command.assert_awaited_once_with(vacuum.COMMAND_CLEAN_UP[protocol_version])
+    device._send_command.assert_awaited_once_with(
+        vacuum.COMMAND_CLEAN_UP[protocol_version]
+    )
+
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "rawAdvData,model,protocol_version", 
-    common_params
-)
+@pytest.mark.parametrize("rawAdvData,model,protocol_version", common_params)
 async def test_return_to_dock(rawAdvData, model, protocol_version):
     device = create_device_for_command_testing(protocol_version, rawAdvData, model)
     await device.return_to_dock(protocol_version)
-    device._send_command.assert_awaited_once_with(vacuum.COMMAND_RETURN_DOCK[protocol_version])
+    device._send_command.assert_awaited_once_with(
+        vacuum.COMMAND_RETURN_DOCK[protocol_version]
+    )
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "rawAdvData,model,protocol_version", 
-    common_params
-)
-async def test_get_basic_info_returns_none_when_no_data(rawAdvData, model, protocol_version):
+@pytest.mark.parametrize("rawAdvData,model,protocol_version", common_params)
+async def test_get_basic_info_returns_none_when_no_data(
+    rawAdvData, model, protocol_version
+):
     device = create_device_for_command_testing(protocol_version, rawAdvData, model)
     device._get_basic_info = AsyncMock(return_value=None)
 
-    assert await device.get_basic_info() is None
+    assert await device.get_basic_info() is None