text: """Support for MQTT fans."""
  import logging
  
  import voluptuous as vol
  
  from homeassistant.components import fan, mqtt
  from homeassistant.components.fan import (
      ATTR_SPEED, SPEED_HIGH, SPEED_LOW, SPEED_MEDIUM, SPEED_OFF,
      SUPPORT_OSCILLATE, SUPPORT_SET_SPEED, FanEntity)
  from homeassistant.const import (
      CONF_DEVICE, CONF_NAME, CONF_OPTIMISTIC, CONF_PAYLOAD_OFF, CONF_PAYLOAD_ON,
      CONF_STATE, STATE_OFF, STATE_ON)
  from homeassistant.core import callback
  import homeassistant.helpers.config_validation as cv
  from homeassistant.helpers.dispatcher import async_dispatcher_connect
  from homeassistant.helpers.typing import ConfigType, HomeAssistantType
  
  from . import (
      ATTR_DISCOVERY_HASH, CONF_COMMAND_TOPIC, CONF_QOS, CONF_RETAIN,
      CONF_STATE_TOPIC, CONF_UNIQUE_ID, MqttAttributes, MqttAvailability,
      MqttDiscoveryUpdate, MqttEntityDeviceInfo, subscription)
  from .discovery import MQTT_DISCOVERY_NEW, clear_discovery_hash
  
  _LOGGER = logging.getLogger(__name__)
  
  CONF_STATE_VALUE_TEMPLATE = 'state_value_template'
  CONF_SPEED_STATE_TOPIC = 'speed_state_topic'
  CONF_SPEED_COMMAND_TOPIC = 'speed_command_topic'
  CONF_SPEED_VALUE_TEMPLATE = 'speed_value_template'
  CONF_OSCILLATION_STATE_TOPIC = 'oscillation_state_topic'
  CONF_OSCILLATION_COMMAND_TOPIC = 'oscillation_command_topic'
  CONF_OSCILLATION_VALUE_TEMPLATE = 'oscillation_value_template'
  CONF_PAYLOAD_OSCILLATION_ON = 'payload_oscillation_on'
  CONF_PAYLOAD_OSCILLATION_OFF = 'payload_oscillation_off'
  CONF_PAYLOAD_LOW_SPEED = 'payload_low_speed'
  CONF_PAYLOAD_MEDIUM_SPEED = 'payload_medium_speed'
  CONF_PAYLOAD_HIGH_SPEED = 'payload_high_speed'
  CONF_SPEED_LIST = 'speeds'
  
  DEFAULT_NAME = 'MQTT Fan'
  DEFAULT_PAYLOAD_ON = 'ON'
  DEFAULT_PAYLOAD_OFF = 'OFF'
  DEFAULT_OPTIMISTIC = False
  
  OSCILLATE_ON_PAYLOAD = 'oscillate_on'
  OSCILLATE_OFF_PAYLOAD = 'oscillate_off'
  
  OSCILLATION = 'oscillation'
  
  PLATFORM_SCHEMA = mqtt.MQTT_RW_PLATFORM_SCHEMA.extend({
      vol.Optional(CONF_DEVICE): mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA,
      vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
      vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean,
      vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): mqtt.valid_publish_topic,
      vol.Optional(CONF_OSCILLATION_STATE_TOPIC): mqtt.valid_subscribe_topic,
      vol.Optional(CONF_OSCILLATION_VALUE_TEMPLATE): cv.template,
      vol.Optional(CONF_PAYLOAD_HIGH_SPEED, default=SPEED_HIGH): cv.string,
      vol.Optional(CONF_PAYLOAD_LOW_SPEED, default=SPEED_LOW): cv.string,
      vol.Optional(CONF_PAYLOAD_MEDIUM_SPEED, default=SPEED_MEDIUM): cv.string,
      vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string,
      vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string,
      vol.Optional(CONF_PAYLOAD_OSCILLATION_OFF,
                   default=DEFAULT_PAYLOAD_OFF): cv.string,
      vol.Optional(CONF_PAYLOAD_OSCILLATION_ON,
                   default=DEFAULT_PAYLOAD_ON): cv.string,
      vol.Optional(CONF_SPEED_COMMAND_TOPIC): mqtt.valid_publish_topic,
      vol.Optional(CONF_SPEED_LIST,
                   default=[SPEED_OFF, SPEED_LOW,
                            SPEED_MEDIUM, SPEED_HIGH]): cv.ensure_list,
      vol.Optional(CONF_SPEED_STATE_TOPIC): mqtt.valid_subscribe_topic,
      vol.Optional(CONF_SPEED_VALUE_TEMPLATE): cv.template,
      vol.Optional(CONF_STATE_VALUE_TEMPLATE): cv.template,
      vol.Optional(CONF_UNIQUE_ID): cv.string,
  }).extend(mqtt.MQTT_AVAILABILITY_SCHEMA.schema).extend(
      mqtt.MQTT_JSON_ATTRS_SCHEMA.schema)
  
  
  async def async_setup_platform(hass: HomeAssistantType, config: ConfigType,
                                 async_add_entities, discovery_info=None):
      """Set up MQTT fan through configuration.yaml."""
      await _async_setup_entity(config, async_add_entities)
  
  
  async def async_setup_entry(hass, config_entry, async_add_entities):
      """Set up MQTT fan dynamically through MQTT discovery."""
      async def async_discover(discovery_payload):
          """Discover and add a MQTT fan."""
          try:
              discovery_hash = discovery_payload.pop(ATTR_DISCOVERY_HASH)
              config = PLATFORM_SCHEMA(discovery_payload)
              await _async_setup_entity(config, async_add_entities, config_entry,
                                        discovery_hash)
          except Exception:
              if discovery_hash:
                  clear_discovery_hash(hass, discovery_hash)
              raise
  
      async_dispatcher_connect(
          hass, MQTT_DISCOVERY_NEW.format(fan.DOMAIN, 'mqtt'),
          async_discover)
  
  
  async def _async_setup_entity(config, async_add_entities, config_entry=None,
                                discovery_hash=None):
      """Set up the MQTT fan."""
      async_add_entities([MqttFan(config, config_entry, discovery_hash)])
  
  
  # pylint: disable=too-many-ancestors
  class MqttFan(MqttAttributes, MqttAvailability, MqttDiscoveryUpdate,
                MqttEntityDeviceInfo, FanEntity):
      """A MQTT fan component."""
  
      def __init__(self, config, config_entry, discovery_hash):
          """Initialize the MQTT fan."""
          self._unique_id = config.get(CONF_UNIQUE_ID)
          self._state = False
          self._speed = None
          self._oscillation = None
          self._supported_features = 0
          self._sub_state = None
  
          self._topic = None
          self._payload = None
          self._templates = None
          self._optimistic = None
          self._optimistic_oscillation = None
          self._optimistic_speed = None
  
          # Load config
          self._setup_from_config(config)
  
          device_config = config.get(CONF_DEVICE)
  
          MqttAttributes.__init__(self, config)
          MqttAvailability.__init__(self, config)
          MqttDiscoveryUpdate.__init__(self, discovery_hash,
                                       self.discovery_update)
          MqttEntityDeviceInfo.__init__(self, device_config, config_entry)
  
      async def async_added_to_hass(self):
          """Subscribe to MQTT events."""
          await super().async_added_to_hass()
          await self._subscribe_topics()
  
      async def discovery_update(self, discovery_payload):
          """Handle updated discovery message."""
          config = PLATFORM_SCHEMA(discovery_payload)
          self._setup_from_config(config)
          await self.attributes_discovery_update(config)
          await self.availability_discovery_update(config)
          await self.device_info_discovery_update(config)
          await self._subscribe_topics()
          self.async_write_ha_state()
  
      def _setup_from_config(self, config):
          """(Re)Setup the entity."""
          self._config = config
          self._topic = {
              key: config.get(key) for key in (
                  CONF_STATE_TOPIC,
                  CONF_COMMAND_TOPIC,
                  CONF_SPEED_STATE_TOPIC,
                  CONF_SPEED_COMMAND_TOPIC,
                  CONF_OSCILLATION_STATE_TOPIC,
                  CONF_OSCILLATION_COMMAND_TOPIC,
              )
          }
          self._templates = {
              CONF_STATE: config.get(CONF_STATE_VALUE_TEMPLATE),
              ATTR_SPEED: config.get(CONF_SPEED_VALUE_TEMPLATE),
              OSCILLATION: config.get(CONF_OSCILLATION_VALUE_TEMPLATE)
          }
          self._payload = {
              STATE_ON: config[CONF_PAYLOAD_ON],
              STATE_OFF: config[CONF_PAYLOAD_OFF],
              OSCILLATE_ON_PAYLOAD: config[CONF_PAYLOAD_OSCILLATION_ON],
              OSCILLATE_OFF_PAYLOAD: config[CONF_PAYLOAD_OSCILLATION_OFF],
              SPEED_LOW: config[CONF_PAYLOAD_LOW_SPEED],
              SPEED_MEDIUM: config[CONF_PAYLOAD_MEDIUM_SPEED],
              SPEED_HIGH: config[CONF_PAYLOAD_HIGH_SPEED],
          }
          optimistic = config[CONF_OPTIMISTIC]
          self._optimistic = optimistic or self._topic[CONF_STATE_TOPIC] is None
          self._optimistic_oscillation = (
              optimistic or self._topic[CONF_OSCILLATION_STATE_TOPIC] is None)
          self._optimistic_speed = (
              optimistic or self._topic[CONF_SPEED_STATE_TOPIC] is None)
  
          self._supported_features = 0
          self._supported_features |= (self._topic[CONF_OSCILLATION_STATE_TOPIC]
                                       is not None and SUPPORT_OSCILLATE)
          self._supported_features |= (self._topic[CONF_SPEED_STATE_TOPIC]
                                       is not None and SUPPORT_SET_SPEED)
  
      async def _subscribe_topics(self):
          """(Re)Subscribe to topics."""
          topics = {}
          templates = {}
          for key, tpl in list(self._templates.items()):
              if tpl is None:
                  templates[key] = lambda value: value
              else:
                  tpl.hass = self.hass
                  templates[key] = tpl.async_render_with_possible_json_value
  
          @callback
          def state_received(msg):
              """Handle new received MQTT message."""
              payload = templates[CONF_STATE](msg.payload)
              if payload == self._payload[STATE_ON]:
                  self._state = True
              elif payload == self._payload[STATE_OFF]:
                  self._state = False
              self.async_write_ha_state()
  
          if self._topic[CONF_STATE_TOPIC] is not None:
              topics[CONF_STATE_TOPIC] = {
                  'topic': self._topic[CONF_STATE_TOPIC],
                  'msg_callback': state_received,
                  'qos': self._config[CONF_QOS]}
  
          @callback
          def speed_received(msg):
              """Handle new received MQTT message for the speed."""
              payload = templates[ATTR_SPEED](msg.payload)
              if payload == self._payload[SPEED_LOW]:
                  self._speed = SPEED_LOW
              elif payload == self._payload[SPEED_MEDIUM]:
                  self._speed = SPEED_MEDIUM
              elif payload == self._payload[SPEED_HIGH]:
                  self._speed = SPEED_HIGH
              self.async_write_ha_state()
  
          if self._topic[CONF_SPEED_STATE_TOPIC] is not None:
              topics[CONF_SPEED_STATE_TOPIC] = {
                  'topic': self._topic[CONF_SPEED_STATE_TOPIC],
                  'msg_callback': speed_received,
                  'qos': self._config[CONF_QOS]}
              self._speed = SPEED_OFF
  
          @callback
          def oscillation_received(msg):
              """Handle new received MQTT message for the oscillation."""
              payload = templates[OSCILLATION](msg.payload)
              if payload == self._payload[OSCILLATE_ON_PAYLOAD]:
                  self._oscillation = True
              elif payload == self._payload[OSCILLATE_OFF_PAYLOAD]:
                  self._oscillation = False
              self.async_write_ha_state()
  
          if self._topic[CONF_OSCILLATION_STATE_TOPIC] is not None:
              topics[CONF_OSCILLATION_STATE_TOPIC] = {
                  'topic': self._topic[CONF_OSCILLATION_STATE_TOPIC],
                  'msg_callback': oscillation_received,
                  'qos': self._config[CONF_QOS]}
              self._oscillation = False
  
          self._sub_state = await subscription.async_subscribe_topics(
              self.hass, self._sub_state,
              topics)
  
      async def async_will_remove_from_hass(self):
          """Unsubscribe when removed."""
          self._sub_state = await subscription.async_unsubscribe_topics(
              self.hass, self._sub_state)
          await MqttAttributes.async_will_remove_from_hass(self)
          await MqttAvailability.async_will_remove_from_hass(self)
  
      @property
      def should_poll(self):
          """No polling needed for a MQTT fan."""
          return False
  
      @property
      def assumed_state(self):
          """Return true if we do optimistic updates."""
          return self._optimistic
  
      @property
      def is_on(self):
          """Return true if device is on."""
          return self._state
  
      @property
      def name(self) -> str:
          """Get entity name."""
          return self._config[CONF_NAME]
  
      @property
      def speed_list(self) -> list:
          """Get the list of available speeds."""
          return self._config[CONF_SPEED_LIST]
  
      @property
      def supported_features(self) -> int:
          """Flag supported features."""
          return self._supported_features
  
      @property
      def speed(self):
          """Return the current speed."""
          return self._speed
  
      @property
      def oscillating(self):
          """Return the oscillation state."""
          return self._oscillation
  
      async def async_turn_on(self, speed: str = None, **kwargs) -> None:
          """Turn on the entity.
  
          This method is a coroutine.
          """
          mqtt.async_publish(
              self.hass, self._topic[CONF_COMMAND_TOPIC],
              self._payload[STATE_ON], self._config[CONF_QOS],
              self._config[CONF_RETAIN])
          if speed:
              await self.async_set_speed(speed)
  
      async def async_turn_off(self, **kwargs) -> None:
          """Turn off the entity.
  
          This method is a coroutine.
          """
          mqtt.async_publish(
              self.hass, self._topic[CONF_COMMAND_TOPIC],
              self._payload[STATE_OFF], self._config[CONF_QOS],
              self._config[CONF_RETAIN])
  
      async def async_set_speed(self, speed: str) -> None:
          """Set the speed of the fan.
  
          This method is a coroutine.
          """
          if self._topic[CONF_SPEED_COMMAND_TOPIC] is None:
              return
  
          if speed == SPEED_LOW:
              mqtt_payload = self._payload[SPEED_LOW]
          elif speed == SPEED_MEDIUM:
              mqtt_payload = self._payload[SPEED_MEDIUM]
          elif speed == SPEED_HIGH:
              mqtt_payload = self._payload[SPEED_HIGH]
          else:
              mqtt_payload = speed
  
          mqtt.async_publish(
              self.hass, self._topic[CONF_SPEED_COMMAND_TOPIC],
              mqtt_payload, self._config[CONF_QOS],
              self._config[CONF_RETAIN])
  
          if self._optimistic_speed:
              self._speed = speed
              self.async_write_ha_state()
  
      async def async_oscillate(self, oscillating: bool) -> None:
          """Set oscillation.
  
          This method is a coroutine.
          """
          if self._topic[CONF_OSCILLATION_COMMAND_TOPIC] is None:
              return
  
          if oscillating is False:
              payload = self._payload[OSCILLATE_OFF_PAYLOAD]
          else:
              payload = self._payload[OSCILLATE_ON_PAYLOAD]
  
          mqtt.async_publish(
              self.hass, self._topic[CONF_OSCILLATION_COMMAND_TOPIC],
              payload, self._config[CONF_QOS], self._config[CONF_RETAIN])
  
          if self._optimistic_oscillation:
              self._oscillation = oscillating
              self.async_write_ha_state()
  
      @property
      def unique_id(self):
          """Return a unique ID."""
          return self._unique_id
  