text: """Platform for the Daikin AC."""
  import asyncio
  from datetime import timedelta
  import logging
  from socket import timeout
  
  import async_timeout
  import voluptuous as vol
  
  from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
  from homeassistant.const import CONF_HOSTS
  import homeassistant.helpers.config_validation as cv
  from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
  from homeassistant.helpers.typing import HomeAssistantType
  from homeassistant.util import Throttle
  
  from . import config_flow  # noqa  pylint_disable=unused-import
  from .const import KEY_HOST
  
  REQUIREMENTS = ['pydaikin==0.9']
  
  _LOGGER = logging.getLogger(__name__)
  
  DOMAIN = 'daikin'
  
  
  MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
  
  COMPONENT_TYPES = ['climate', 'sensor']
  
  CONFIG_SCHEMA = vol.Schema({
      DOMAIN: vol.Schema({
          vol.Optional(
              CONF_HOSTS, default=[]
          ): vol.All(cv.ensure_list, [cv.string]),
      })
  }, extra=vol.ALLOW_EXTRA)
  
  
  async def async_setup(hass, config):
      """Establish connection with Daikin."""
      if DOMAIN not in config:
          return True
  
      hosts = config[DOMAIN].get(CONF_HOSTS)
      if not hosts:
          hass.async_create_task(
              hass.config_entries.flow.async_init(
                  DOMAIN, context={'source': SOURCE_IMPORT}))
      for host in hosts:
          hass.async_create_task(
              hass.config_entries.flow.async_init(
                  DOMAIN,
                  context={'source': SOURCE_IMPORT},
                  data={
                      KEY_HOST: host,
                  }))
      return True
  
  
  async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry):
      """Establish connection with Daikin."""
      conf = entry.data
      daikin_api = await daikin_api_setup(hass, conf[KEY_HOST])
      if not daikin_api:
          return False
      hass.data.setdefault(DOMAIN, {}).update({entry.entry_id: daikin_api})
      await asyncio.wait([
          hass.config_entries.async_forward_entry_setup(entry, component)
          for component in COMPONENT_TYPES
      ])
      return True
  
  
  async def async_unload_entry(hass, config_entry):
      """Unload a config entry."""
      await asyncio.wait([
          hass.config_entries.async_forward_entry_unload(config_entry, component)
          for component in COMPONENT_TYPES
      ])
      hass.data[DOMAIN].pop(config_entry.entry_id)
      if not hass.data[DOMAIN]:
          hass.data.pop(DOMAIN)
      return True
  
  
  async def daikin_api_setup(hass, host):
      """Create a Daikin instance only once."""
      from pydaikin.appliance import Appliance
      try:
          with async_timeout.timeout(10):
              device = await hass.async_add_executor_job(Appliance, host)
      except asyncio.TimeoutError:
          _LOGGER.error("Connection to Daikin could not be established")
          return None
      except Exception:  # pylint: disable=broad-except
          _LOGGER.error("Unexpected error creating device")
          return None
  
      name = device.values['name']
      api = DaikinApi(device, name)
  
      return api
  
  
  class DaikinApi:
      """Keep the Daikin instance in one place and centralize the update."""
  
      def __init__(self, device, name):
          """Initialize the Daikin Handle."""
          self.device = device
          self.name = name
          self.ip_address = device.ip
  
      @Throttle(MIN_TIME_BETWEEN_UPDATES)
      def update(self, **kwargs):
          """Pull the latest data from Daikin."""
          try:
              self.device.update_status()
          except timeout:
              _LOGGER.warning(
                  "Connection failed for %s", self.ip_address
              )
  
      @property
      def mac(self):
          """Return mac-address of device."""
          return self.device.values.get(CONNECTION_NETWORK_MAC)
  
      @property
      def device_info(self):
          """Return a device description for device registry."""
          info = self.device.values
          return {
              'connections': {(CONNECTION_NETWORK_MAC, self.mac)},
              'identifieres': self.mac,
              'manufacturer': 'Daikin',
              'model': info.get('model'),
              'name': info.get('name'),
              'sw_version': info.get('ver').replace('_', '.'),
          }
  