text: """Config flow to configure Life360 integration."""
  from collections import OrderedDict
  import logging
  
  from life360 import LoginError
  import voluptuous as vol
  
  from homeassistant import config_entries
  from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
  
  from .const import CONF_AUTHORIZATION, DOMAIN
  from .helpers import get_api
  
  _LOGGER = logging.getLogger(__name__)
  
  DOCS_URL = 'https://www.home-assistant.io/components/life360'
  
  
  @config_entries.HANDLERS.register(DOMAIN)
  class Life360ConfigFlow(config_entries.ConfigFlow):
      """Life360 integration config flow."""
  
      VERSION = 1
      CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
  
      def __init__(self):
          """Initialize."""
          self._api = get_api()
          self._username = vol.UNDEFINED
          self._password = vol.UNDEFINED
  
      @property
      def configured_usernames(self):
          """Return tuple of configured usernames."""
          entries = self.hass.config_entries.async_entries(DOMAIN)
          if entries:
              return (entry.data[CONF_USERNAME] for entry in entries)
          return ()
  
      async def async_step_user(self, user_input=None):
          """Handle a user initiated config flow."""
          errors = {}
  
          if user_input is not None:
              self._username = user_input[CONF_USERNAME]
              self._password = user_input[CONF_PASSWORD]
              try:
                  # pylint: disable=no-value-for-parameter
                  vol.Email()(self._username)
                  authorization = self._api.get_authorization(
                      self._username, self._password)
              except vol.Invalid:
                  errors[CONF_USERNAME] = 'invalid_username'
              except LoginError:
                  errors['base'] = 'invalid_credentials'
              else:
                  if self._username in self.configured_usernames:
                      errors['base'] = 'user_already_configured'
                  else:
                      return self.async_create_entry(
                          title=self._username,
                          data={
                              CONF_USERNAME: self._username,
                              CONF_PASSWORD: self._password,
                              CONF_AUTHORIZATION: authorization
                          },
                          description_placeholders={'docs_url': DOCS_URL}
                      )
  
          data_schema = OrderedDict()
          data_schema[vol.Required(CONF_USERNAME, default=self._username)] = str
          data_schema[vol.Required(CONF_PASSWORD, default=self._password)] = str
  
          return self.async_show_form(
              step_id='user',
              data_schema=vol.Schema(data_schema),
              errors=errors,
              description_placeholders={'docs_url': DOCS_URL}
          )
  
      async def async_step_import(self, user_input):
          """Import a config flow from configuration."""
          username = user_input[CONF_USERNAME]
          password = user_input[CONF_PASSWORD]
          if username in self.configured_usernames:
              _LOGGER.warning('%s already configured', username)
              return self.async_abort(reason='user_already_configured')
          try:
              authorization = self._api.get_authorization(username, password)
          except LoginError:
              _LOGGER.error('Invalid credentials for %s', username)
              return self.async_abort(reason='invalid_credentials')
          return self.async_create_entry(
              title='{} (from configuration)'.format(username),
              data={
                  CONF_USERNAME: username,
                  CONF_PASSWORD: password,
                  CONF_AUTHORIZATION: authorization
              }
          )
  