async def on_provider_unload(self, provider: MusicProvider) -> None:
"""Handle logic when a provider is (about to get) unloaded."""
# make sure to stop any running sync tasks first
- for sync_task in self.in_progress_syncs:
+ for sync_task in list(self.in_progress_syncs):
if sync_task.provider_instance == provider.instance_id:
if sync_task.task:
sync_task.task.cancel()
key = f"sync_{provider_instance_id}_{media_type.value}"
self.mass.cancel_timer(key)
# cancel any running sync tasks
- for sync_task in self.in_progress_syncs:
+ for sync_task in list(self.in_progress_syncs):
if sync_task.provider_instance == provider_instance_id:
sync_task.task.cancel()
def _start_provider_sync(self, provider: MusicProvider, media_type: MediaType) -> None:
"""Start sync task on provider and track progress."""
# check if we're not already running a sync task for this provider/mediatype
- for sync_task in self.in_progress_syncs:
+ for sync_task in list(self.in_progress_syncs):
if sync_task.provider_instance != provider.instance_id:
continue
if sync_task.task.done():
current_sendspin_player = get_sendspin_player_id()
return [
player
- for player in self._players.values()
+ for player in list(self._players.values())
if (player.state.available or return_unavailable)
and (player.state.enabled or return_disabled)
and (provider_filter is None or player.provider.instance_id == provider_filter)
name_normalized = name.strip().lower()
matches: list[Player] = []
- for player in self._players.values():
+ for player in list(self._players.values()):
if player.state.name.strip().lower() == name_normalized:
matches.append(player)
if self.mass.closing:
return
# update all players that are using this control
- for player in self._players.values():
+ for player in list(self._players.values()):
if control_id in (
player.state.power_control,
player.state.volume_control,
return await handler(request)
# Try prefix match (for routes registered with /*)
if self._dynamic_routes is not None:
- for route_key, handler in self._dynamic_routes.items():
+ for route_key, handler in list(self._dynamic_routes.items()):
method, path = route_key.split(".", 1)
if method in (request.method, "*") and path.endswith("/*"):
prefix = path[:-2]
self.signal_event(EventType.SHUTDOWN)
self.closing = True
# cancel all running tasks
- for task in self._tracked_tasks.values():
+ for task in list(self._tracked_tasks.values()):
task.cancel()
# cleanup all providers
await asyncio.gather(
)
return [
x
- for x in self._providers.values()
+ for x in list(self._providers.values())
if (provider_type is None or provider_type == x.type)
# apply user provider filter
and (
return None
provider_instance_or_domain = prov.domain
# fallback to match on domain
- for prov in self._providers.values():
+ for prov in list(self._providers.values()):
if prov.domain != provider_instance_or_domain:
continue
if return_unavailable or prov.available:
"""
return [
prov
- for prov in self._providers.values()
+ for prov in list(self._providers.values())
if (provider_type is None or provider_type == prov.type)
and prov.domain == domain
and (return_unavailable or prov.available)
LOGGER.getChild("event").log(VERBOSE_LOG_LEVEL, "%s %s", event.value, object_id or "")
event_obj = MassEvent(event=event, object_id=object_id, data=data)
- for cb_func, event_filter, id_filter in self._subscribers:
+ for cb_func, event_filter, id_filter in list(self._subscribers):
if not (event_filter is None or event in event_filter):
continue
if not (id_filter is None or object_id in id_filter):
service_type,
state_change,
)
- for prov in self._providers.values():
+ for prov in list(self._providers.values()):
if not prov.manifest.mdns_discovery:
continue
if not prov.available: