chore(core): reformat

Author: petretiandrea

plugp100/discovery/discovered_device.py

@@ -85,9 +85,13 @@ async def get_tapo_device(
             )
         else:
             logging.warning(
-                f"No encryption schema found for discovered device {self.ip} {self.device_type}")
+                f"No encryption schema found for discovered device {self.ip} {self.device_type}"
+            )
             config = DeviceConnectConfiguration(
-                host=self.ip, port=80, device_type=self.device_type, credentials=credentials
+                host=self.ip,
+                port=80,
+                device_type=self.device_type,
+                credentials=credentials,
             )
         return await connect(config, session)
 

plugp100/new/components/countdown.py

@@ -8,38 +8,41 @@
 
 
 class Countdown(DeviceComponent):
-
     def __init__(self, client: TapoClient):
         self._client = client
-        self._rules: TapoRuleList[RuleTimer] = TapoRuleList(enable=True, countdown_rule_max_count=1, rule_list=[])
+        self._rules: TapoRuleList[RuleTimer] = TapoRuleList(
+            enable=True, countdown_rule_max_count=1, rule_list=[]
+        )
 
     async def update(self, current_state: dict[str, Any] | None = None):
         request = TapoRequest(method="get_countdown_rules", params={"start_index": 0})
-        self._rules = (await self._client.execute_raw_request(request)) \
-            .map(lambda x: TapoRuleList.from_json(x, RuleTimer)) \
+        self._rules = (
+            (await self._client.execute_raw_request(request))
+            .map(lambda x: TapoRuleList.from_json(x, RuleTimer))
             .get_or_else(self._rules)
+        )
 
     def get_countdown_rules(self) -> "TapoRuleList[RuleTimer]":
         return self._rules
 
     async def add_countdown_on(self, timer_seconds: int) -> Try[bool]:
-        return await self._add_countdown_rule(timer_seconds, {
-            'on': True
-        })
+        return await self._add_countdown_rule(timer_seconds, {"on": True})
 
     async def add_countdown_off(self, timer_seconds: int) -> Try[bool]:
-        return await self._add_countdown_rule(timer_seconds, {
-            'on': False
-        })
-
-    async def _add_countdown_rule(self, timer_seconds: int, desired_state: dict[str, Any]) -> Try[bool]:
-        request = TapoRequest(method="add_countdown_rule", params={
-            "delay": timer_seconds,
-            "desired_states": desired_state,
-            "enable": True,
-        })
-        return (await self._client.execute_raw_request(request)) \
-            .map(lambda _: True)
+        return await self._add_countdown_rule(timer_seconds, {"on": False})
+
+    async def _add_countdown_rule(
+        self, timer_seconds: int, desired_state: dict[str, Any]
+    ) -> Try[bool]:
+        request = TapoRequest(
+            method="add_countdown_rule",
+            params={
+                "delay": timer_seconds,
+                "desired_states": desired_state,
+                "enable": True,
+            },
+        )
+        return (await self._client.execute_raw_request(request)).map(lambda _: True)
 
 
 T = TypeVar("T")
@@ -56,10 +59,7 @@ def from_json(data: dict[str, Any], constructor: T) -> "TapoRuleList[T]":
         return TapoRuleList(
             enable=data.get("enable", False),
             countdown_rule_max_count=data.get("countdown_rule_max_count", 1),
-            rule_list=list(map(
-                lambda x: constructor(**x),
-                data.get('rule_list', [])
-            ))
+            rule_list=list(map(lambda x: constructor(**x), data.get("rule_list", []))),
         )
 
 

plugp100/new/components/hub_children_component.py

@@ -39,9 +39,12 @@ async def update(self, current_state: dict[str, Any] | None = None):
                 if child_device is not None:
                     self._children.append(child_device)
                 else:
-                    _LOGGER.warning(f"Found child device not supported, model {child.model}", )
                     _LOGGER.warning(
-                        "Please request support by opening an issue to https://github.com/petretiandrea/plugp100/issues/new")
+                        f"Found child device not supported, model {child.model}",
+                    )
+                    _LOGGER.warning(
+                        "Please request support by opening an issue to https://github.com/petretiandrea/plugp100/issues/new"
+                    )
 
             for child_device in self._children:
                 await child_device.update()
@@ -52,17 +55,17 @@ def find_child_device_by_model(self, model_filter: str) -> Optional["TapoDevice"
                 child
                 for child in self.children
                 if child.device_id is not None
-                   and model_filter.lower() in child.model.lower()
+                and model_filter.lower() in child.model.lower()
             ),
             None,
         )
 
 
 # TODO: make based on device type
 def _hub_child_create(
-        parent_device: TapoDevice,
-        client: TapoClient,
-        child_info: HubChildBaseInfo,
+    parent_device: TapoDevice,
+    client: TapoClient,
+    child_info: HubChildBaseInfo,
 ) -> Optional[TapoDevice]:
     model = child_info.model.lower()
     if "t31" in model:

plugp100/new/device_factory.py

@@ -90,11 +90,11 @@ async def _guess_protocol(
         KlapProtocol(config.credentials, config.url, klap_handshake_v2(), session),
     ]
     device_info_request = TapoRequest.get_device_info()
-    for i,protocol in enumerate(protocols):
+    for i, protocol in enumerate(protocols):
         info = await protocol.send_request(device_info_request)
         if info.is_success():
             _LOGGER.debug(f"Found working protocol {type(protocol)}")
-            for j,p in enumerate(protocols):
+            for j, p in enumerate(protocols):
                 if i != j:
                     await p.close()
             return protocol

plugp100/new/tapodevice.py

@@ -27,12 +27,12 @@ class LastUpdate:
 
 class TapoDevice:
     def __init__(
-            self,
-            host: str,
-            port: Optional[int],
-            client: TapoClient,
-            device_type: DeviceType = DeviceType.Unknown,
-            child_id: Optional[str] = None,
+        self,
+        host: str,
+        port: Optional[int],
+        client: TapoClient,
+        device_type: DeviceType = DeviceType.Unknown,
+        child_id: Optional[str] = None,
     ):
         self.host = host
         self.port = port
@@ -171,8 +171,7 @@ async def start_firmware_upgrade(self) -> bool:
             response = await self.client.control_child(self._child_id, request)
         else:
             response = await self.client.execute_raw_request(request)
-        return response.map(lambda _: True) \
-            .get_or_else(False)
+        return response.map(lambda _: True).get_or_else(False)
 
     async def _negotiate_components(self) -> Components:
         if self._child_id:

plugp100/responses/firmware.py

@@ -33,7 +33,7 @@ class FirmwareDownloadStatus(enum.Enum):
     DOWNLOAD_FAIL = -1001
     CHECK_FAIL = -1002
     TRANSFER_FAIL = -1003
-    LOW_BATTERY = - 1004
+    LOW_BATTERY = -1004
 
 
 @dataclasses.dataclass
@@ -51,5 +51,5 @@ def from_json(data: dict[str, Any]) -> "FirmwareDownloadProgress":
             download_in_progress=data.get("download_progress", 0),
             reboot_time=data.get("reboot_time", 0),
             upgrade_time=data.get("upgrade_time", 0),
-            auto_upgrade=data.get("auto_upgrade", False)
+            auto_upgrade=data.get("auto_upgrade", False),
         )