Improve lists in integrations [R-S] (#113233)

* Improve lists in integrations [R-S]

* Fix

* Fix

homeassistant/components/rachio/device.py

@@ -245,10 +245,11 @@ class RachioIro:
         _deinit_webhooks(None)
 
         # Choose which events to listen for and get their IDs
-        event_types = []
+        event_types = [
-        for event_type in self.rachio.notification.get_webhook_event_type()[1]:
+            {"id": event_type[KEY_ID]}
-            if event_type[KEY_NAME] in LISTEN_EVENT_TYPES:
+            for event_type in self.rachio.notification.get_webhook_event_type()[1]
-                event_types.append({"id": event_type[KEY_ID]})
+            if event_type[KEY_NAME] in LISTEN_EVENT_TYPES
+        ]
 
         # Register to listen to these events from the device
         url = self.rachio.webhook_url

homeassistant/components/rachio/switch.py

@@ -169,10 +169,13 @@ def _create_entities(hass: HomeAssistant, config_entry: ConfigEntry) -> list[Ent
         schedules = controller.list_schedules()
         flex_schedules = controller.list_flex_schedules()
         current_schedule = controller.current_schedule
-        for zone in zones:
+        entities.extend(
-            entities.append(RachioZone(person, controller, zone, current_schedule))
+            RachioZone(person, controller, zone, current_schedule) for zone in zones
-        for sched in schedules + flex_schedules:
+        )
-            entities.append(RachioSchedule(person, controller, sched, current_schedule))
+        entities.extend(
+            RachioSchedule(person, controller, schedule, current_schedule)
+            for schedule in schedules + flex_schedules
+        )
     return entities
 
 

homeassistant/components/raincloud/binary_sensor.py

@@ -45,8 +45,10 @@ def setup_platform(
 
         else:
             # create a sensor for each zone managed by faucet
-            for zone in raincloud.controller.faucet.zones:
+            sensors.extend(
-                sensors.append(RainCloudBinarySensor(zone, sensor_type))
+                RainCloudBinarySensor(zone, sensor_type)
+                for zone in raincloud.controller.faucet.zones
+            )
 
     add_entities(sensors, True)
 

homeassistant/components/raincloud/sensor.py

@@ -48,8 +48,10 @@ def setup_platform(
             sensors.append(RainCloudSensor(raincloud.controller.faucet, sensor_type))
         else:
             # create a sensor for each zone managed by a faucet
-            for zone in raincloud.controller.faucet.zones:
+            sensors.extend(
-                sensors.append(RainCloudSensor(zone, sensor_type))
+                RainCloudSensor(zone, sensor_type)
+                for zone in raincloud.controller.faucet.zones
+            )
 
     add_entities(sensors, True)
 

homeassistant/components/raincloud/switch.py

@@ -47,13 +47,14 @@ def setup_platform(
     raincloud = hass.data[DATA_RAINCLOUD].data
     default_watering_timer = config[CONF_WATERING_TIME]
 
-    sensors = []
+    add_entities(
-    for sensor_type in config[CONF_MONITORED_CONDITIONS]:
+        (
-        # create a sensor for each zone managed by faucet
+            RainCloudSwitch(default_watering_timer, zone, sensor_type)
-        for zone in raincloud.controller.faucet.zones:
+            for zone in raincloud.controller.faucet.zones
-            sensors.append(RainCloudSwitch(default_watering_timer, zone, sensor_type))
+            for sensor_type in config[CONF_MONITORED_CONDITIONS]
-
+        ),
-    add_entities(sensors, True)
+        True,
+    )
 
 
 class RainCloudSwitch(RainCloudEntity, SwitchEntity):

homeassistant/components/recorder/migration.py

@@ -512,21 +512,20 @@ def _update_states_table_with_foreign_key_options(
 ) -> None:
     """Add the options to foreign key constraints."""
     inspector = sqlalchemy.inspect(engine)
-    alters = []
+    alters = [
-    for foreign_key in inspector.get_foreign_keys(TABLE_STATES):
-        if foreign_key["name"] and (
-            # MySQL/MariaDB will have empty options
-            not foreign_key.get("options")
-            or
-            # Postgres will have ondelete set to None
-            foreign_key.get("options", {}).get("ondelete") is None
-        ):
-            alters.append(
         {
             "old_fk": ForeignKeyConstraint((), (), name=foreign_key["name"]),
             "columns": foreign_key["constrained_columns"],
         }
+        for foreign_key in inspector.get_foreign_keys(TABLE_STATES)
+        if foreign_key["name"]
+        and (
+            # MySQL/MariaDB will have empty options
+            not foreign_key.get("options")
+            # Postgres will have ondelete set to None
+            or foreign_key.get("options", {}).get("ondelete") is None
         )
+    ]
 
     if not alters:
         return

homeassistant/components/reolink/media_source.py

@@ -243,7 +243,6 @@ class ReolinkVODMediaSource(MediaSource):
         start = now - dt.timedelta(days=31)
         end = now
 
-        children: list[BrowseMediaSource] = []
         if _LOGGER.isEnabledFor(logging.DEBUG):
             _LOGGER.debug(
                 "Requesting recording days of %s from %s to %s",
@@ -254,9 +253,7 @@ class ReolinkVODMediaSource(MediaSource):
         statuses, _ = await host.api.request_vod_files(
             channel, start, end, status_only=True, stream=stream
         )
-        for status in statuses:
+        children: list[BrowseMediaSource] = [
-            for day in status.days:
-                children.append(
             BrowseMediaSource(
                 domain=DOMAIN,
                 identifier=f"DAY|{config_entry_id}|{channel}|{stream}|{status.year}|{status.month}|{day}",
@@ -266,7 +263,9 @@ class ReolinkVODMediaSource(MediaSource):
                 can_play=False,
                 can_expand=True,
             )
-                )
+            for status in statuses
+            for day in status.days
+        ]
 
         return BrowseMediaSource(
             domain=DOMAIN,

homeassistant/components/rfxtrx/device_action.py

@@ -51,21 +51,17 @@ async def async_get_actions(
     except ValueError:
         return []
 
-    actions = []
+    return [
-    for action_type in ACTION_TYPES:
-        if hasattr(device, action_type):
-            data: dict[int, str] = getattr(device, ACTION_SELECTION[action_type], {})
-            for value in data.values():
-                actions.append(
         {
             CONF_DEVICE_ID: device_id,
             CONF_DOMAIN: DOMAIN,
             CONF_TYPE: action_type,
             CONF_SUBTYPE: value,
         }
-                )
+        for action_type in ACTION_TYPES
-
+        if hasattr(device, action_type)
-    return actions
+        for value in getattr(device, ACTION_SELECTION[action_type], {}).values()
+    ]
 
 
 def _get_commands(

homeassistant/components/rfxtrx/device_trigger.py

@@ -51,11 +51,7 @@ async def async_get_triggers(
     """List device triggers for RFXCOM RFXtrx devices."""
     device = async_get_device_object(hass, device_id)
 
-    triggers = []
+    return [
-    for conf_type in TRIGGER_TYPES:
-        data: dict[int, str] = getattr(device, TRIGGER_SELECTION[conf_type], {})
-        for command in data.values():
-            triggers.append(
         {
             CONF_PLATFORM: "device",
             CONF_DEVICE_ID: device_id,
@@ -63,8 +59,9 @@ async def async_get_triggers(
             CONF_TYPE: conf_type,
             CONF_SUBTYPE: command,
         }
-            )
+        for conf_type in TRIGGER_TYPES
-    return triggers
+        for command in getattr(device, TRIGGER_SELECTION[conf_type], {}).values()
+    ]
 
 
 async def async_validate_trigger_config(

homeassistant/components/rfxtrx/sensor.py

@@ -255,18 +255,15 @@ async def async_setup_entry(
         device_id: DeviceTuple,
         entity_info: dict[str, Any],
     ) -> list[Entity]:
-        entities: list[Entity] = []
+        return [
-        for data_type in set(event.values) & set(SENSOR_TYPES_DICT):
-            entities.append(
             RfxtrxSensor(
                 event.device,
                 device_id,
                 SENSOR_TYPES_DICT[data_type],
                 event=event if auto else None,
             )
-            )
+            for data_type in set(event.values) & set(SENSOR_TYPES_DICT)
-
+        ]
-        return entities
 
     await async_setup_platform_entry(
         hass, config_entry, async_add_entities, _supported, _constructor

homeassistant/components/ring/diagnostics.py

@@ -34,10 +34,11 @@ async def async_get_config_entry_diagnostics(
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
     ring: ring_doorbell.Ring = hass.data[DOMAIN][entry.entry_id]["api"]
-    devices_raw = []
+    devices_raw = [
-    for device_type in ring.devices_data:
+        ring.devices_data[device_type][device_id]
-        for device_id in ring.devices_data[device_type]:
+        for device_type in ring.devices_data
-            devices_raw.append(ring.devices_data[device_type][device_id])
+        for device_id in ring.devices_data[device_type]
+    ]
     return async_redact_data(
         {"device_data": devices_raw},
         TO_REDACT,

homeassistant/components/ring/light.py

@@ -41,13 +41,12 @@ async def async_setup_entry(
     devices_coordinator: RingDataCoordinator = hass.data[DOMAIN][config_entry.entry_id][
         RING_DEVICES_COORDINATOR
     ]
-    lights = []
 
-    for device in devices["stickup_cams"]:
+    async_add_entities(
-        if device.has_capability("light"):
+        RingLight(device, devices_coordinator)
-            lights.append(RingLight(device, devices_coordinator))
+        for device in devices["stickup_cams"]
-
+        if device.has_capability("light")
-    async_add_entities(lights)
+    )
 
 
 class RingLight(RingEntity, LightEntity):

homeassistant/components/ring/siren.py

@@ -28,12 +28,10 @@ async def async_setup_entry(
     coordinator: RingDataCoordinator = hass.data[DOMAIN][config_entry.entry_id][
         RING_DEVICES_COORDINATOR
     ]
-    sirens = []
 
-    for device in devices["chimes"]:
+    async_add_entities(
-        sirens.append(RingChimeSiren(device, coordinator))
+        RingChimeSiren(device, coordinator) for device in devices["chimes"]
-
+    )
-    async_add_entities(sirens)
 
 
 class RingChimeSiren(RingEntity, SirenEntity):

homeassistant/components/ring/switch.py

@@ -38,13 +38,12 @@ async def async_setup_entry(
     coordinator: RingDataCoordinator = hass.data[DOMAIN][config_entry.entry_id][
         RING_DEVICES_COORDINATOR
     ]
-    switches = []
 
-    for device in devices["stickup_cams"]:
+    async_add_entities(
-        if device.has_capability("siren"):
+        SirenSwitch(device, coordinator)
-            switches.append(SirenSwitch(device, coordinator))
+        for device in devices["stickup_cams"]
-
+        if device.has_capability("siren")
-    async_add_entities(switches)
+    )
 
 
 class BaseRingSwitch(RingEntity, SwitchEntity):

homeassistant/components/roborock/__init__.py

@@ -87,12 +87,10 @@ def build_setup_functions(
     product_info: dict[str, HomeDataProduct],
 ) -> list[Coroutine[Any, Any, RoborockDataUpdateCoordinator | None]]:
     """Create a list of setup functions that can later be called asynchronously."""
-    setup_functions = []
+    return [
-    for device in device_map.values():
-        setup_functions.append(
         setup_device(hass, user_data, device, product_info[device.product_id])
-        )
+        for device in device_map.values()
-    return setup_functions
+    ]
 
 
 async def setup_device(

homeassistant/components/roku/select.py

@@ -115,15 +115,13 @@ async def async_setup_entry(
     coordinator: RokuDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
     device: RokuDevice = coordinator.data
 
-    entities: list[RokuSelectEntity] = []
+    entities: list[RokuSelectEntity] = [
-
-    for description in ENTITIES:
-        entities.append(
         RokuSelectEntity(
             coordinator=coordinator,
             description=description,
         )
-        )
+        for description in ENTITIES
+    ]
 
     if len(device.channels) > 0:
         entities.append(

homeassistant/components/roomba/braava.py

@@ -37,11 +37,11 @@ class BraavaJet(IRobotVacuum):
         super().__init__(roomba, blid)
 
         # Initialize fan speed list
-        speed_list = []
+        self._attr_fan_speed_list = [
-        for behavior in BRAAVA_MOP_BEHAVIORS:
+            f"{behavior}-{spray}"
-            for spray in BRAAVA_SPRAY_AMOUNT:
+            for behavior in BRAAVA_MOP_BEHAVIORS
-                speed_list.append(f"{behavior}-{spray}")
+            for spray in BRAAVA_SPRAY_AMOUNT
-        self._attr_fan_speed_list = speed_list
+        ]
 
     @property
     def fan_speed(self):

homeassistant/components/russound_rnet/media_player.py

@@ -58,9 +58,7 @@ def setup_platform(
     russ = russound.Russound(host, port)
     russ.connect()
 
-    sources = []
+    sources = [source["name"] for source in config[CONF_SOURCES]]
-    for source in config[CONF_SOURCES]:
-        sources.append(source["name"])
 
     if russ.is_connected():
         for zone_id, extra in config[CONF_ZONES].items():

homeassistant/components/saj/sensor.py

@@ -79,7 +79,7 @@ async def async_setup_platform(
     sensor_def = pysaj.Sensors(wifi)
 
     # Use all sensors by default
-    hass_sensors = []
+    hass_sensors: list[SAJsensor] = []
 
     kwargs = {}
     if wifi:
@@ -103,10 +103,10 @@ async def async_setup_platform(
     if not done:
         raise PlatformNotReady
 
-    for sensor in sensor_def:
+    hass_sensors.extend(
-        if sensor.enabled:
-            hass_sensors.append(
         SAJsensor(saj.serialnumber, sensor, inverter_name=config.get(CONF_NAME))
+        for sensor in sensor_def
+        if sensor.enabled
     )
 
     async_add_entities(hass_sensors)

homeassistant/components/schlage/binary_sensor.py

@@ -45,17 +45,15 @@ async def async_setup_entry(
 ) -> None:
     """Set up binary_sensors based on a config entry."""
     coordinator: SchlageDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id]
-    entities = []
+    async_add_entities(
-    for device_id in coordinator.data.locks:
-        for description in _DESCRIPTIONS:
-            entities.append(
         SchlageBinarySensor(
             coordinator=coordinator,
             description=description,
             device_id=device_id,
         )
+        for device_id in coordinator.data.locks
+        for description in _DESCRIPTIONS
     )
-    async_add_entities(entities)
 
 
 class SchlageBinarySensor(SchlageEntity, BinarySensorEntity):

homeassistant/components/schlage/switch.py

@@ -62,17 +62,15 @@ async def async_setup_entry(
 ) -> None:
     """Set up switches based on a config entry."""
     coordinator: SchlageDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id]
-    entities = []
+    async_add_entities(
-    for device_id in coordinator.data.locks:
-        for description in SWITCHES:
-            entities.append(
         SchlageSwitch(
             coordinator=coordinator,
             description=description,
             device_id=device_id,
         )
+        for device_id in coordinator.data.locks
+        for description in SWITCHES
     )
-    async_add_entities(entities)
 
 
 class SchlageSwitch(SchlageEntity, SwitchEntity):

homeassistant/components/screenlogic/binary_sensor.py

@@ -175,31 +175,30 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up entry."""
-    entities: list[ScreenLogicBinarySensor] = []
     coordinator: ScreenlogicDataUpdateCoordinator = hass.data[SL_DOMAIN][
         config_entry.entry_id
     ]
     gateway = coordinator.gateway
 
-    for core_sensor_description in SUPPORTED_CORE_SENSORS:
+    entities: list[ScreenLogicBinarySensor] = [
+        ScreenLogicPushBinarySensor(coordinator, core_sensor_description)
+        for core_sensor_description in SUPPORTED_CORE_SENSORS
         if (
             gateway.get_data(
                 *core_sensor_description.data_root, core_sensor_description.key
             )
             is not None
-        ):
-            entities.append(
-                ScreenLogicPushBinarySensor(coordinator, core_sensor_description)
         )
+    ]
 
     for p_index, p_data in gateway.get_data(DEVICE.PUMP).items():
         if not p_data or not p_data.get(VALUE.DATA):
             continue
-        for proto_pump_sensor_description in SUPPORTED_PUMP_SENSORS:
+        entities.extend(
-            entities.append(
             ScreenLogicPumpBinarySensor(
                 coordinator, copy(proto_pump_sensor_description), p_index
             )
+            for proto_pump_sensor_description in SUPPORTED_PUMP_SENSORS
         )
 
     chem_sensor_description: ScreenLogicPushBinarySensorDescription

homeassistant/components/screenlogic/climate.py

@@ -47,15 +47,13 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up entry."""
-    entities = []
     coordinator: ScreenlogicDataUpdateCoordinator = hass.data[SL_DOMAIN][
         config_entry.entry_id
     ]
 
     gateway = coordinator.gateway
 
-    for body_index in gateway.get_data(DEVICE.BODY):
+    async_add_entities(
-        entities.append(
         ScreenLogicClimate(
             coordinator,
             ScreenLogicClimateDescription(
@@ -64,10 +62,9 @@ async def async_setup_entry(
                 key=body_index,
             ),
         )
+        for body_index in gateway.get_data(DEVICE.BODY)
     )
 
-    async_add_entities(entities)
-
 
 @dataclass(frozen=True, kw_only=True)
 class ScreenLogicClimateDescription(

homeassistant/components/screenlogic/sensor.py

@@ -227,20 +227,21 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up entry."""
-    entities: list[ScreenLogicSensor] = []
     coordinator: ScreenlogicDataUpdateCoordinator = hass.data[SL_DOMAIN][
         config_entry.entry_id
     ]
     gateway = coordinator.gateway
 
-    for core_sensor_description in SUPPORTED_CORE_SENSORS:
+    entities: list[ScreenLogicSensor] = [
+        ScreenLogicPushSensor(coordinator, core_sensor_description)
+        for core_sensor_description in SUPPORTED_CORE_SENSORS
         if (
             gateway.get_data(
                 *core_sensor_description.data_root, core_sensor_description.key
             )
             is not None
-        ):
+        )
-            entities.append(ScreenLogicPushSensor(coordinator, core_sensor_description))
+    ]
 
     for pump_index, pump_data in gateway.get_data(DEVICE.PUMP).items():
         if not pump_data or not pump_data.get(VALUE.DATA):

homeassistant/components/sense/sensor.py

@@ -127,8 +127,10 @@ async def async_setup_entry(
             )
         )
 
-    for i in range(len(data.active_voltage)):
+    entities.extend(
-        entities.append(SenseVoltageSensor(data, i, sense_monitor_id))
+        SenseVoltageSensor(data, i, sense_monitor_id)
+        for i in range(len(data.active_voltage))
+    )
 
     for type_id, typ in TRENDS_SENSOR_TYPES.items():
         for variant_id, variant_name in TREND_SENSOR_VARIANTS:

homeassistant/components/sensibo/climate.py

@@ -230,11 +230,9 @@ class SensiboClimate(SensiboDeviceBaseEntity, ClimateEntity):
     @property
     def hvac_modes(self) -> list[HVACMode]:
         """Return the list of available hvac operation modes."""
-        hvac_modes = []
         if TYPE_CHECKING:
             assert self.device_data.hvac_modes
-        for mode in self.device_data.hvac_modes:
+        hvac_modes = [SENSIBO_TO_HA[mode] for mode in self.device_data.hvac_modes]
-            hvac_modes.append(SENSIBO_TO_HA[mode])
         return hvac_modes if hvac_modes else [HVACMode.OFF]
 
     @property

homeassistant/components/seven_segments/image_processing.py

@@ -57,16 +57,13 @@ async def async_setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up the Seven segments OCR platform."""
-    entities = []
+    async_add_entities(
-    for camera in config[CONF_SOURCE]:
-        entities.append(
         ImageProcessingSsocr(
             hass, camera[CONF_ENTITY_ID], config, camera.get(CONF_NAME)
         )
+        for camera in config[CONF_SOURCE]
     )
 
-    async_add_entities(entities)
-
 
 class ImageProcessingSsocr(ImageProcessingEntity):
     """Representation of the seven segments OCR image processing entity."""

homeassistant/components/shelly/utils.py

@@ -188,8 +188,6 @@ def get_block_input_triggers(
     if not is_block_momentary_input(device.settings, block, True):
         return []
 
-    triggers = []
-
     if block.type == "device" or get_number_of_channels(device, block) == 1:
         subtype = "button"
     else:
@@ -203,20 +201,12 @@ def get_block_input_triggers(
     else:
         trigger_types = BASIC_INPUTS_EVENTS_TYPES
 
-    for trigger_type in trigger_types:
+    return [(trigger_type, subtype) for trigger_type in trigger_types]
-        triggers.append((trigger_type, subtype))
-
-    return triggers
 
 
 def get_shbtn_input_triggers() -> list[tuple[str, str]]:
     """Return list of input triggers for SHBTN models."""
-    triggers = []
+    return [(trigger_type, "button") for trigger_type in SHBTN_INPUTS_EVENTS_TYPES]
-
-    for trigger_type in SHBTN_INPUTS_EVENTS_TYPES:
-        triggers.append((trigger_type, "button"))
-
-    return triggers
 
 
 @singleton.singleton("shelly_coap")

homeassistant/components/sigfox/sensor.py

@@ -52,10 +52,7 @@ def setup_platform(
     auth = sigfox.auth
     devices = sigfox.devices
 
-    sensors = []
+    add_entities((SigfoxDevice(device, auth, name) for device in devices), True)
-    for device in devices:
-        sensors.append(SigfoxDevice(device, auth, name))
-    add_entities(sensors, True)
 
 
 def epoch_to_datetime(epoch_time):
@@ -105,8 +102,7 @@ class SigfoxAPI:
             url = urljoin(API_URL, location_url)
             response = requests.get(url, auth=self._auth, timeout=10)
             devices_data = json.loads(response.text)["data"]
-            for device in devices_data:
+            devices.extend(device["id"] for device in devices_data)
-                devices.append(device["id"])
         return devices
 
     @property

homeassistant/components/simplisafe/binary_sensor.py

@@ -79,8 +79,10 @@ async def async_setup_entry(
             if sensor.type in SUPPORTED_BATTERY_SENSOR_TYPES:
                 sensors.append(BatteryBinarySensor(simplisafe, system, sensor))
 
-        for lock in system.locks.values():
+        sensors.extend(
-            sensors.append(BatteryBinarySensor(simplisafe, system, lock))
+            BatteryBinarySensor(simplisafe, system, lock)
+            for lock in system.locks.values()
+        )
 
     async_add_entities(sensors)
 

homeassistant/components/simplisafe/lock.py

@@ -34,15 +34,16 @@ async def async_setup_entry(
 ) -> None:
     """Set up SimpliSafe locks based on a config entry."""
     simplisafe = hass.data[DOMAIN][entry.entry_id]
-    locks = []
+    locks: list[SimpliSafeLock] = []
 
     for system in simplisafe.systems.values():
         if system.version == 2:
             LOGGER.info("Skipping lock setup for V2 system: %s", system.system_id)
             continue
 
-        for lock in system.locks.values():
+        locks.extend(
-            locks.append(SimpliSafeLock(simplisafe, system, lock))
+            SimpliSafeLock(simplisafe, system, lock) for lock in system.locks.values()
+        )
 
     async_add_entities(locks)
 

homeassistant/components/simplisafe/sensor.py

@@ -25,16 +25,18 @@ async def async_setup_entry(
 ) -> None:
     """Set up SimpliSafe freeze sensors based on a config entry."""
     simplisafe = hass.data[DOMAIN][entry.entry_id]
-    sensors = []
+    sensors: list[SimplisafeFreezeSensor] = []
 
     for system in simplisafe.systems.values():
         if system.version == 2:
             LOGGER.info("Skipping sensor setup for V2 system: %s", system.system_id)
             continue
 
-        for sensor in system.sensors.values():
+        sensors.extend(
-            if sensor.type == DeviceTypes.TEMPERATURE:
+            SimplisafeFreezeSensor(simplisafe, system, sensor)
-                sensors.append(SimplisafeFreezeSensor(simplisafe, system, sensor))
+            for sensor in system.sensors.values()
+            if sensor.type == DeviceTypes.TEMPERATURE
+        )
 
     async_add_entities(sensors)
 

homeassistant/components/sleepiq/number.py

@@ -143,34 +143,34 @@ async def async_setup_entry(
     """Set up the SleepIQ bed sensors."""
     data: SleepIQData = hass.data[DOMAIN][entry.entry_id]
 
-    entities = []
+    entities: list[SleepIQNumberEntity] = []
     for bed in data.client.beds.values():
-        for sleeper in bed.sleepers:
+        entities.extend(
-            entities.append(
             SleepIQNumberEntity(
                 data.data_coordinator,
                 bed,
                 sleeper,
                 NUMBER_DESCRIPTIONS[FIRMNESS],
             )
+            for sleeper in bed.sleepers
         )
-        for actuator in bed.foundation.actuators:
+        entities.extend(
-            entities.append(
             SleepIQNumberEntity(
                 data.data_coordinator,
                 bed,
                 actuator,
                 NUMBER_DESCRIPTIONS[ACTUATOR],
             )
+            for actuator in bed.foundation.actuators
         )
-        for foot_warmer in bed.foundation.foot_warmers:
+        entities.extend(
-            entities.append(
             SleepIQNumberEntity(
                 data.data_coordinator,
                 bed,
                 foot_warmer,
                 NUMBER_DESCRIPTIONS[FOOT_WARMING_TIMER],
             )
+            for foot_warmer in bed.foundation.foot_warmers
         )
 
     async_add_entities(entities)

homeassistant/components/sma/sensor.py

@@ -844,9 +844,7 @@ async def async_setup_entry(
     if TYPE_CHECKING:
         assert config_entry.unique_id
 
-    entities = []
+    async_add_entities(
-    for sensor in used_sensors:
-        entities.append(
         SMAsensor(
             coordinator,
             config_entry.unique_id,
@@ -854,10 +852,9 @@ async def async_setup_entry(
             device_info,
             sensor,
         )
+        for sensor in used_sensors
     )
 
-    async_add_entities(entities)
-
 
 class SMAsensor(CoordinatorEntity, SensorEntity):
     """Representation of a SMA sensor."""

homeassistant/components/smappee/switch.py

@@ -36,8 +36,7 @@ async def async_setup_entry(
                     )
                 )
             elif actuator.type == "INFINITY_OUTPUT_MODULE":
-                for option in actuator.state_options:
+                entities.extend(
-                    entities.append(
                     SmappeeActuator(
                         smappee_base,
                         service_location,
@@ -47,6 +46,7 @@ async def async_setup_entry(
                         actuator.serialnumber,
                         actuator_state_option=option,
                     )
+                    for option in actuator.state_options
                 )
 
     async_add_entities(entities, True)

homeassistant/components/smartthings/fan.py

@@ -59,9 +59,9 @@ def get_capabilities(capabilities: Sequence[str]) -> Sequence[str] | None:
 
     supported = [Capability.switch]
 
-    for capability in optional:
+    supported.extend(
-        if capability in capabilities:
+        capability for capability in optional if capability in capabilities
-            supported.append(capability)
+    )
 
     return supported
 

homeassistant/components/sms/sensor.py

@@ -85,14 +85,13 @@ async def async_setup_entry(
     network_coordinator = sms_data[NETWORK_COORDINATOR]
     gateway = sms_data[GATEWAY]
     unique_id = str(await gateway.get_imei_async())
-    entities = []
+    entities = [
-    for description in SIGNAL_SENSORS:
-        entities.append(
         DeviceSensor(signal_coordinator, description, unique_id, gateway)
-        )
+        for description in SIGNAL_SENSORS
-    for description in NETWORK_SENSORS:
+    ]
-        entities.append(
+    entities.extend(
         DeviceSensor(network_coordinator, description, unique_id, gateway)
+        for description in NETWORK_SENSORS
     )
     async_add_entities(entities, True)
 

homeassistant/components/speedtestdotnet/coordinator.py

@@ -38,10 +38,9 @@ class SpeedTestDataCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     def update_servers(self) -> None:
         """Update list of test servers."""
         test_servers = self.api.get_servers()
-        test_servers_list = []
+        test_servers_list = [
-        for servers in test_servers.values():
+            server for servers in test_servers.values() for server in servers
-            for server in servers:
+        ]
-                test_servers_list.append(server)
         for server in sorted(
             test_servers_list,
             key=lambda server: (

homeassistant/components/squeezebox/media_player.py

@@ -395,11 +395,11 @@ class SqueezeBoxEntity(MediaPlayerEntity):
         player_ids = {
             p.unique_id: p.entity_id for p in self.hass.data[DOMAIN][KNOWN_PLAYERS]
         }
-        sync_group = []
+        return [
-        for player in self._player.sync_group:
+            player_ids[player]
-            if player in player_ids:
+            for player in self._player.sync_group
-                sync_group.append(player_ids[player])
+            if player in player_ids
-        return sync_group
+        ]
 
     @property
     def sync_group(self):
@@ -550,8 +550,7 @@ class SqueezeBoxEntity(MediaPlayerEntity):
         """
         all_params = [command]
         if parameters:
-            for parameter in parameters:
+            all_params.extend(parameters)
-                all_params.append(parameter)
         await self._player.async_query(*all_params)
 
     async def async_call_query(self, command, parameters=None):
@@ -562,8 +561,7 @@ class SqueezeBoxEntity(MediaPlayerEntity):
         """
         all_params = [command]
         if parameters:
-            for parameter in parameters:
+            all_params.extend(parameters)
-                all_params.append(parameter)
         self._query_result = await self._player.async_query(*all_params)
         _LOGGER.debug("call_query got result %s", self._query_result)
 

homeassistant/components/starline/button.py

@@ -24,12 +24,12 @@ async def async_setup_entry(
 ) -> None:
     """Set up the StarLine button."""
     account: StarlineAccount = hass.data[DOMAIN][entry.entry_id]
-    entities = []
+    async_add_entities(
-    for device in account.api.devices.values():
+        StarlineButton(account, device, description)
-        if device.support_state:
+        for device in account.api.devices.values()
-            for description in BUTTON_TYPES:
+        if device.support_state
-                entities.append(StarlineButton(account, device, description))
+        for description in BUTTON_TYPES
-    async_add_entities(entities)
+    )
 
 
 class StarlineButton(StarlineEntity, ButtonEntity):

homeassistant/components/starline/device_tracker.py

@@ -16,11 +16,11 @@ async def async_setup_entry(
 ) -> None:
     """Set up StarLine entry."""
     account: StarlineAccount = hass.data[DOMAIN][entry.entry_id]
-    entities = []
+    async_add_entities(
-    for device in account.api.devices.values():
+        StarlineDeviceTracker(account, device)
-        if device.support_position:
+        for device in account.api.devices.values()
-            entities.append(StarlineDeviceTracker(account, device))
+        if device.support_position
-    async_add_entities(entities)
+    )
 
 
 class StarlineDeviceTracker(StarlineEntity, TrackerEntity, RestoreEntity):

homeassistant/components/starlingbank/sensor.py

@@ -54,17 +54,17 @@ def setup_platform(
 ) -> None:
     """Set up the Sterling Bank sensor platform."""
 
-    sensors = []
+    sensors: list[StarlingBalanceSensor] = []
     for account in config[CONF_ACCOUNTS]:
         try:
             starling_account = StarlingAccount(
                 account[CONF_ACCESS_TOKEN], sandbox=account[CONF_SANDBOX]
             )
-            for balance_type in account[CONF_BALANCE_TYPES]:
+            sensors.extend(
-                sensors.append(
                 StarlingBalanceSensor(
                     starling_account, account[CONF_NAME], balance_type
                 )
+                for balance_type in account[CONF_BALANCE_TYPES]
             )
         except requests.exceptions.HTTPError as error:
             _LOGGER.error(

homeassistant/components/subaru/device_tracker.py

@@ -36,11 +36,11 @@ async def async_setup_entry(
     entry: dict = hass.data[DOMAIN][config_entry.entry_id]
     coordinator: DataUpdateCoordinator = entry[ENTRY_COORDINATOR]
     vehicle_info: dict = entry[ENTRY_VEHICLES]
-    entities: list[SubaruDeviceTracker] = []
+    async_add_entities(
-    for vehicle in vehicle_info.values():
+        SubaruDeviceTracker(vehicle, coordinator)
-        if vehicle[VEHICLE_HAS_REMOTE_SERVICE]:
+        for vehicle in vehicle_info.values()
-            entities.append(SubaruDeviceTracker(vehicle, coordinator))
+        if vehicle[VEHICLE_HAS_REMOTE_SERVICE]
-    async_add_entities(entities)
+    )
 
 
 class SubaruDeviceTracker(

homeassistant/components/surepetcare/lock.py

@@ -23,25 +23,18 @@ async def async_setup_entry(
 ) -> None:
     """Set up Sure PetCare locks on a config entry."""
 
-    entities: list[SurePetcareLock] = []
-
     coordinator: SurePetcareDataCoordinator = hass.data[DOMAIN][entry.entry_id]
 
-    for surepy_entity in coordinator.data.values():
+    async_add_entities(
-        if surepy_entity.type not in [
+        SurePetcareLock(surepy_entity.id, coordinator, lock_state)
-            EntityType.CAT_FLAP,
+        for surepy_entity in coordinator.data.values()
-            EntityType.PET_FLAP,
+        if surepy_entity.type in [EntityType.CAT_FLAP, EntityType.PET_FLAP]
-        ]:
-            continue
-
         for lock_state in (
             LockState.LOCKED_IN,
             LockState.LOCKED_OUT,
             LockState.LOCKED_ALL,
-        ):
+        )
-            entities.append(SurePetcareLock(surepy_entity.id, coordinator, lock_state))
+    )
-
-    async_add_entities(entities)
 
 
 class SurePetcareLock(SurePetcareEntity, LockEntity):

homeassistant/components/swiss_hydrological_data/sensor.py

@@ -73,12 +73,13 @@ def setup_platform(
         _LOGGER.error("The station doesn't exists: %s", station)
         return
 
-    entities = []
+    add_entities(
-
+        (
-    for condition in monitored_conditions:
+            SwissHydrologicalDataSensor(hydro_data, station, condition)
-        entities.append(SwissHydrologicalDataSensor(hydro_data, station, condition))
+            for condition in monitored_conditions
-
+        ),
-    add_entities(entities, True)
+        True,
+    )
 
 
 class SwissHydrologicalDataSensor(SensorEntity):

homeassistant/components/syncthru/sensor.py

@@ -62,15 +62,15 @@ async def async_setup_entry(
         SyncThruMainSensor(coordinator, name),
         SyncThruActiveAlertSensor(coordinator, name),
     ]
-
+    entities.extend(SyncThruTonerSensor(coordinator, name, key) for key in supp_toner)
-    for key in supp_toner:
+    entities.extend(SyncThruDrumSensor(coordinator, name, key) for key in supp_drum)
-        entities.append(SyncThruTonerSensor(coordinator, name, key))
+    entities.extend(
-    for key in supp_drum:
+        SyncThruInputTraySensor(coordinator, name, key) for key in supp_tray
-        entities.append(SyncThruDrumSensor(coordinator, name, key))
+    )
-    for key in supp_tray:
+    entities.extend(
-        entities.append(SyncThruInputTraySensor(coordinator, name, key))
+        SyncThruOutputTraySensor(coordinator, name, int_key)
-    for int_key in supp_output_tray:
+        for int_key in supp_output_tray
-        entities.append(SyncThruOutputTraySensor(coordinator, name, int_key))
+    )
 
     async_add_entities(entities)
 

homeassistant/components/synology_dsm/media_source.py

@@ -91,9 +91,7 @@ class SynologyPhotosMediaSource(MediaSource):
     ) -> list[BrowseMediaSource]:
         """Handle browsing different diskstations."""
         if not item.identifier:
-            ret = []
+            return [
-            for entry in self.entries:
-                ret.append(
                 BrowseMediaSource(
                     domain=DOMAIN,
                     identifier=entry.unique_id,
@@ -103,8 +101,8 @@ class SynologyPhotosMediaSource(MediaSource):
                     can_play=False,
                     can_expand=True,
                 )
-                )
+                for entry in self.entries
-            return ret
+            ]
         identifier = SynologyPhotosMediaSourceIdentifier(item.identifier)
         diskstation: SynologyDSMData = self.hass.data[DOMAIN][identifier.unique_id]
 

homeassistant/components/system_bridge/binary_sensor.py

@@ -50,22 +50,19 @@ async def async_setup_entry(
     """Set up System Bridge binary sensor based on a config entry."""
     coordinator: SystemBridgeDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
 
-    entities = []
+    entities = [
-    for description in BASE_BINARY_SENSOR_TYPES:
-        entities.append(
         SystemBridgeBinarySensor(coordinator, description, entry.data[CONF_PORT])
-        )
+        for description in BASE_BINARY_SENSOR_TYPES
+    ]
 
     if (
         coordinator.data.battery
         and coordinator.data.battery.percentage
         and coordinator.data.battery.percentage > -1
     ):
-        for description in BATTERY_BINARY_SENSOR_TYPES:
+        entities.extend(
-            entities.append(
+            SystemBridgeBinarySensor(coordinator, description, entry.data[CONF_PORT])
-                SystemBridgeBinarySensor(
+            for description in BATTERY_BINARY_SENSOR_TYPES
-                    coordinator, description, entry.data[CONF_PORT]
-                )
         )
 
     async_add_entities(entities)

homeassistant/components/system_bridge/media_source.py

@@ -88,10 +88,7 @@ class SystemBridgeSource(MediaSource):
 
     def _build_bridges(self) -> BrowseMediaSource:
         """Build bridges for System Bridge media."""
-        children = []
+        children = [
-        for entry in self.hass.config_entries.async_entries(DOMAIN):
-            if entry.entry_id is not None:
-                children.append(
             BrowseMediaSource(
                 domain=DOMAIN,
                 identifier=entry.entry_id,
@@ -103,7 +100,9 @@ class SystemBridgeSource(MediaSource):
                 children=[],
                 children_media_class=MediaClass.DIRECTORY,
             )
-                )
+            for entry in self.hass.config_entries.async_entries(DOMAIN)
+            if entry.entry_id is not None
+        ]
 
         return BrowseMediaSource(
             domain=DOMAIN,

homeassistant/components/system_bridge/sensor.py

@@ -364,18 +364,16 @@ async def async_setup_entry(
     """Set up System Bridge sensor based on a config entry."""
     coordinator: SystemBridgeDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
 
-    entities = []
+    entities = [
-    for description in BASE_SENSOR_TYPES:
-        entities.append(
         SystemBridgeSensor(coordinator, description, entry.data[CONF_PORT])
-        )
+        for description in BASE_SENSOR_TYPES
+    ]
 
     for index_device, device in enumerate(coordinator.data.disks.devices):
         if device.partitions is None:
             continue
 
-        for index_partition, partition in enumerate(device.partitions):
+        entities.extend(
-            entities.append(
             SystemBridgeSensor(
                 coordinator,
                 SystemBridgeSensorEntityDescription(
@@ -392,6 +390,7 @@ async def async_setup_entry(
                 ),
                 entry.data[CONF_PORT],
             )
+            for index_partition, partition in enumerate(device.partitions)
         )
 
     if (
@@ -399,9 +398,9 @@ async def async_setup_entry(
         and coordinator.data.battery.percentage
         and coordinator.data.battery.percentage > -1
     ):
-        for description in BATTERY_SENSOR_TYPES:
+        entities.extend(
-            entities.append(
             SystemBridgeSensor(coordinator, description, entry.data[CONF_PORT])
+            for description in BATTERY_SENSOR_TYPES
         )
 
     entities.append(
@@ -466,8 +465,8 @@ async def async_setup_entry(
             ]
 
     for index, gpu in enumerate(coordinator.data.gpus):
-        entities = [
+        entities.extend(
-            *entities,
+            [
                 SystemBridgeSensor(
                     coordinator,
                     SystemBridgeSensorEntityDescription(
@@ -587,6 +586,7 @@ async def async_setup_entry(
                     entry.data[CONF_PORT],
                 ),
             ]
+        )
 
     if coordinator.data.cpu.per_cpu is not None:
         for cpu in coordinator.data.cpu.per_cpu:

homeassistant/components/systemmonitor/binary_sensor.py

@@ -92,21 +92,20 @@ async def async_setup_entry(
     hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up System Montor binary sensors based on a config entry."""
-    entities: list[SystemMonitorSensor] = []
     coordinator: SystemMonitorCoordinator = hass.data[DOMAIN_COORDINATOR]
 
-    for sensor_description in SENSOR_TYPES:
+    async_add_entities(
-        _entry = entry.options.get(BINARY_SENSOR_DOMAIN, {})
-        for argument in _entry.get(CONF_PROCESS, []):
-            entities.append(
         SystemMonitorSensor(
             coordinator,
             sensor_description,
             entry.entry_id,
             argument,
         )
+        for sensor_description in SENSOR_TYPES
+        for argument in entry.options.get(BINARY_SENSOR_DOMAIN, {}).get(
+            CONF_PROCESS, []
+        )
     )
-    async_add_entities(entities)
 
 
 class SystemMonitorSensor(

tests/components/recorder/test_history.py

@@ -658,9 +658,7 @@ def test_get_significant_states_only(
         return hass.states.get(entity_id)
 
     start = dt_util.utcnow() - timedelta(minutes=4)
-    points = []
+    points = [start + timedelta(minutes=i) for i in range(1, 4)]
-    for i in range(1, 4):
-        points.append(start + timedelta(minutes=i))
 
     states = []
     with freeze_time(start) as freezer:

tests/components/recorder/test_history_db_schema_30.py

@@ -517,9 +517,7 @@ def test_get_significant_states_only(
             return hass.states.get(entity_id)
 
         start = dt_util.utcnow() - timedelta(minutes=4)
-        points = []
+        points = [start + timedelta(minutes=i) for i in range(1, 4)]
-        for i in range(1, 4):
-            points.append(start + timedelta(minutes=i))
 
         states = []
         with freeze_time(start) as freezer:

tests/components/recorder/test_history_db_schema_32.py

@@ -507,9 +507,7 @@ def test_get_significant_states_only(
             return hass.states.get(entity_id)
 
         start = dt_util.utcnow() - timedelta(minutes=4)
-        points = []
+        points = [start + timedelta(minutes=i) for i in range(1, 4)]
-        for i in range(1, 4):
-            points.append(start + timedelta(minutes=i))
 
         states = []
         with freeze_time(start) as freezer:

tests/components/recorder/test_migration_from_schema_32.py

@@ -914,18 +914,17 @@ async def test_stats_timestamp_conversion_is_reentrant(
 
     def _get_all_short_term_stats() -> list[dict[str, Any]]:
         with session_scope(hass=hass) as session:
-            results = []
+            results = [
-            for result in (
-                session.query(old_db_schema.StatisticsShortTerm)
-                .where(old_db_schema.StatisticsShortTerm.metadata_id == 1000)
-                .all()
-            ):
-                results.append(
                 {
                     field.name: getattr(result, field.name)
                     for field in old_db_schema.StatisticsShortTerm.__table__.c
                 }
+                for result in (
+                    session.query(old_db_schema.StatisticsShortTerm)
+                    .where(old_db_schema.StatisticsShortTerm.metadata_id == 1000)
+                    .all()
                 )
+            ]
             return sorted(results, key=lambda row: row["start_ts"])
 
     # Do not optimize this block, its intentionally written to interleave
@@ -1099,14 +1098,12 @@ async def test_stats_timestamp_with_one_by_one(
     def _get_all_stats(table: old_db_schema.StatisticsBase) -> list[dict[str, Any]]:
         """Get all stats from a table."""
         with session_scope(hass=hass) as session:
-            results = []
+            results = [
-            for result in session.query(table).where(table.metadata_id == 1000).all():
+                {field.name: getattr(result, field.name) for field in table.__table__.c}
-                results.append(
+                for result in session.query(table)
-                    {
+                .where(table.metadata_id == 1000)
-                        field.name: getattr(result, field.name)
+                .all()
-                        for field in table.__table__.c
+            ]
-                    }
-                )
             return sorted(results, key=lambda row: row["start_ts"])
 
     def _insert_and_do_migration():
@@ -1326,14 +1323,12 @@ async def test_stats_timestamp_with_one_by_one_removes_duplicates(
     def _get_all_stats(table: old_db_schema.StatisticsBase) -> list[dict[str, Any]]:
         """Get all stats from a table."""
         with session_scope(hass=hass) as session:
-            results = []
+            results = [
-            for result in session.query(table).where(table.metadata_id == 1000).all():
+                {field.name: getattr(result, field.name) for field in table.__table__.c}
-                results.append(
+                for result in session.query(table)
-                    {
+                .where(table.metadata_id == 1000)
-                        field.name: getattr(result, field.name)
+                .all()
-                        for field in table.__table__.c
+            ]
-                    }
-                )
             return sorted(results, key=lambda row: row["start_ts"])
 
     def _insert_and_do_migration():

tests/components/reolink/test_config_flow.py

@@ -474,9 +474,7 @@ async def test_dhcp_ip_update(
         const.DOMAIN, context={"source": config_entries.SOURCE_DHCP}, data=dhcp_data
     )
 
-    expected_calls = []
+    expected_calls = [
-    for host in host_call_list:
-        expected_calls.append(
         call(
             host,
             TEST_USERNAME,
@@ -486,7 +484,8 @@ async def test_dhcp_ip_update(
             protocol=DEFAULT_PROTOCOL,
             timeout=DEFAULT_TIMEOUT,
         )
-        )
+        for host in host_call_list
+    ]
 
     assert reolink_connect_class.call_args_list == expected_calls
 

tests/components/statistics/test_sensor.py

@@ -1292,9 +1292,7 @@ async def test_state_characteristics(hass: HomeAssistant) -> None:
             "unit": "%",
         },
     )
-    sensors_config = []
+    sensors_config = [
-    for characteristic in characteristics:
-        sensors_config.append(
         {
             "platform": "statistics",
             "name": f"test_{characteristic['source_sensor_domain']}_{characteristic['name']}",
@@ -1302,7 +1300,8 @@ async def test_state_characteristics(hass: HomeAssistant) -> None:
             "state_characteristic": characteristic["name"],
             "max_age": {"minutes": 8},  # 9 values spaces by one minute
         }
-        )
+        for characteristic in characteristics
+    ]
 
     with freeze_time(current_time) as freezer:
         assert await async_setup_component(

tests/components/steam_online/__init__.py

@@ -69,9 +69,9 @@ class MockedInterface(dict):
     def GetFriendList(self, steamid: str) -> dict:
         """Get friend list."""
         fake_friends = [{"steamid": ACCOUNT_2}]
-        for _i in range(0, 4):
+        fake_friends.extend(
-            fake_friends.append(
             {"steamid": "".join(random.choices(string.digits, k=len(ACCOUNT_1)))}
+            for _ in range(0, 4)
         )
         return {"friendslist": {"friends": fake_friends}}
 

tests/components/stream/test_hls.py

@@ -399,9 +399,7 @@ async def test_hls_max_segments(
 
     # Only NUM_PLAYLIST_SEGMENTS are returned in the playlist.
     start = MAX_SEGMENTS + 1 - NUM_PLAYLIST_SEGMENTS
-    segments = []
+    segments = [make_segment(sequence) for sequence in range(start, MAX_SEGMENTS + 1)]
-    for sequence in range(start, MAX_SEGMENTS + 1):
-        segments.append(make_segment(sequence))
     assert await resp.text() == make_playlist(sequence=start, segments=segments)
 
     # Fetch the actual segments with a fake byte payload
@@ -497,9 +495,7 @@ async def test_hls_max_segments_discontinuity(
     # EXT-X-DISCONTINUITY tag to be omitted and EXT-X-DISCONTINUITY-SEQUENCE
     # returned instead.
     start = MAX_SEGMENTS + 1 - NUM_PLAYLIST_SEGMENTS
-    segments = []
+    segments = [make_segment(sequence) for sequence in range(start, MAX_SEGMENTS + 1)]
-    for sequence in range(start, MAX_SEGMENTS + 1):
-        segments.append(make_segment(sequence))
     assert await resp.text() == make_playlist(
         sequence=start,
         discontinuity_sequence=1,

tests/components/stream/test_ll_hls.py

@@ -96,9 +96,9 @@ def make_segment_with_parts(
     response = []
     if discontinuity:
         response.append("#EXT-X-DISCONTINUITY")
-    for i in range(num_parts):
+    response.extend(
-        response.append(
         f'#EXT-X-PART:DURATION={TEST_PART_DURATION:.3f},URI="./segment/{segment}.{i}.m4s"{",INDEPENDENT=YES" if i%independent_period==0 else ""}'
+        for i in range(num_parts)
     )
     response.extend(
         [