fix potential naming collision

homeassistant/components/bluesound/media_player.py

@@ -33,7 +33,12 @@
     EVENT_HOMEASSISTANT_START,
     EVENT_HOMEASSISTANT_STOP,
 )
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
+from homeassistant.core import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
+    Event,
+    HomeAssistant,
+    callback,
+)
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
@@ -88,30 +93,30 @@
     """Add Bluesound players."""
 
     @callback
-    def _init_player(event=None):
+    def _init_bluesound_player(event: Event | None = None):
         """Start polling."""
-        hass.async_create_task(player.async_init())
+        hass.async_create_task(bluesound_player.async_init())
 
     @callback
-    def _start_polling(event=None):
+    def _start_polling(event: Event):
         """Start polling."""
-        player.start_polling()
+        bluesound_player.start_polling()
 
     @callback
-    def _stop_polling(event=None):
+    def _stop_polling(event: Event):
         """Stop polling."""
-        player.stop_polling()
+        bluesound_player.stop_polling()
 
     @callback
-    def _add_player_cb():
+    def _add_bluesound_player_cb():
         """Add player after first sync fetch."""
-        if player.id in [x.id for x in hass.data[DATA_BLUESOUND]]:
-            _LOGGER.warning("Player already added %s", player.id)
+        if bluesound_player.id in [x.id for x in hass.data[DATA_BLUESOUND]]:
+            _LOGGER.warning("Player already added %s", bluesound_player.id)
             return
 
-        hass.data[DATA_BLUESOUND].append(player)
-        async_add_entities([player])
-        _LOGGER.info("Added device with name: %s", player.name)
+        hass.data[DATA_BLUESOUND].append(bluesound_player)
+        async_add_entities([bluesound_player])
+        _LOGGER.info("Added device with name: %s", bluesound_player.name)
 
         if hass.is_running:
             _start_polling()
@@ -120,23 +125,25 @@
 
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _stop_polling)
 
-    player = BluesoundPlayer(hass, host, port, player, sync_status, _add_player_cb)
+    bluesound_player = BluesoundPlayer(
+        hass, host, port, player, sync_status, _add_bluesound_player_cb
+    )
 
     if hass.is_running:
-        _init_player()
+        _init_bluesound_player()
     else:
-        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, _init_player)
+        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, _init_bluesound_player)
 
 
 async def _async_import(hass: HomeAssistant, config: ConfigType) -> None:
     """Import config entry from configuration.yaml."""
     if not hass.config_entries.async_entries(DOMAIN):
         # Start import flow
         result = await hass.config_entries.flow.async_init(
             DOMAIN, context={"source": SOURCE_IMPORT}, data=config
         )
         if result["type"] == FlowResultType.ABORT:
             ir.async_create_issue(
                 hass,
                 DOMAIN,
                 f"deprecated_yaml_import_issue_{result['reason']}",
@@ -150,9 +157,9 @@
                     "integration_title": INTEGRATION_TITLE,
                 },
             )
             return
 
     ir.async_create_issue(
         hass,
         HOMEASSISTANT_DOMAIN,
         f"deprecated_yaml_{DOMAIN}",
@@ -177,12 +184,12 @@
     if DATA_BLUESOUND not in hass.data:
         hass.data[DATA_BLUESOUND] = []
 
     host = config_entry.data.get(CONF_HOST)
     port = config_entry.data.get(CONF_PORT)
     assert isinstance(host, str)
     assert isinstance(port, int)
 
     _add_player(
         hass,
         async_add_entities,
         host,
@@ -199,13 +206,13 @@
     discovery_info: DiscoveryInfoType | None,
 ) -> None:
     """Trigger import flows."""
     hosts = config.get(CONF_HOSTS, [])
     for host in hosts:
         import_data = {
             CONF_HOST: host[CONF_HOST],
             CONF_PORT: host.get(CONF_PORT, 11000),
         }
         hass.async_create_task(_async_import(hass, import_data))
 
 
 class BluesoundPlayer(MediaPlayerEntity):
@@ -227,7 +234,7 @@
         self._hass = hass
         self.port = port
         self._polling_task = None  # The actual polling task.
         self._name = sync_status.name
         self._id = None
         self._last_status_update = None
         self._sync_status: SyncStatus | None = None
@@ -242,7 +249,7 @@
         self._group_name = None
         self._group_list: list[str] = []
         self._bluesound_device_name = None
         self._player = player
 
         self._init_callback = init_callback
 
@@ -394,7 +401,7 @@
     def unique_id(self) -> str:
         """Return an unique ID."""
         assert self._sync_status is not None
         return format_unique_id(self._sync_status.mac, self.port)
 
     async def async_trigger_sync_on_all(self):
         """Trigger sync status update on all devices."""