Replace in-place sets with tuples

homeassistant/components/broadlink/config_flow.py

@@ -97,7 +97,7 @@ async def async_step_user(self, user_input=None):
                 err_msg = "Device not found"
 
             except OSError as err:
-                if err.errno in {errno.EINVAL, socket.EAI_NONAME}:
+                if err.errno in (errno.EINVAL, socket.EAI_NONAME):
                     errors["base"] = "invalid_host"
                     err_msg = "Invalid hostname or IP address"
                 elif err.errno == errno.ENETUNREACH:

homeassistant/components/broadlink/switch.py

@@ -109,7 +109,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up the Broadlink switch."""
     device = hass.data[DOMAIN].devices[config_entry.entry_id]
 
-    if device.api.type in {"RM4MINI", "RM4PRO", "RMMINI", "RMMINIB", "RMPRO"}:
+    if device.api.type in ("RM4MINI", "RM4PRO", "RMMINI", "RMMINIB", "RMPRO"):
         platform_data = hass.data[DOMAIN].platforms.get(SWITCH_DOMAIN, {})
         user_defined_switches = platform_data.get(device.api.mac, {})
         switches = [
@@ -119,7 +119,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
     elif device.api.type == "SP1":
         switches = [BroadlinkSP1Switch(device)]
 
-    elif device.api.type in {"SP2", "SP2S", "SP3", "SP3S", "SP4", "SP4B"}:
+    elif device.api.type in ("SP2", "SP2S", "SP3", "SP3S", "SP4", "SP4B"):
         switches = [BroadlinkSP2Switch(device)]
 
     elif device.api.type == "BG1":

homeassistant/components/homekit_controller/climate.py

@@ -400,8 +400,8 @@ def current_temperature(self):
     def target_temperature(self):
         """Return the temperature we try to reach."""
         value = self.service.value(CharacteristicsTypes.HEATING_COOLING_TARGET)
-        if (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT, HVAC_MODE_COOL}) or (
-            (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT_COOL})
+        if (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT, HVAC_MODE_COOL)) or (
+            (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT_COOL,))
             and not (SUPPORT_TARGET_TEMPERATURE_RANGE & self.supported_features)
         ):
             return self.service.value(CharacteristicsTypes.TEMPERATURE_TARGET)
@@ -411,7 +411,7 @@ def target_temperature(self):
     def target_temperature_high(self):
         """Return the highbound target temperature we try to reach."""
         value = self.service.value(CharacteristicsTypes.HEATING_COOLING_TARGET)
-        if (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT_COOL}) and (
+        if (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT_COOL,)) and (
             SUPPORT_TARGET_TEMPERATURE_RANGE & self.supported_features
         ):
             return self.service.value(
@@ -423,7 +423,7 @@ def target_temperature_high(self):
     def target_temperature_low(self):
         """Return the lowbound target temperature we try to reach."""
         value = self.service.value(CharacteristicsTypes.HEATING_COOLING_TARGET)
-        if (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT_COOL}) and (
+        if (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT_COOL,)) and (
             SUPPORT_TARGET_TEMPERATURE_RANGE & self.supported_features
         ):
             return self.service.value(
@@ -435,19 +435,19 @@ def target_temperature_low(self):
     def min_temp(self):
         """Return the minimum target temp."""
         value = self.service.value(CharacteristicsTypes.HEATING_COOLING_TARGET)
-        if (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT_COOL}) and (
+        if (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT_COOL,)) and (
             SUPPORT_TARGET_TEMPERATURE_RANGE & self.supported_features
         ):
             min_temp = self.service[
                 CharacteristicsTypes.TEMPERATURE_HEATING_THRESHOLD
             ].minValue
             if min_temp is not None:
                 return min_temp
-        elif MODE_HOMEKIT_TO_HASS.get(value) in {
+        elif MODE_HOMEKIT_TO_HASS.get(value) in (
             HVAC_MODE_HEAT,
             HVAC_MODE_COOL,
             HVAC_MODE_HEAT_COOL,
-        }:
+        ):
             min_temp = self.service[CharacteristicsTypes.TEMPERATURE_TARGET].minValue
             if min_temp is not None:
                 return min_temp
@@ -457,19 +457,19 @@ def min_temp(self):
     def max_temp(self):
         """Return the maximum target temp."""
         value = self.service.value(CharacteristicsTypes.HEATING_COOLING_TARGET)
-        if (MODE_HOMEKIT_TO_HASS.get(value) in {HVAC_MODE_HEAT_COOL}) and (
+        if (MODE_HOMEKIT_TO_HASS.get(value) in (HVAC_MODE_HEAT_COOL,)) and (
             SUPPORT_TARGET_TEMPERATURE_RANGE & self.supported_features
         ):
             max_temp = self.service[
                 CharacteristicsTypes.TEMPERATURE_COOLING_THRESHOLD
             ].maxValue
             if max_temp is not None:
                 return max_temp
-        elif MODE_HOMEKIT_TO_HASS.get(value) in {
+        elif MODE_HOMEKIT_TO_HASS.get(value) in (
             HVAC_MODE_HEAT,
             HVAC_MODE_COOL,
             HVAC_MODE_HEAT_COOL,
-        }:
+        ):
             max_temp = self.service[CharacteristicsTypes.TEMPERATURE_TARGET].maxValue
             if max_temp is not None:
                 return max_temp

homeassistant/components/huawei_lte/device_tracker.py

@@ -242,10 +242,5 @@ async def async_update(self) -> None:
             self._extra_state_attributes = {
                 _better_snakecase(k): v
                 for k, v in host.items()
-                if k
-                in {
-                    "AddressSource",
-                    "AssociatedSsid",
-                    "InterfaceType",
-                }
+                if k in ("AddressSource", "AssociatedSsid", "InterfaceType")
             }

homeassistant/components/lock/reproduce_state.py

@@ -50,9 +50,9 @@ async def _async_reproduce_state(
 
     service_data = {ATTR_ENTITY_ID: state.entity_id}
 
-    if state.state in {STATE_LOCKED, STATE_LOCKING}:
+    if state.state in (STATE_LOCKED, STATE_LOCKING):
         service = SERVICE_LOCK
-    elif state.state in {STATE_UNLOCKED, STATE_UNLOCKING}:
+    elif state.state in (STATE_UNLOCKED, STATE_UNLOCKING):
         service = SERVICE_UNLOCK
 
     await hass.services.async_call(

homeassistant/components/netatmo/sensor.py

@@ -507,11 +507,11 @@ def async_update_callback(self) -> None:
 
         try:
             state = data[self.entity_description.netatmo_name]
-            if self.entity_description.key in {"temperature", "pressure", "sum_rain_1"}:
+            if self.entity_description.key in ("temperature", "pressure", "sum_rain_1"):
                 self._attr_state = round(state, 1)
-            elif self.entity_description.key in {"windangle_value", "gustangle_value"}:
+            elif self.entity_description.key in ("windangle_value", "gustangle_value"):
                 self._attr_state = fix_angle(state)
-            elif self.entity_description.key in {"windangle", "gustangle"}:
+            elif self.entity_description.key in ("windangle", "gustangle"):
                 self._attr_state = process_angle(fix_angle(state))
             elif self.entity_description.key == "rf_status":
                 self._attr_state = process_rf(state)

homeassistant/components/stream/worker.py

@@ -326,7 +326,7 @@ def stream_worker(
         audio_stream = None
     # These formats need aac_adtstoasc bitstream filter, but auto_bsf not
     # compatible with empty_moov and manual bitstream filters not in PyAV
-    if container.format.name in {"hls", "mpegts"}:
+    if container.format.name in ("hls", "mpegts"):
         audio_stream = None
     # Some audio streams do not have a profile and throw errors when remuxing
     if audio_stream and audio_stream.profile is None:

homeassistant/components/tahoma/cover.py

@@ -237,22 +237,22 @@ def stop_cover(self, **kwargs):
             == "io:RollerShutterWithLowSpeedManagementIOComponent"
         ):
             self.apply_action("setPosition", "secured")
-        elif self.tahoma_device.type in {
+        elif self.tahoma_device.type in (
             "io:ExteriorVenetianBlindIOComponent",
             "rts:BlindRTSComponent",
             "rts:DualCurtainRTSComponent",
             "rts:ExteriorVenetianBlindRTSComponent",
             "rts:VenetianBlindRTSComponent",
-        }:
+        ):
             self.apply_action("my")
-        elif self.tahoma_device.type in {
+        elif self.tahoma_device.type in (
             HORIZONTAL_AWNING,
             "io:AwningValanceIOComponent",
             "io:RollerShutterGenericIOComponent",
             "io:VerticalExteriorAwningIOComponent",
             "io:VerticalInteriorBlindVeluxIOComponent",
             "io:WindowOpenerVeluxIOComponent",
-        }:
+        ):
             self.apply_action("stop")
         else:
             self.apply_action("stopIdentify")

homeassistant/components/twitter/notify.py

@@ -206,7 +206,7 @@ def check_status_until_done(self, media_id, callback, *args):
 
         _LOGGER.debug("media processing %s status: %s", media_id, processing_info)
 
-        if processing_info["state"] in {"succeeded", "failed"}:
+        if processing_info["state"] in ("succeeded", "failed"):
             return callback(media_id)
 
         check_after_secs = processing_info["check_after_secs"]

homeassistant/components/withings/common.py

@@ -887,14 +887,14 @@ def set_value(field: GetSleepSummaryField, func: Callable) -> None:
     async def async_webhook_data_updated(self, data_category: NotifyAppli) -> None:
         """Handle scenario when data is updated from a webook."""
         _LOGGER.debug("Withings webhook triggered")
-        if data_category in {
+        if data_category in (
             NotifyAppli.WEIGHT,
             NotifyAppli.CIRCULATORY,
             NotifyAppli.SLEEP,
-        }:
+        ):
             await self.poll_data_update_coordinator.async_request_refresh()
 
-        elif data_category in {NotifyAppli.BED_IN, NotifyAppli.BED_OUT}:
+        elif data_category in (NotifyAppli.BED_IN, NotifyAppli.BED_OUT):
             self.webhook_update_coordinator.update_data(
                 Measurement.IN_BED, data_category == NotifyAppli.BED_IN
             )