async_create_task (#17059)

* async_create_task

* Update google.py

homeassistant/components/apple_tv.py

@@ -252,4 +252,4 @@ def set_power_on(self, value):
                 self.atv.push_updater.start()
 
             for listener in self.listeners:
-                self.hass.async_add_job(listener.async_update_ha_state())
+                self.hass.async_create_task(listener.async_update_ha_state())

homeassistant/components/camera/__init__.py

@@ -183,7 +183,7 @@ def update_tokens(time):
         """Update tokens of the entities."""
         for entity in component.entities:
             entity.async_update_token()
-            hass.async_add_job(entity.async_update_ha_state())
+            hass.async_create_task(entity.async_update_ha_state())
 
     hass.helpers.event.async_track_time_interval(
         update_tokens, TOKEN_CHANGE_INTERVAL)

homeassistant/components/cloud/iot.py

@@ -79,7 +79,7 @@ def _handle_hass_stop(event):
 
             try:
                 # Sleep 2^tries seconds between retries
-                self.retry_task = hass.async_add_job(asyncio.sleep(
+                self.retry_task = hass.async_create_task(asyncio.sleep(
                     2**min(9, self.tries), loop=hass.loop))
                 yield from self.retry_task
                 self.retry_task = None
@@ -106,7 +106,7 @@ def _handle_connection(self):
                 'cloud_subscription_expired')
 
             # Don't await it because it will cancel this task
-            hass.async_add_job(self.cloud.logout())
+            hass.async_create_task(self.cloud.logout())
             return
         except auth_api.CloudError as err:
             _LOGGER.warning("Unable to refresh token: %s", err)

homeassistant/components/config/__init__.py

@@ -52,7 +52,7 @@ def component_loaded(event):
         """Respond to components being loaded."""
         panel_name = event.data.get(ATTR_COMPONENT)
         if panel_name in ON_DEMAND:
-            hass.async_add_job(setup_panel(panel_name))
+            hass.async_create_task(setup_panel(panel_name))
 
     hass.bus.async_listen(EVENT_COMPONENT_LOADED, component_loaded)
 
@@ -136,7 +136,7 @@ async def post(self, request, config_key):
         await hass.async_add_job(_write, path, current)
 
         if self.post_write_hook is not None:
-            hass.async_add_job(self.post_write_hook(hass))
+            hass.async_create_task(self.post_write_hook(hass))
 
         return self.json({
             'result': 'ok',

homeassistant/components/config/auth.py

@@ -52,7 +52,7 @@ async def send_users():
         connection.send_message(
             websocket_api.result_message(msg['id'], result))
 
-    hass.async_add_job(send_users())
+    hass.async_create_task(send_users())
 
 
 @callback
@@ -79,7 +79,7 @@ async def delete_user():
         connection.send_message(
             websocket_api.result_message(msg['id']))
 
-    hass.async_add_job(delete_user())
+    hass.async_create_task(delete_user())
 
 
 @callback
@@ -95,7 +95,7 @@ async def create_user():
                 'user': _user_info(user)
             }))
 
-    hass.async_add_job(create_user())
+    hass.async_create_task(create_user())
 
 
 def _user_info(user):

homeassistant/components/config/device_registry.py

@@ -44,4 +44,4 @@ async def retrieve_entities():
             } for entry in registry.devices.values()]
         ))
 
-    hass.async_add_job(retrieve_entities())
+    hass.async_create_task(retrieve_entities())

homeassistant/components/device_tracker/__init__.py

@@ -371,7 +371,7 @@ def async_update_stale(self, now: dt_util.dt.datetime):
         for device in self.devices.values():
             if (device.track and device.last_update_home) and \
                device.stale(now):
-                self.hass.async_add_job(device.async_update_ha_state(True))
+                self.hass.async_create_task(device.async_update_ha_state(True))
 
     async def async_setup_tracked_device(self):
         """Set up all not exists tracked devices.
@@ -386,7 +386,7 @@ async def async_init_single_device(dev):
         tasks = []
         for device in self.devices.values():
             if device.track and not device.last_seen:
-                tasks.append(self.hass.async_add_job(
+                tasks.append(self.hass.async_create_task(
                     async_init_single_device(device)))
 
         if tasks:
@@ -718,10 +718,10 @@ async def async_device_tracker_scan(now: dt_util.dt.datetime):
                                  zone_home.attributes[ATTR_LONGITUDE]]
                 kwargs['gps_accuracy'] = 0
 
-            hass.async_add_job(async_see_device(**kwargs))
+            hass.async_create_task(async_see_device(**kwargs))
 
     async_track_time_interval(hass, async_device_tracker_scan, interval)
-    hass.async_add_job(async_device_tracker_scan(None))
+    hass.async_create_task(async_device_tracker_scan(None))
 
 
 def update_config(path: str, dev_id: str, device: Device):

homeassistant/components/device_tracker/automatic.py

@@ -113,7 +113,7 @@ def initialize_data(session):
         # Load the initial vehicle data
         vehicles = yield from session.get_vehicles()
         for vehicle in vehicles:
-            hass.async_add_job(data.load_vehicle(vehicle))
+            hass.async_create_task(data.load_vehicle(vehicle))
 
         # Create a task instead of adding a tracking job, since this task will
         # run until the websocket connection is closed.
@@ -188,7 +188,7 @@ def get(self, request):  # pylint: disable=no-self-use
         code = params['code']
         state = params['state']
         initialize_callback = hass.data[DATA_CONFIGURING][state]
-        hass.async_add_job(initialize_callback(code, state))
+        hass.async_create_task(initialize_callback(code, state))
 
         return response
 
@@ -209,7 +209,7 @@ def __init__(self, hass, client, session, devices, async_see):
         self.ws_close_requested = False
 
         self.client.on_app_event(
-            lambda name, event: self.hass.async_add_job(
+            lambda name, event: self.hass.async_create_task(
                 self.handle_event(name, event)))
 
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.ws_close())

homeassistant/components/device_tracker/gpslogger.py

@@ -98,7 +98,7 @@ async def get(self, request: Request):
         if 'activity' in data:
             attrs['activity'] = data['activity']
 
-        hass.async_add_job(self.async_see(
+        hass.async_create_task(self.async_see(
             dev_id=device,
             gps=gps_location, battery=battery,
             gps_accuracy=accuracy,

homeassistant/components/device_tracker/meraki.py

@@ -121,7 +121,7 @@ def _handle(self, hass, data):
                 attrs['seenTime'] = i['seenTime']
             if i.get('ssid', False):
                 attrs['ssid'] = i['ssid']
-            hass.async_add_job(self.async_see(
+            hass.async_create_task(self.async_see(
                 gps=gps_location,
                 mac=mac,
                 source_type=SOURCE_TYPE_ROUTER,

homeassistant/components/device_tracker/mqtt.py

@@ -33,7 +33,7 @@ async def async_setup_scanner(hass, config, async_see, discovery_info=None):
         @callback
         def async_message_received(topic, payload, qos, dev_id=dev_id):
             """Handle received MQTT message."""
-            hass.async_add_job(
+            hass.async_create_task(
                 async_see(dev_id=dev_id, location_name=payload))
 
         await mqtt.async_subscribe(

homeassistant/components/device_tracker/mqtt_json.py

@@ -55,7 +55,7 @@ def async_message_received(topic, payload, qos, dev_id=dev_id):
                 return
 
             kwargs = _parse_see_args(dev_id, data)
-            hass.async_add_job(async_see(**kwargs))
+            hass.async_create_task(async_see(**kwargs))
 
         await mqtt.async_subscribe(
             hass, topic, async_message_received, qos)

homeassistant/components/discovery.py

@@ -168,7 +168,7 @@ async def scan_devices(now):
         results = await hass.async_add_job(_discover, netdisco)
 
         for result in results:
-            hass.async_add_job(new_service_found(*result))
+            hass.async_create_task(new_service_found(*result))
 
         async_track_point_in_utc_time(hass, scan_devices,
                                       dt_util.utcnow() + SCAN_INTERVAL)
@@ -180,7 +180,7 @@ def schedule_first(event):
 
         # discovery local services
         if 'HASSIO' in os.environ:
-            hass.async_add_job(new_service_found(SERVICE_HASSIO, {}))
+            hass.async_create_task(new_service_found(SERVICE_HASSIO, {}))
 
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, schedule_first)
 

homeassistant/components/emulated_hue/hue_api.py

@@ -254,11 +254,11 @@ async def put(self, request, username, entity_number):
 
         # Separate call to turn on needed
         if turn_on_needed:
-            hass.async_add_job(hass.services.async_call(
+            hass.async_create_task(hass.services.async_call(
                 core.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: entity_id},
                 blocking=True))
 
-        hass.async_add_job(hass.services.async_call(
+        hass.async_create_task(hass.services.async_call(
             domain, service, data, blocking=True))
 
         json_response = \

homeassistant/components/homematicip_cloud/hap.py

@@ -142,7 +142,7 @@ def async_update(self, *args, **kwargs):
             # Explicitly getting an update as device states might have
             # changed during access point disconnect."""
 
-            job = self.hass.async_add_job(self.get_state())
+            job = self.hass.async_create_task(self.get_state())
             job.add_done_callback(self.get_state_finished)
 
     async def get_state(self):
@@ -161,7 +161,7 @@ def get_state_finished(self, future):
             # so reconnect loop is taking over.
             _LOGGER.error(
                 "Updating state after HMIP access point reconnect failed")
-            self.hass.async_add_job(self.home.disable_events())
+            self.hass.async_create_task(self.home.disable_events())
 
     def set_all_to_unavailable(self):
         """Set all devices to unavailable and tell Home Assistant."""
@@ -212,7 +212,7 @@ async def async_connect(self):
                           "Retrying in %d seconds",
                           self.config_entry.data.get(HMIPC_HAPID), retry_delay)
             try:
-                self._retry_task = self.hass.async_add_job(asyncio.sleep(
+                self._retry_task = self.hass.async_create_task(asyncio.sleep(
                     retry_delay, loop=self.hass.loop))
                 await self._retry_task
             except asyncio.CancelledError:

homeassistant/components/hue/__init__.py

@@ -108,7 +108,7 @@ async def async_setup(hass, config):
         # this component we'll have to use hass.async_add_job to avoid a
         # deadlock: creating a config entry will set up the component but the
         # setup would block till the entry is created!
-        hass.async_add_job(hass.config_entries.flow.async_init(
+        hass.async_create_task(hass.config_entries.flow.async_init(
             DOMAIN, context={'source': config_entries.SOURCE_IMPORT},
             data={
                 'host': bridge_conf[CONF_HOST],

homeassistant/components/hue/bridge.py

@@ -50,7 +50,7 @@ async def async_setup(self, tries=0):
             # We are going to fail the config entry setup and initiate a new
             # linking procedure. When linking succeeds, it will remove the
             # old config entry.
-            hass.async_add_job(hass.config_entries.flow.async_init(
+            hass.async_create_task(hass.config_entries.flow.async_init(
                 DOMAIN, context={'source': config_entries.SOURCE_IMPORT},
                 data={
                     'host': host,

homeassistant/components/intent_script.py

@@ -78,7 +78,7 @@ async def async_handle(self, intent_obj):
 
         if action is not None:
             if is_async_action:
-                intent_obj.hass.async_add_job(action.async_run(slots))
+                intent_obj.hass.async_create_task(action.async_run(slots))
             else:
                 await action.async_run(slots)
 

homeassistant/components/light/lifx.py

@@ -300,7 +300,7 @@ def service_to_entities(self, service):
     @callback
     def register(self, bulb):
         """Handle aiolifx detected bulb."""
-        self.hass.async_add_job(self.register_new_bulb(bulb))
+        self.hass.async_create_task(self.register_new_bulb(bulb))
 
     async def register_new_bulb(self, bulb):
         """Handle newly detected bulb."""
@@ -344,7 +344,7 @@ def unregister(self, bulb):
             entity = self.entities[bulb.mac_addr]
             _LOGGER.debug("%s unregister", entity.who)
             entity.registered = False
-            self.hass.async_add_job(entity.async_update_ha_state())
+            self.hass.async_create_task(entity.async_update_ha_state())
 
 
 class AwaitAioLIFX:
@@ -484,12 +484,12 @@ async def update_during_transition(self, when):
     async def async_turn_on(self, **kwargs):
         """Turn the light on."""
         kwargs[ATTR_POWER] = True
-        self.hass.async_add_job(self.set_state(**kwargs))
+        self.hass.async_create_task(self.set_state(**kwargs))
 
     async def async_turn_off(self, **kwargs):
         """Turn the light off."""
         kwargs[ATTR_POWER] = False
-        self.hass.async_add_job(self.set_state(**kwargs))
+        self.hass.async_create_task(self.set_state(**kwargs))
 
     async def set_state(self, **kwargs):
         """Set a color on the light and turn it on/off."""

homeassistant/components/light/template.py

@@ -215,7 +215,7 @@ async def async_turn_on(self, **kwargs):
             optimistic_set = True
 
         if ATTR_BRIGHTNESS in kwargs and self._level_script:
-            self.hass.async_add_job(self._level_script.async_run(
+            self.hass.async_create_task(self._level_script.async_run(
                 {"brightness": kwargs[ATTR_BRIGHTNESS]}))
         else:
             await self._on_script.async_run()

homeassistant/components/light/tradfri.py

@@ -127,7 +127,7 @@ def _async_start_observe(self, exc=None):
             cmd = self._group.observe(callback=self._observe_update,
                                       err_callback=self._async_start_observe,
                                       duration=0)
-            self.hass.async_add_job(self._api(cmd))
+            self.hass.async_create_task(self._api(cmd))
         except PytradfriError as err:
             _LOGGER.warning("Observation failed, trying again", exc_info=err)
             self._async_start_observe()
@@ -346,7 +346,7 @@ def _async_start_observe(self, exc=None):
             cmd = self._light.observe(callback=self._observe_update,
                                       err_callback=self._async_start_observe,
                                       duration=0)
-            self.hass.async_add_job(self._api(cmd))
+            self.hass.async_create_task(self._api(cmd))
         except PytradfriError as err:
             _LOGGER.warning("Observation failed, trying again", exc_info=err)
             self._async_start_observe()

homeassistant/components/media_extractor.py

@@ -148,7 +148,7 @@ def call_media_player_service(self, stream_selector, entity_id):
             if entity_id:
                 data[ATTR_ENTITY_ID] = entity_id
 
-            self.hass.async_add_job(
+            self.hass.async_create_task(
                 self.hass.services.async_call(
                     MEDIA_PLAYER_DOMAIN, SERVICE_PLAY_MEDIA, data)
             )

homeassistant/components/media_player/anthemav.py

@@ -49,7 +49,7 @@ async def async_setup_platform(hass, config, async_add_entities,
     def async_anthemav_update_callback(message):
         """Receive notification from transport that new data exists."""
         _LOGGER.info("Received update callback from AVR: %s", message)
-        hass.async_add_job(device.async_update_ha_state())
+        hass.async_create_task(device.async_update_ha_state())
 
     avr = await anthemav.Connection.create(
         host=host, port=port, loop=hass.loop,

homeassistant/components/media_player/bluesound.py

@@ -96,7 +96,7 @@ def _add_player(hass, async_add_entities, host, port=None, name=None):
     @callback
     def _init_player(event=None):
         """Start polling."""
-        hass.async_add_job(player.async_init())
+        hass.async_create_task(player.async_init())
 
     @callback
     def _start_polling(event=None):
@@ -272,7 +272,7 @@ async def _start_poll_command(self):
 
     def start_polling(self):
         """Start the polling task."""
-        self._polling_task = self._hass.async_add_job(
+        self._polling_task = self._hass.async_create_task(
             self._start_poll_command())
 
     def stop_polling(self):

homeassistant/components/media_player/cast.py

@@ -343,7 +343,7 @@ def async_cast_discovered(discover: ChromecastInfo):
                 # Discovered is not our device.
                 return
             _LOGGER.debug("Discovered chromecast with same UUID: %s", discover)
-            self.hass.async_add_job(self.async_set_cast_info(discover))
+            self.hass.async_create_task(self.async_set_cast_info(discover))
 
         async def async_stop(event):
             """Disconnect socket on Home Assistant stop."""
@@ -352,7 +352,7 @@ async def async_stop(event):
         async_dispatcher_connect(self.hass, SIGNAL_CAST_DISCOVERED,
                                  async_cast_discovered)
         self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop)
-        self.hass.async_add_job(self.async_set_cast_info(self._cast_info))
+        self.hass.async_create_task(self.async_set_cast_info(self._cast_info))
 
     async def async_will_remove_from_hass(self) -> None:
         """Disconnect Chromecast object when removed."""