Extend max line length from 88 to 110

The project source code indents quite a lot, so lines tend to be longer. Let Black flows lines to a length of 110 max instead of the default of 88.

Author: markruys

.github/workflows/black.yml

@@ -9,5 +9,5 @@ jobs:
       - uses: actions/checkout@v4
       - uses: psf/black@stable
         with:
-          options: "--check --verbose"
+          options: "--check --verbose --line-length 110"
           src: "./custom_components/jablotron80"

custom_components/jablotron80/__init__.py

@@ -63,9 +63,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     hass.data[DOMAIN][entry.entry_id] = {
         DATA_JABLOTRON: cu,
-        DATA_OPTIONS_UPDATE_UNSUBSCRIBER: entry.add_update_listener(
-            options_update_listener
-        ),
+        DATA_OPTIONS_UPDATE_UNSUBSCRIBER: entry.add_update_listener(options_update_listener),
     }
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -76,9 +74,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
     # This is called when an entry/configured device is to be removed. The class
     # needs to unload itself, and remove callbacks. See the classes for further
     # details
-    options_update_unsubscriber = hass.data[DOMAIN][entry.entry_id][
-        DATA_OPTIONS_UPDATE_UNSUBSCRIBER
-    ]
+    options_update_unsubscriber = hass.data[DOMAIN][entry.entry_id][DATA_OPTIONS_UPDATE_UNSUBSCRIBER]
     options_update_unsubscriber()
     cu = hass.data[DOMAIN][entry.entry_id][DATA_JABLOTRON]
     cu.shutdown()

custom_components/jablotron80/alarm_control_panel.py

@@ -31,9 +31,7 @@
 LOGGER = logging.getLogger(__package__)
 
 
-async def async_setup_entry(
-    hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities
-) -> None:
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities) -> None:
     cu = hass.data[DOMAIN][config_entry.entry_id][DATA_JABLOTRON]
     # how to handle split system?
     if cu.mode != JA80CentralUnit.SYSTEM_MODE_SPLIT:
@@ -51,9 +49,7 @@ def check_zone_status(zone: JablotronZone, status: str) -> bool:
 
 class Jablotron80AlarmControl(JablotronEntity, AlarmControlPanelEntity):
 
-    def __init__(
-        self, cu: JA80CentralUnit, zones: List[JablotronZone], main_zone: int = 0
-    ) -> None:
+    def __init__(self, cu: JA80CentralUnit, zones: List[JablotronZone], main_zone: int = 0) -> None:
         self._object = zones[main_zone]
         self._main_zone = main_zone
         self._cu = cu
@@ -75,10 +71,7 @@ def _check_code(code: Optional[str]) -> Optional[str]:
     @property
     def supported_features(self) -> int:
         if self._cu.mode == JA80CentralUnit.SYSTEM_MODE_UNSPLIT:
-            return (
-                AlarmControlPanelEntityFeature.ARM_AWAY
-                | AlarmControlPanelEntityFeature.TRIGGER
-            )
+            return AlarmControlPanelEntityFeature.ARM_AWAY | AlarmControlPanelEntityFeature.TRIGGER
         elif self._cu.mode == JA80CentralUnit.SYSTEM_MODE_PARTIAL:
             return (
                 AlarmControlPanelEntityFeature.ARM_AWAY
@@ -92,10 +85,7 @@ def supported_features(self) -> int:
                 | AlarmControlPanelEntityFeature.ARM_HOME
                 | AlarmControlPanelEntityFeature.TRIGGER
             )
-        return (
-            AlarmControlPanelEntityFeature.ARM_AWAY
-            | AlarmControlPanelEntityFeature.TRIGGER
-        )
+        return AlarmControlPanelEntityFeature.ARM_AWAY | AlarmControlPanelEntityFeature.TRIGGER
 
     @property
     def code_arm_required(self) -> bool:
@@ -181,28 +171,16 @@ async def async_alarm_arm_custom_bypass(self, code=None) -> None:
         raise NotImplementedError()
 
     def get_active_zone(self) -> JablotronZone:
-        if (
-            self._cu.mode == JA80CentralUnit.SYSTEM_MODE_UNSPLIT
-            and len(self._zones) == 1
-        ):
+        if self._cu.mode == JA80CentralUnit.SYSTEM_MODE_UNSPLIT and len(self._zones) == 1:
             return self._zones[0]
-        elif (
-            self._cu.mode == JA80CentralUnit.SYSTEM_MODE_PARTIAL
-            and len(self._zones) == 3
-        ):
+        elif self._cu.mode == JA80CentralUnit.SYSTEM_MODE_PARTIAL and len(self._zones) == 3:
             zone_home = self._zones[0]
             zone_night = self._zones[1]
             zone_away = self._zones[2]
-            for zone in [
-                zone
-                for zone in self._zones
-                if check_zone_status(zone, JablotronZone.STATUS_ALARM)
-            ]:
+            for zone in [zone for zone in self._zones if check_zone_status(zone, JablotronZone.STATUS_ALARM)]:
                 return zone
             for zone in [
-                zone
-                for zone in self._zones
-                if check_zone_status(zone, JablotronZone.STATUS_ENTRY_DELAY)
+                zone for zone in self._zones if check_zone_status(zone, JablotronZone.STATUS_ENTRY_DELAY)
             ]:
                 return zone
             if check_zone_status(zone_away, JablotronZone.STATUS_ARMED):
@@ -212,26 +190,18 @@ def get_active_zone(self) -> JablotronZone:
             elif check_zone_status(zone_home, JablotronZone.STATUS_ARMED):
                 return zone_home
             for zone in [
-                zone
-                for zone in self._zones
-                if check_zone_status(zone, JablotronZone.STATUS_ARMING)
+                zone for zone in self._zones if check_zone_status(zone, JablotronZone.STATUS_ARMING)
             ]:
                 return zone
             for zone in [
-                zone
-                for zone in self._zones
-                if check_zone_status(zone, JablotronZone.STATUS_DISARMED)
+                zone for zone in self._zones if check_zone_status(zone, JablotronZone.STATUS_DISARMED)
             ]:
                 return zone
-        elif (
-            self._cu.mode == JA80CentralUnit.SYSTEM_MODE_SPLIT and len(self._zones) == 3
-        ):
+        elif self._cu.mode == JA80CentralUnit.SYSTEM_MODE_SPLIT and len(self._zones) == 3:
             zone_home = self._zones[self._main_zone]
             zone_away = self._zones[2]
             for zone in [
-                zone
-                for zone in [zone_home, zone_away]
-                if check_zone_status(zone, JablotronZone.STATUS_ALARM)
+                zone for zone in [zone_home, zone_away] if check_zone_status(zone, JablotronZone.STATUS_ALARM)
             ]:
                 return zone
             for zone in [
@@ -269,8 +239,7 @@ def alarm_state(self) -> AlarmControlPanelState | None:
             return AlarmControlPanelState.TRIGGERED
 
         elif (
-            zone.status == JablotronZone.STATUS_ARMED
-            and self._cu.mode == JA80CentralUnit.SYSTEM_MODE_UNSPLIT
+            zone.status == JablotronZone.STATUS_ARMED and self._cu.mode == JA80CentralUnit.SYSTEM_MODE_UNSPLIT
         ):
             return AlarmControlPanelState.ARMED_AWAY
 

custom_components/jablotron80/binary_sensor.py

@@ -28,20 +28,12 @@
 LOGGER = logging.getLogger(__package__)
 
 
-async def async_setup_entry(
-    hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities
-) -> None:
-    cu = hass.data[DOMAIN][config_entry.entry_id][
-        DATA_JABLOTRON
-    ]  # type: JA80CentralUnit
-    async_add_entities(
-        [JablotronDeviceSensorEntity(device, cu) for device in cu.devices], True
-    )
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities) -> None:
+    cu = hass.data[DOMAIN][config_entry.entry_id][DATA_JABLOTRON]  # type: JA80CentralUnit
+    async_add_entities([JablotronDeviceSensorEntity(device, cu) for device in cu.devices], True)
     async_add_entities([JablotronDeviceSensorEntity(cu.central_device, cu)], True)
     async_add_entities([JablotronDeviceSensorEntity(led, cu) for led in cu.leds], True)
-    async_add_entities(
-        [JablotronDeviceSensorEntity(code, cu) for code in cu.codes], True
-    )
+    async_add_entities([JablotronDeviceSensorEntity(code, cu) for code in cu.codes], True)
     async_add_entities([JablotronDeviceSensorEntity(cu.statustext, cu)], True)
 
 
@@ -60,10 +52,7 @@ def icon(self) -> Optional[str]:
     @property
     def device_class(self) -> Optional[str]:
         if self._object._id <= 0:
-            if (
-                "code" == self._object.type
-                and self._object.reaction == JablotronConstants.REACTION_PANIC
-            ):
+            if "code" == self._object.type and self._object.reaction == JablotronConstants.REACTION_PANIC:
                 return BinarySensorDeviceClass.SAFETY
             elif (
                 "code" == self._object.type

custom_components/jablotron80/button.py

@@ -12,12 +12,8 @@
 LOGGER = logging.getLogger(__package__)
 
 
-async def async_setup_entry(
-    hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities
-) -> None:
-    cu = hass.data[DOMAIN][config_entry.entry_id][
-        DATA_JABLOTRON
-    ]  # type: JA80CentralUnit
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities) -> None:
+    cu = hass.data[DOMAIN][config_entry.entry_id][DATA_JABLOTRON]  # type: JA80CentralUnit
     async_add_entities([JablotronQueryButtonEntity(cu.query, cu)], True)
 
 

custom_components/jablotron80/config_flow.py

@@ -71,9 +71,7 @@ def async_get_options_flow(
     ) -> config_entries.OptionsFlow:
         return JablotronOptionsFlow(config_entry)
 
-    async def async_step_user(
-        self, user_input: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
+    async def async_step_user(self, user_input: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Handle the initial step."""
         # This goes through the steps to take the user through the setup process.
         # Using this it is possible to update the UI and prompt for additional
@@ -93,9 +91,7 @@ async def async_step_user(
                 CABLE_MODEL: cables_by_names[user_input[CABLE_MODEL]],
                 CONFIGURATION_SERIAL_PORT: user_input[CONFIGURATION_SERIAL_PORT],
                 CONFIGURATION_PASSWORD: user_input[CONFIGURATION_PASSWORD],
-                CONFIGURATION_NUMBER_OF_WIRED_DEVICES: user_input[
-                    CONFIGURATION_NUMBER_OF_WIRED_DEVICES
-                ],
+                CONFIGURATION_NUMBER_OF_WIRED_DEVICES: user_input[CONFIGURATION_NUMBER_OF_WIRED_DEVICES],
             }
             cu = JA80CentralUnit(None, self._config, None)
             await cu.initialize()
@@ -133,9 +129,7 @@ async def async_step_user(
                     vol.Required(CABLE_MODEL, default=DEFAULT_CABLE_MODEL): vol.In(
                         list(CABLE_MODELS.values())
                     ),
-                    vol.Required(
-                        CONFIGURATION_SERIAL_PORT, default=DEFAULT_SERIAL_PORT
-                    ): str,
+                    vol.Required(CONFIGURATION_SERIAL_PORT, default=DEFAULT_SERIAL_PORT): str,
                     vol.Required(CONFIGURATION_PASSWORD): str,
                     vol.Optional(
                         CONFIGURATION_NUMBER_OF_WIRED_DEVICES,
@@ -149,9 +143,7 @@ async def async_step_user(
             errors=errors,
         )
 
-    async def async_step_devices(
-        self, user_input: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
+    async def async_step_devices(self, user_input: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         errors = {}
         devices_by_names = {value: key for key, value in DEVICES.items()}
         if user_input is not None:
@@ -168,13 +160,9 @@ async def async_step_devices(
                     }
                 for input in sorted(user_input):
                     parts = input.split("_")
-                    if parts[0] == "device" and (
-                        parts[2] == "name" or parts[2] == "type"
-                    ):
+                    if parts[0] == "device" and (parts[2] == "name" or parts[2] == "type"):
                         if parts[2] == "type":
-                            devices[int(parts[1])][parts[2]] = devices_by_names[
-                                user_input[input]
-                            ]
+                            devices[int(parts[1])][parts[2]] = devices_by_names[user_input[input]]
                         else:
                             devices[int(parts[1])][parts[2]] = user_input[input]
 
@@ -212,24 +200,18 @@ async def async_step_devices(
                 default_device = DEVICES[DEVICE_DOOR_OPENING_DETECTOR]
             else:
                 default_device = DEVICES[DEVICE_OTHER]
-            fields[
-                vol.Required(
-                    "device_{:03}_type".format(device.id), default=default_device
-                )
-            ] = vol.In(list(DEVICES.values()))
-            fields[
-                vol.Required("device_{:03}_name".format(device.id), default=device.name)
-            ] = str
+            fields[vol.Required("device_{:03}_type".format(device.id), default=default_device)] = vol.In(
+                list(DEVICES.values())
+            )
+            fields[vol.Required("device_{:03}_name".format(device.id), default=device.name)] = str
 
         return self.async_show_form(
             step_id="devices",
             data_schema=vol.Schema(fields),
             errors=errors,
         )
 
-    async def async_step_codes(
-        self, user_input: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
+    async def async_step_codes(self, user_input: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         errors = {}
         if user_input is not None:
             try:
@@ -262,9 +244,7 @@ async def async_step_codes(
                 default_name = "Master"
             if code.id == 63:
                 default_name = "Service"
-            fields[
-                vol.Required("code_{:03}_name".format(code.id), default=default_name)
-            ] = str
+            fields[vol.Required("code_{:03}_name".format(code.id), default=default_name)] = str
 
         return self.async_show_form(
             step_id="codes",