Merge pull request #1636 from esphome/bump-1.17.0b1

1.17.0b1
2026-06-12 19:06:05 +08:00 · 2021-03-22 20:44:38 +13:00
parent 808ce6eecb 6114d331c9
commit 0fe61d9ec7
553 changed files with 27573 additions and 13992 deletions
@@ -1,13 +1,47 @@
-## Description:
+# What does this implement/fix? 

+Quick description 

-**Related issue (if applicable):** fixes <link to issue>
+## Types of changes
+
+- [ ] Bugfix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Configuration change (this will require users to update their yaml configuration files to keep working)
+
+**Related issue or feature (if applicable):** fixes <link to issue>

 **Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>
+  
+# Test Environment
+
+- [ ] ESP32
+- [ ] ESP8266
+- [ ] Windows
+- [ ] Mac OS
+- [ ] Linux
+
+## Example entry for `config.yaml`:
+<!--
+  Supplying a configuration snippet, makes it easier for a maintainer to test
+  your PR. Furthermore, for new integrations, it gives an impression of how
+  the configuration would look like.
+  Note: Remove this section if this PR does not have an example entry.
+-->
+
+```yaml
+# Example config.yaml
+
+```
+
+# Explain your changes
+
+Describe your changes here to communicate to the maintainers **why we should accept this pull request**.
+Very important to fill if no issue linked

 ## Checklist:
  - [ ] The code change is tested and works locally.
  - [ ] Tests have been added to verify that the new code works (under `tests/` folder).
-
+  
 If user exposed functionality or configuration variables are added/changed:
  - [ ] Documentation added/updated in [esphome-docs](https://github.com/esphome/esphome-docs).
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v2
      - name: Set up env variables
        run: |
-          base_version="2.6.0"
+          base_version="3.0.0"

          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
@@ -45,7 +45,7 @@ jobs:
        run: |
          docker pull "${BUILD_TO}:dev" || true
      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
+        run: docker run --rm --privileged multiarch/qemu-user-static:5.2.0-2 --reset -p yes
      - run: |
          docker build \
            --build-arg "BUILD_FROM=${BUILD_FROM}" \
@@ -18,15 +18,6 @@ jobs:
    container: esphome/esphome-lint:latest
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -49,15 +40,6 @@ jobs:
        split: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -15,15 +15,6 @@ jobs:
    container: esphome/esphome-lint:latest
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -46,15 +37,6 @@ jobs:
        split: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -192,7 +174,7 @@ jobs:
          echo "TAG=${TAG}" >> $GITHUB_ENV
      - name: Set up env variables
        run: |
-          base_version="2.6.0"
+          base_version="3.0.0"

          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
@@ -211,7 +193,7 @@ jobs:
        run: |
          docker pull "${BUILD_TO}:dev" || true
      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
+        run: docker run --rm --privileged multiarch/qemu-user-static:5.2.0-2 --reset -p yes
      - run: |
          docker build \
            --build-arg "BUILD_FROM=${BUILD_FROM}" \
@@ -14,15 +14,6 @@ jobs:
    container: esphome/esphome-lint:latest
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -45,15 +36,6 @@ jobs:
        split: [1, 2, 3, 4]
    steps:
      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
      # Set up the pio project so that the cpp checks know how files are compiled
      # (build flags, libraries etc)
      - name: Set up platformio environment
@@ -212,7 +194,7 @@ jobs:
          echo "TAG=${TAG}" >> $GITHUB_ENV
      - name: Set up env variables
        run: |
-          base_version="2.6.0"
+          base_version="3.0.0"

          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
@@ -239,7 +221,7 @@ jobs:
        run: |
          docker pull "${BUILD_TO}:${CACHE_TAG}" || true
      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
+        run: docker run --rm --privileged multiarch/qemu-user-static:5.2.0-2 --reset -p yes
      - run: |
          docker build \
            --build-arg "BUILD_FROM=${BUILD_FROM}" \
@@ -1,11 +1,27 @@
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
-   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.4.0
+  - repo: https://github.com/ambv/black
+    rev: 20.8b1
    hooks:
-    -   id: trailing-whitespace
-    -   id: end-of-file-fixer
-    -   id: check-yaml
-    -   id: check-added-large-files
-    -   id: flake8
+    - id: black
+      args:
+        - --safe
+        - --quiet
+      files: ^((esphome|script|tests)/.+)?[^/]+\.py$
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.4
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-docstrings==1.5.0
+          - pydocstyle==5.1.1
+        files: ^(esphome|tests)/.+\.py$
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: no-commit-to-branch
+        args:
+          - --branch=dev
+          - --branch=master
+          - --branch=beta
@@ -13,6 +13,7 @@ esphome/core/* @esphome/core
 # Integrations
 esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
+esphome/components/addressable_light/* @justfalter
 esphome/components/animation/* @syndlex
 esphome/components/api/* @OttoWinter
 esphome/components/async_tcp/* @OttoWinter
@@ -37,6 +38,7 @@ esphome/components/globals/* @esphome/core
 esphome/components/gpio/* @esphome/core
 esphome/components/homeassistant/* @OttoWinter
 esphome/components/i2c/* @esphome/core
+esphome/components/inkbird_ibsth1_mini/* @fkirill
 esphome/components/inkplate6/* @jesserockz
 esphome/components/integration/* @OttoWinter
 esphome/components/interval/* @esphome/core
@@ -44,10 +46,18 @@ esphome/components/json/* @OttoWinter
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
 esphome/components/logger/* @esphome/core
-esphome/components/mcp23s08/* @SenexCrenshaw
-esphome/components/mcp23s17/* @SenexCrenshaw
+esphome/components/max7219digit/* @rspaargaren
+esphome/components/mcp23008/* @jesserockz
+esphome/components/mcp23017/* @jesserockz
+esphome/components/mcp23s08/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23s17/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23x08_base/* @jesserockz
+esphome/components/mcp23x17_base/* @jesserockz
+esphome/components/mcp23xxx_base/* @jesserockz
 esphome/components/mcp2515/* @danielschramm @mvturnho
 esphome/components/mcp9808/* @k7hpn
+esphome/components/midea_ac/* @dudanov
+esphome/components/midea_dongle/* @dudanov
 esphome/components/network/* @esphome/core
 esphome/components/nfc/* @jesserockz
 esphome/components/ota/* @esphome/core
@@ -57,6 +67,7 @@ esphome/components/pn532/* @OttoWinter @jesserockz
 esphome/components/pn532_i2c/* @OttoWinter @jesserockz
 esphome/components/pn532_spi/* @OttoWinter @jesserockz
 esphome/components/power_supply/* @esphome/core
+esphome/components/pulse_meter/* @stevebaxter
 esphome/components/rc522/* @glmnet
 esphome/components/rc522_i2c/* @glmnet
 esphome/components/rc522_spi/* @glmnet
@@ -1,9 +1,11 @@
-ARG BUILD_FROM=esphome/esphome-base-amd64:2.6.0
+ARG BUILD_FROM=esphome/esphome-base-amd64:3.0.0
 FROM ${BUILD_FROM}

 # First install requirements to leverage caching when requirements don't change
-COPY requirements.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt
+COPY requirements.txt docker/platformio_install_deps.py platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt \
+    && /platformio_install_deps.py /platformio.ini

 # Then copy esphome and install
 COPY . .
@@ -1,4 +1,4 @@
-FROM esphome/esphome-base-amd64:2.6.0
+FROM esphome/esphome-base-amd64:3.0.0

 COPY . .

@@ -2,8 +2,10 @@ ARG BUILD_FROM
 FROM ${BUILD_FROM}

 # First install requirements to leverage caching when requirements don't change
-COPY requirements.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt
+COPY requirements.txt docker/platformio_install_deps.py platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt \
+    && /platformio_install_deps.py /platformio.ini

 # Copy root filesystem
 COPY docker/rootfs/ /
@@ -1,7 +1,9 @@
-FROM esphome/esphome-lint-base:2.6.0
+FROM esphome/esphome-lint-base:3.0.0

-COPY requirements.txt requirements_test.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt -r /requirements_test.txt
+COPY requirements.txt requirements_test.txt docker/platformio_install_deps.py  platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_test.txt \
+    && /platformio_install_deps.py /platformio.ini

 VOLUME ["/esphome"]
 WORKDIR /esphome
@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# This script is used in the docker containers to preinstall
+# all platformio libraries in the global storage
+
+import configparser
+import re
+import subprocess
+import sys
+
+config = configparser.ConfigParser()
+config.read(sys.argv[1])
+libs = []
+for line in config['common']['lib_deps'].splitlines():
+    # Format: '1655@1.0.2  ; TinyGPSPlus (has name conflict)' (includes comment)
+    m = re.search(r'([a-zA-Z0-9-_/]+@[0-9\.]+)', line)
+    if m is None:
+        continue
+    libs.append(m.group(1))
+
+subprocess.check_call(['platformio', 'lib', '-g', 'install', *libs])
@@ -177,10 +177,14 @@ class APIClient(threading.Thread):
        try:
            ip = resolve_ip_address(self._address)
        except EsphomeError as err:
-            _LOGGER.warning("Error resolving IP address of %s. Is it connected to WiFi?",
-                            self._address)
-            _LOGGER.warning("(If this error persists, please set a static IP address: "
-                            "https://esphome.io/components/wifi.html#manual-ips)")
+            _LOGGER.warning(
+                "Error resolving IP address of %s. Is it connected to WiFi?",
+                self._address,
+            )
+            _LOGGER.warning(
+                "(If this error persists, please set a static IP address: "
+                "https://esphome.io/components/wifi.html#manual-ips)"
+            )
            raise APIConnectionError(err) from err

        _LOGGER.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
@@ -198,14 +202,19 @@ class APIClient(threading.Thread):
        self._socket_open_event.set()

        hello = pb.HelloRequest()
-        hello.client_info = f'ESPHome v{const.__version__}'
+        hello.client_info = f"ESPHome v{const.__version__}"
        try:
            resp = self._send_message_await_response(hello, pb.HelloResponse)
        except APIConnectionError as err:
            self._fatal_error(err)
            raise err
-        _LOGGER.debug("Successfully connected to %s ('%s' API=%s.%s)", self._address,
-                      resp.server_info, resp.api_version_major, resp.api_version_minor)
+        _LOGGER.debug(
+            "Successfully connected to %s ('%s' API=%s.%s)",
+            self._address,
+            resp.server_info,
+            resp.api_version_major,
+            resp.api_version_minor,
+        )
        self._connected = True
        self._refresh_ping()
        if self.on_connect is not None:
@@ -270,7 +279,9 @@ class APIClient(threading.Thread):
        req += encoded
        self._write(req)

-    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=5):
+    def _send_message_await_response_complex(
+        self, send_msg, do_append, do_stop, timeout=5
+    ):
        event = threading.Event()
        responses = []

@@ -295,12 +306,15 @@ class APIClient(threading.Thread):
        def is_response(msg):
            return isinstance(msg, response_type)

-        return self._send_message_await_response_complex(send_msg, is_response, is_response,
-                                                         timeout)[0]
+        return self._send_message_await_response_complex(
+            send_msg, is_response, is_response, timeout
+        )[0]

    def device_info(self):
        self._check_connected()
-        return self._send_message_await_response(pb.DeviceInfoRequest(), pb.DeviceInfoResponse)
+        return self._send_message_await_response(
+            pb.DeviceInfoRequest(), pb.DeviceInfoResponse
+        )

    def ping(self):
        self._check_connected()
@@ -310,7 +324,9 @@ class APIClient(threading.Thread):
        self._check_connected()

        try:
-            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
+            self._send_message_await_response(
+                pb.DisconnectRequest(), pb.DisconnectResponse
+            )
        except APIConnectionError:
            pass
        self._close_socket()
@@ -415,7 +431,7 @@ class APIClient(threading.Thread):


 def run_logs(config, address):
-    conf = config['api']
+    conf = config["api"]
    port = conf[CONF_PORT]
    password = conf[CONF_PASSWORD]
    _LOGGER.info("Starting log output from %s using esphome API", address)
@@ -447,24 +463,35 @@ def run_logs(config, address):
            _LOGGER.info("Successfully connected to %s", address)
            return

-        wait_time = int(min(1.5**min(tries, 100), 30))
+        wait_time = int(min(1.5 ** min(tries, 100), 30))
        if not has_connects:
-            _LOGGER.warning("Initial connection failed. The ESP might not be connected "
-                            "to WiFi yet (%s). Re-Trying in %s seconds",
-                            error, wait_time)
+            _LOGGER.warning(
+                "Initial connection failed. The ESP might not be connected "
+                "to WiFi yet (%s). Re-Trying in %s seconds",
+                error,
+                wait_time,
+            )
        else:
-            _LOGGER.warning("Couldn't connect to API (%s). Trying to reconnect in %s seconds",
-                            error, wait_time)
-        timer = threading.Timer(wait_time, functools.partial(try_connect, None, tries + 1))
+            _LOGGER.warning(
+                "Couldn't connect to API (%s). Trying to reconnect in %s seconds",
+                error,
+                wait_time,
+            )
+        timer = threading.Timer(
+            wait_time, functools.partial(try_connect, None, tries + 1)
+        )
        timer.start()
        retry_timer.append(timer)

    def on_log(msg):
-        time_ = datetime.now().time().strftime('[%H:%M:%S]')
+        time_ = datetime.now().time().strftime("[%H:%M:%S]")
        text = msg.message
        if msg.send_failed:
-            text = color('white', '(Message skipped because it was too big to fit in '
-                                  'TCP buffer - This is only cosmetic)')
+            text = color(
+                "white",
+                "(Message skipped because it was too big to fit in "
+                "TCP buffer - This is only cosmetic)",
+            )
        safe_print(time_ + text)

    def on_login():
@@ -1,8 +1,17 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_AUTOMATION_ID, CONF_CONDITION, CONF_ELSE, CONF_ID, CONF_THEN, \
-    CONF_TRIGGER_ID, CONF_TYPE_ID, CONF_TIME
+from esphome.const import (
+    CONF_AUTOMATION_ID,
+    CONF_CONDITION,
+    CONF_ELSE,
+    CONF_ID,
+    CONF_THEN,
+    CONF_TRIGGER_ID,
+    CONF_TYPE_ID,
+    CONF_TIME,
+)
 from esphome.core import coroutine
+from esphome.jsonschema import jschema_extractor
 from esphome.util import Registry


@@ -13,7 +22,12 @@ def maybe_simple_id(*validators):
 def maybe_conf(conf, *validators):
    validator = cv.All(*validators)

+    @jschema_extractor("maybe")
    def validate(value):
+        # pylint: disable=comparison-with-callable
+        if value == jschema_extractor:
+            return validator
+
        if isinstance(value, dict):
            return validator(value)
        with cv.remove_prepend_path([conf]):
@@ -30,36 +44,34 @@ def register_condition(name, condition_type, schema):
    return CONDITION_REGISTRY.register(name, condition_type, schema)


-Action = cg.esphome_ns.class_('Action')
-Trigger = cg.esphome_ns.class_('Trigger')
+Action = cg.esphome_ns.class_("Action")
+Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
-Condition = cg.esphome_ns.class_('Condition')
+Condition = cg.esphome_ns.class_("Condition")
 CONDITION_REGISTRY = Registry()
-validate_action = cv.validate_registry_entry('action', ACTION_REGISTRY)
-validate_action_list = cv.validate_registry('action', ACTION_REGISTRY)
-validate_condition = cv.validate_registry_entry('condition', CONDITION_REGISTRY)
-validate_condition_list = cv.validate_registry('condition', CONDITION_REGISTRY)
+validate_action = cv.validate_registry_entry("action", ACTION_REGISTRY)
+validate_action_list = cv.validate_registry("action", ACTION_REGISTRY)
+validate_condition = cv.validate_registry_entry("condition", CONDITION_REGISTRY)
+validate_condition_list = cv.validate_registry("condition", CONDITION_REGISTRY)


 def validate_potentially_and_condition(value):
    if isinstance(value, list):
-        with cv.remove_prepend_path(['and']):
-            return validate_condition({
-                'and': value
-            })
+        with cv.remove_prepend_path(["and"]):
+            return validate_condition({"and": value})
    return validate_condition(value)


-DelayAction = cg.esphome_ns.class_('DelayAction', Action, cg.Component)
-LambdaAction = cg.esphome_ns.class_('LambdaAction', Action)
-IfAction = cg.esphome_ns.class_('IfAction', Action)
-WhileAction = cg.esphome_ns.class_('WhileAction', Action)
-WaitUntilAction = cg.esphome_ns.class_('WaitUntilAction', Action, cg.Component)
-UpdateComponentAction = cg.esphome_ns.class_('UpdateComponentAction', Action)
-Automation = cg.esphome_ns.class_('Automation')
+DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
+LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
+IfAction = cg.esphome_ns.class_("IfAction", Action)
+WhileAction = cg.esphome_ns.class_("WhileAction", Action)
+WaitUntilAction = cg.esphome_ns.class_("WaitUntilAction", Action, cg.Component)
+UpdateComponentAction = cg.esphome_ns.class_("UpdateComponentAction", Action)
+Automation = cg.esphome_ns.class_("Automation")

-LambdaCondition = cg.esphome_ns.class_('LambdaCondition', Condition)
-ForCondition = cg.esphome_ns.class_('ForCondition', Condition, cg.Component)
+LambdaCondition = cg.esphome_ns.class_("LambdaCondition", Condition)
+ForCondition = cg.esphome_ns.class_("ForCondition", Condition, cg.Component)


 def validate_automation(extra_schema=None, extra_validators=None, single=False):
@@ -83,10 +95,10 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
                try:
                    return cv.Schema([schema])(value)
                except cv.Invalid as err2:
-                    if 'extra keys not allowed' in str(err2) and len(err2.path) == 2:
+                    if "extra keys not allowed" in str(err2) and len(err2.path) == 2:
                        # pylint: disable=raise-missing-from
                        raise err
-                    if 'Unable to find action' in str(err):
+                    if "Unable to find action" in str(err):
                        raise err2
                    raise cv.MultipleInvalid([err, err2])
        elif isinstance(value, dict):
@@ -97,7 +109,13 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
        # This should only happen with invalid configs, but let's have a nice error message.
        return [schema(value)]

+    @jschema_extractor("automation")
    def validator(value):
+        # hack to get the schema
+        # pylint: disable=comparison-with-callable
+        if value == jschema_extractor:
+            return schema
+
        value = validator_(value)
        if extra_validators is not None:
            value = cv.Schema([extra_validators])(value)
@@ -110,47 +128,59 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
    return validator


-AUTOMATION_SCHEMA = cv.Schema({
-    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(Trigger),
-    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_id(Automation),
-    cv.Required(CONF_THEN): validate_action_list,
-})
+AUTOMATION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(Trigger),
+        cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_id(Automation),
+        cv.Required(CONF_THEN): validate_action_list,
+    }
+)

-AndCondition = cg.esphome_ns.class_('AndCondition', Condition)
-OrCondition = cg.esphome_ns.class_('OrCondition', Condition)
-NotCondition = cg.esphome_ns.class_('NotCondition', Condition)
+AndCondition = cg.esphome_ns.class_("AndCondition", Condition)
+OrCondition = cg.esphome_ns.class_("OrCondition", Condition)
+NotCondition = cg.esphome_ns.class_("NotCondition", Condition)


-@register_condition('and', AndCondition, validate_condition_list)
+@register_condition("and", AndCondition, validate_condition_list)
 def and_condition_to_code(config, condition_id, template_arg, args):
    conditions = yield build_condition_list(config, template_arg, args)
    yield cg.new_Pvariable(condition_id, template_arg, conditions)


-@register_condition('or', OrCondition, validate_condition_list)
+@register_condition("or", OrCondition, validate_condition_list)
 def or_condition_to_code(config, condition_id, template_arg, args):
    conditions = yield build_condition_list(config, template_arg, args)
    yield cg.new_Pvariable(condition_id, template_arg, conditions)


-@register_condition('not', NotCondition, validate_potentially_and_condition)
+@register_condition("not", NotCondition, validate_potentially_and_condition)
 def not_condition_to_code(config, condition_id, template_arg, args):
    condition = yield build_condition(config, template_arg, args)
    yield cg.new_Pvariable(condition_id, template_arg, condition)


-@register_condition('lambda', LambdaCondition, cv.lambda_)
+@register_condition("lambda", LambdaCondition, cv.lambda_)
 def lambda_condition_to_code(config, condition_id, template_arg, args):
    lambda_ = yield cg.process_lambda(config, args, return_type=bool)
    yield cg.new_Pvariable(condition_id, template_arg, lambda_)


-@register_condition('for', ForCondition, cv.Schema({
-    cv.Required(CONF_TIME): cv.templatable(cv.positive_time_period_milliseconds),
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-}).extend(cv.COMPONENT_SCHEMA))
+@register_condition(
+    "for",
+    ForCondition,
+    cv.Schema(
+        {
+            cv.Required(CONF_TIME): cv.templatable(
+                cv.positive_time_period_milliseconds
+            ),
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+)
 def for_condition_to_code(config, condition_id, template_arg, args):
-    condition = yield build_condition(config[CONF_CONDITION], cg.TemplateArguments(), [])
+    condition = yield build_condition(
+        config[CONF_CONDITION], cg.TemplateArguments(), []
+    )
    var = cg.new_Pvariable(condition_id, template_arg, condition)
    yield cg.register_component(var, config)
    templ = yield cg.templatable(config[CONF_TIME], args, cg.uint32)
@@ -158,7 +188,9 @@ def for_condition_to_code(config, condition_id, template_arg, args):
    yield var


-@register_action('delay', DelayAction, cv.templatable(cv.positive_time_period_milliseconds))
+@register_action(
+    "delay", DelayAction, cv.templatable(cv.positive_time_period_milliseconds)
+)
 def delay_action_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    yield cg.register_component(var, {})
@@ -167,11 +199,18 @@ def delay_action_to_code(config, action_id, template_arg, args):
    yield var


-@register_action('if', IfAction, cv.All({
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    cv.Optional(CONF_THEN): validate_action_list,
-    cv.Optional(CONF_ELSE): validate_action_list,
-}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE)))
+@register_action(
+    "if",
+    IfAction,
+    cv.All(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+            cv.Optional(CONF_THEN): validate_action_list,
+            cv.Optional(CONF_ELSE): validate_action_list,
+        },
+        cv.has_at_least_one_key(CONF_THEN, CONF_ELSE),
+    ),
+)
 def if_action_to_code(config, action_id, template_arg, args):
    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
    var = cg.new_Pvariable(action_id, template_arg, conditions)
@@ -184,10 +223,16 @@ def if_action_to_code(config, action_id, template_arg, args):
    yield var


-@register_action('while', WhileAction, cv.Schema({
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    cv.Required(CONF_THEN): validate_action_list,
-}))
+@register_action(
+    "while",
+    WhileAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+            cv.Required(CONF_THEN): validate_action_list,
+        }
+    ),
+)
 def while_action_to_code(config, action_id, template_arg, args):
    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
    var = cg.new_Pvariable(action_id, template_arg, conditions)
@@ -197,15 +242,17 @@ def while_action_to_code(config, action_id, template_arg, args):


 def validate_wait_until(value):
-    schema = cv.Schema({
-        cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    })
+    schema = cv.Schema(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+        }
+    )
    if isinstance(value, dict) and CONF_CONDITION in value:
        return schema(value)
    return validate_wait_until({CONF_CONDITION: value})


-@register_action('wait_until', WaitUntilAction, validate_wait_until)
+@register_action("wait_until", WaitUntilAction, validate_wait_until)
 def wait_until_action_to_code(config, action_id, template_arg, args):
    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
    var = cg.new_Pvariable(action_id, template_arg, conditions)
@@ -213,15 +260,21 @@ def wait_until_action_to_code(config, action_id, template_arg, args):
    yield var


-@register_action('lambda', LambdaAction, cv.lambda_)
+@register_action("lambda", LambdaAction, cv.lambda_)
 def lambda_action_to_code(config, action_id, template_arg, args):
    lambda_ = yield cg.process_lambda(config, args, return_type=cg.void)
    yield cg.new_Pvariable(action_id, template_arg, lambda_)


-@register_action('component.update', UpdateComponentAction, maybe_simple_id({
-    cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
-}))
+@register_action(
+    "component.update",
+    UpdateComponentAction,
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
+)
 def component_update_action_to_code(config, action_id, template_arg, args):
    comp = yield cg.get_variable(config[CONF_ID])
    yield cg.new_Pvariable(action_id, template_arg, comp)
@@ -229,7 +282,9 @@ def component_update_action_to_code(config, action_id, template_arg, args):

@coroutine
 def build_action(full_config, template_arg, args):
-    registry_entry, config = cg.extract_registry_entry_config(ACTION_REGISTRY, full_config)
+    registry_entry, config = cg.extract_registry_entry_config(
+        ACTION_REGISTRY, full_config
+    )
    action_id = full_config[CONF_TYPE_ID]
    builder = registry_entry.coroutine_fun
    yield builder(config, action_id, template_arg, args)
@@ -246,7 +301,9 @@ def build_action_list(config, templ, arg_type):

@coroutine
 def build_condition(full_config, template_arg, args):
-    registry_entry, config = cg.extract_registry_entry_config(CONDITION_REGISTRY, full_config)
+    registry_entry, config = cg.extract_registry_entry_config(
+        CONDITION_REGISTRY, full_config
+    )
    action_id = full_config[CONF_TYPE_ID]
    builder = registry_entry.coroutine_fun
    yield builder(config, action_id, template_arg, args)
@@ -9,18 +9,71 @@

 # pylint: disable=unused-import
 from esphome.cpp_generator import (  # noqa
-    Expression, RawExpression, RawStatement, TemplateArguments,
-    StructInitializer, ArrayInitializer, safe_exp, Statement, LineComment,
-    progmem_array, statement, variable, Pvariable, new_Pvariable,
-    add, add_global, add_library, add_build_flag, add_define,
-    get_variable, get_variable_with_full_id, process_lambda, is_template, templatable, MockObj,
-    MockObjClass)
+    Expression,
+    RawExpression,
+    RawStatement,
+    TemplateArguments,
+    StructInitializer,
+    ArrayInitializer,
+    safe_exp,
+    Statement,
+    LineComment,
+    progmem_array,
+    statement,
+    variable,
+    new_variable,
+    Pvariable,
+    new_Pvariable,
+    add,
+    add_global,
+    add_library,
+    add_build_flag,
+    add_define,
+    get_variable,
+    get_variable_with_full_id,
+    process_lambda,
+    is_template,
+    templatable,
+    MockObj,
+    MockObjClass,
+)
 from esphome.cpp_helpers import (  # noqa
-    gpio_pin_expression, register_component, build_registry_entry,
-    build_registry_list, extract_registry_entry_config, register_parented)
+    gpio_pin_expression,
+    register_component,
+    build_registry_entry,
+    build_registry_list,
+    extract_registry_entry_config,
+    register_parented,
+)
 from esphome.cpp_types import (  # noqa
-    global_ns, void, nullptr, float_, double, bool_, int_, std_ns, std_string,
-    std_vector, uint8, uint16, uint32, int32, const_char_ptr, NAN,
-    esphome_ns, App, Nameable, Component, ComponentPtr,
-    PollingComponent, Application, optional, arduino_json_ns, JsonObject,
-    JsonObjectRef, JsonObjectConstRef, Controller, GPIOPin)
+    global_ns,
+    void,
+    nullptr,
+    float_,
+    double,
+    bool_,
+    int_,
+    std_ns,
+    std_string,
+    std_vector,
+    uint8,
+    uint16,
+    uint32,
+    int32,
+    const_char_ptr,
+    NAN,
+    esphome_ns,
+    App,
+    Nameable,
+    Component,
+    ComponentPtr,
+    PollingComponent,
+    Application,
+    optional,
+    arduino_json_ns,
+    JsonObject,
+    JsonObjectRef,
+    JsonObjectConstRef,
+    Controller,
+    GPIOPin,
+)
@@ -11,6 +11,7 @@ void A4988::setup() {
  if (this->sleep_pin_ != nullptr) {
    this->sleep_pin_->setup();
    this->sleep_pin_->digital_write(false);
+    this->sleep_pin_state_ = false;
  }
  this->step_pin_->setup();
  this->step_pin_->digital_write(false);
@@ -27,7 +28,12 @@ void A4988::dump_config() {
 void A4988::loop() {
  bool at_target = this->has_reached_target();
  if (this->sleep_pin_ != nullptr) {
+    bool sleep_rising_edge = !sleep_pin_state_ & !at_target;
    this->sleep_pin_->digital_write(!at_target);
+    this->sleep_pin_state_ = !at_target;
+    if (sleep_rising_edge) {
+      delayMicroseconds(1000);
+    }
  }
  if (at_target) {
    this->high_freq_.stop();
@@ -21,6 +21,7 @@ class A4988 : public stepper::Stepper, public Component {
  GPIOPin *step_pin_;
  GPIOPin *dir_pin_;
  GPIOPin *sleep_pin_{nullptr};
+  bool sleep_pin_state_;
  HighFrequencyLoopRequester high_freq_;
 };

@@ -5,15 +5,17 @@ import esphome.codegen as cg
 from esphome.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN


-a4988_ns = cg.esphome_ns.namespace('a4988')
-A4988 = a4988_ns.class_('A4988', stepper.Stepper, cg.Component)
+a4988_ns = cg.esphome_ns.namespace("a4988")
+A4988 = a4988_ns.class_("A4988", stepper.Stepper, cg.Component)

-CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend({
-    cv.Required(CONF_ID): cv.declare_id(A4988),
-    cv.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
-    cv.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
-    cv.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(A4988),
+        cv.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
+        cv.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
+        cv.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
+    }
+).extend(cv.COMPONENT_SCHEMA)


 def to_code(config):
@@ -4,28 +4,32 @@ from esphome import pins
 from esphome.components import output
 from esphome.const import CONF_ID, CONF_MIN_POWER, CONF_METHOD

-CODEOWNERS = ['@glmnet']
+CODEOWNERS = ["@glmnet"]

-ac_dimmer_ns = cg.esphome_ns.namespace('ac_dimmer')
-AcDimmer = ac_dimmer_ns.class_('AcDimmer', output.FloatOutput, cg.Component)
+ac_dimmer_ns = cg.esphome_ns.namespace("ac_dimmer")
+AcDimmer = ac_dimmer_ns.class_("AcDimmer", output.FloatOutput, cg.Component)

-DimMethod = ac_dimmer_ns.enum('DimMethod')
+DimMethod = ac_dimmer_ns.enum("DimMethod")
 DIM_METHODS = {
-    'LEADING_PULSE': DimMethod.DIM_METHOD_LEADING_PULSE,
-    'LEADING': DimMethod.DIM_METHOD_LEADING,
-    'TRAILING': DimMethod.DIM_METHOD_TRAILING,
+    "LEADING_PULSE": DimMethod.DIM_METHOD_LEADING_PULSE,
+    "LEADING": DimMethod.DIM_METHOD_LEADING,
+    "TRAILING": DimMethod.DIM_METHOD_TRAILING,
 }

-CONF_GATE_PIN = 'gate_pin'
-CONF_ZERO_CROSS_PIN = 'zero_cross_pin'
-CONF_INIT_WITH_HALF_CYCLE = 'init_with_half_cycle'
-CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
-    cv.Required(CONF_ID): cv.declare_id(AcDimmer),
-    cv.Required(CONF_GATE_PIN): pins.internal_gpio_output_pin_schema,
-    cv.Required(CONF_ZERO_CROSS_PIN): pins.internal_gpio_input_pin_schema,
-    cv.Optional(CONF_INIT_WITH_HALF_CYCLE, default=True): cv.boolean,
-    cv.Optional(CONF_METHOD, default='leading pulse'): cv.enum(DIM_METHODS, upper=True, space='_'),
-}).extend(cv.COMPONENT_SCHEMA)
+CONF_GATE_PIN = "gate_pin"
+CONF_ZERO_CROSS_PIN = "zero_cross_pin"
+CONF_INIT_WITH_HALF_CYCLE = "init_with_half_cycle"
+CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(AcDimmer),
+        cv.Required(CONF_GATE_PIN): pins.internal_gpio_output_pin_schema,
+        cv.Required(CONF_ZERO_CROSS_PIN): pins.internal_gpio_input_pin_schema,
+        cv.Optional(CONF_INIT_WITH_HALF_CYCLE, default=True): cv.boolean,
+        cv.Optional(CONF_METHOD, default="leading pulse"): cv.enum(
+            DIM_METHODS, upper=True, space="_"
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)


 def to_code(config):
@@ -5,18 +5,22 @@ from esphome.components.light.types import AddressableLightEffect
 from esphome.components.light.effects import register_addressable_effect
 from esphome.const import CONF_NAME, CONF_UART_ID

-DEPENDENCIES = ['uart']
+DEPENDENCIES = ["uart"]

-adalight_ns = cg.esphome_ns.namespace('adalight')
+adalight_ns = cg.esphome_ns.namespace("adalight")
 AdalightLightEffect = adalight_ns.class_(
-    'AdalightLightEffect', uart.UARTDevice, AddressableLightEffect)
+    "AdalightLightEffect", uart.UARTDevice, AddressableLightEffect
+)

 CONFIG_SCHEMA = cv.Schema({})


-@register_addressable_effect('adalight', AdalightLightEffect, "Adalight", {
-    cv.GenerateID(CONF_UART_ID): cv.use_id(uart.UARTComponent)
-})
+@register_addressable_effect(
+    "adalight",
+    AdalightLightEffect,
+    "Adalight",
+    {cv.GenerateID(CONF_UART_ID): cv.use_id(uart.UARTComponent)},
+)
 def adalight_light_effect_to_code(config, effect_id):
    effect = cg.new_Pvariable(effect_id, config[CONF_NAME])
    yield uart.register_uart_device(effect, config)
@@ -42,11 +42,11 @@ void AdalightLightEffect::reset_frame_(light::AddressableLight &it) {

 void AdalightLightEffect::blank_all_leds_(light::AddressableLight &it) {
  for (int led = it.size(); led-- > 0;) {
-    it[led].set(light::ESPColor::BLACK);
+    it[led].set(COLOR_BLACK);
  }
 }

-void AdalightLightEffect::apply(light::AddressableLight &it, const light::ESPColor &current_color) {
+void AdalightLightEffect::apply(light::AddressableLight &it, const Color &current_color) {
  const uint32_t now = millis();

  if (now - this->last_ack_ >= ADALIGHT_ACK_INTERVAL) {
@@ -130,7 +130,7 @@ AdalightLightEffect::Frame AdalightLightEffect::parse_frame_(light::AddressableL
  for (int led = 0; led < accepted_led_count; led++, led_data += 3) {
    auto white = std::min(std::min(led_data[0], led_data[1]), led_data[2]);

-    it[led].set(light::ESPColor(led_data[0], led_data[1], led_data[2], white));
+    it[led].set(Color(led_data[0], led_data[1], led_data[2], white));
  }

  return CONSUMED;
@@ -16,7 +16,7 @@ class AdalightLightEffect : public light::AddressableLightEffect, public uart::U
 public:
  void start() override;
  void stop() override;
-  void apply(light::AddressableLight &it, const light::ESPColor &current_color) override;
+  void apply(light::AddressableLight &it, const Color &current_color) override;

 protected:
  enum Frame {
@@ -1 +1 @@
-CODEOWNERS = ['@esphome/core']
+CODEOWNERS = ["@esphome/core"]
@@ -16,7 +16,9 @@ void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuati

 void ADCSensor::setup() {
  ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
+#ifndef USE_ADC_SENSOR_VCC
  GPIOPin(this->pin_, INPUT).setup();
+#endif

 #ifdef ARDUINO_ARCH_ESP32
  analogSetPinAttenuation(this->pin_, this->attenuation_);
@@ -2,36 +2,51 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import sensor, voltage_sampler
-from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_PIN, ICON_FLASH, UNIT_VOLT
+from esphome.const import (
+    CONF_ATTENUATION,
+    CONF_ID,
+    CONF_PIN,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    UNIT_VOLT,
+)


-AUTO_LOAD = ['voltage_sampler']
+AUTO_LOAD = ["voltage_sampler"]

 ATTENUATION_MODES = {
-    '0db': cg.global_ns.ADC_0db,
-    '2.5db': cg.global_ns.ADC_2_5db,
-    '6db': cg.global_ns.ADC_6db,
-    '11db': cg.global_ns.ADC_11db,
+    "0db": cg.global_ns.ADC_0db,
+    "2.5db": cg.global_ns.ADC_2_5db,
+    "6db": cg.global_ns.ADC_6db,
+    "11db": cg.global_ns.ADC_11db,
 }


 def validate_adc_pin(value):
    vcc = str(value).upper()
-    if vcc == 'VCC':
+    if vcc == "VCC":
        return cv.only_on_esp8266(vcc)
    return pins.analog_pin(value)


-adc_ns = cg.esphome_ns.namespace('adc')
-ADCSensor = adc_ns.class_('ADCSensor', sensor.Sensor, cg.PollingComponent,
-                          voltage_sampler.VoltageSampler)
+adc_ns = cg.esphome_ns.namespace("adc")
+ADCSensor = adc_ns.class_(
+    "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)

-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2).extend({
-    cv.GenerateID(): cv.declare_id(ADCSensor),
-    cv.Required(CONF_PIN): validate_adc_pin,
-    cv.SplitDefault(CONF_ATTENUATION, esp32='0db'):
-        cv.All(cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)),
-}).extend(cv.polling_component_schema('60s'))
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE)
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(ADCSensor),
+            cv.Required(CONF_PIN): validate_adc_pin,
+            cv.SplitDefault(CONF_ATTENUATION, esp32="0db"): cv.All(
+                cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+)


 def to_code(config):
@@ -39,8 +54,8 @@ def to_code(config):
    yield cg.register_component(var, config)
    yield sensor.register_sensor(var, config)

-    if config[CONF_PIN] == 'VCC':
-        cg.add_define('USE_ADC_SENSOR_VCC')
+    if config[CONF_PIN] == "VCC":
+        cg.add_define("USE_ADC_SENSOR_VCC")
    else:
        cg.add(var.set_pin(config[CONF_PIN]))

@@ -0,0 +1,67 @@
+#include "addressable_light_display.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace addressable_light {
+
+static const char* TAG = "addressable_light.display";
+
+int AddressableLightDisplay::get_width_internal() { return this->width_; }
+int AddressableLightDisplay::get_height_internal() { return this->height_; }
+
+void AddressableLightDisplay::setup() {
+  this->addressable_light_buffer_.resize(this->width_ * this->height_, {0, 0, 0, 0});
+}
+
+void AddressableLightDisplay::update() {
+  if (!this->enabled_)
+    return;
+
+  this->do_update_();
+  this->display();
+}
+
+void AddressableLightDisplay::display() {
+  bool dirty = false;
+  uint8_t old_r, old_g, old_b, old_w;
+  Color* c;
+
+  for (uint32_t offset = 0; offset < this->addressable_light_buffer_.size(); offset++) {
+    c = &(this->addressable_light_buffer_[offset]);
+
+    light::ESPColorView pixel = (*this->light_)[offset];
+
+    // Track the original values for the pixel view. If it has changed updating, then
+    // we trigger a redraw. Avoiding redraws == avoiding flicker!
+    old_r = pixel.get_red();
+    old_g = pixel.get_green();
+    old_b = pixel.get_blue();
+    old_w = pixel.get_white();
+
+    pixel.set_rgbw(c->r, c->g, c->b, c->w);
+
+    // If the actual value of the pixel changed, then schedule a redraw.
+    if (pixel.get_red() != old_r || pixel.get_green() != old_g || pixel.get_blue() != old_b ||
+        pixel.get_white() != old_w) {
+      dirty = true;
+    }
+  }
+
+  if (dirty) {
+    this->light_->schedule_show();
+  }
+}
+
+void HOT AddressableLightDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
+  if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0)
+    return;
+
+  if (this->pixel_mapper_f_.has_value()) {
+    // Params are passed by reference, so they may be modified in call.
+    this->addressable_light_buffer_[(*this->pixel_mapper_f_)(x, y)] = color;
+  } else {
+    this->addressable_light_buffer_[y * this->get_width_internal() + x] = color;
+  }
+}
+}  // namespace addressable_light
+}  // namespace esphome
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/color.h"
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/light/addressable_light.h"
+
+namespace esphome {
+namespace addressable_light {
+
+class AddressableLightDisplay : public display::DisplayBuffer, public PollingComponent {
+ public:
+  light::AddressableLight *get_light() const { return this->light_; }
+
+  void set_width(int32_t width) { width_ = width; }
+  void set_height(int32_t height) { height_ = height; }
+  void set_light(light::LightState *state) {
+    light_state_ = state;
+    light_ = static_cast<light::AddressableLight *>(state->get_output());
+  }
+  void set_enabled(bool enabled) {
+    if (light_state_) {
+      if (enabled_ && !enabled) {  // enabled -> disabled
+        // - Tell the parent light to refresh, effectively wiping the display. Also
+        //   restores the previous effect (if any).
+        light_state_->make_call().set_effect(this->last_effect_).perform();
+
+      } else if (!enabled_ && enabled) {  // disabled -> enabled
+        // - Save the current effect.
+        this->last_effect_ = light_state_->get_effect_name();
+        // - Disable any current effect.
+        light_state_->make_call().set_effect(0).perform();
+      }
+    }
+    enabled_ = enabled;
+  }
+  bool get_enabled() { return enabled_; }
+
+  void set_pixel_mapper(std::function<int(int, int)> &&pixel_mapper_f) { this->pixel_mapper_f_ = pixel_mapper_f; }
+  void setup() override;
+  void display();
+
+ protected:
+  int get_width_internal() override;
+  int get_height_internal() override;
+  void draw_absolute_pixel_internal(int x, int y, Color color) override;
+  void update() override;
+
+  light::LightState *light_state_;
+  light::AddressableLight *light_;
+  bool enabled_{true};
+  int32_t width_;
+  int32_t height_;
+  std::vector<Color> addressable_light_buffer_;
+  optional<std::string> last_effect_;
+  optional<std::function<int(int, int)>> pixel_mapper_f_;
+};
+}  // namespace addressable_light
+}  // namespace esphome
@@ -0,0 +1,63 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import display, light
+from esphome.const import (
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_PAGES,
+    CONF_ADDRESSABLE_LIGHT_ID,
+    CONF_HEIGHT,
+    CONF_WIDTH,
+    CONF_UPDATE_INTERVAL,
+    CONF_PIXEL_MAPPER,
+)
+
+CODEOWNERS = ["@justfalter"]
+
+addressable_light_ns = cg.esphome_ns.namespace("addressable_light")
+AddressableLightDisplay = addressable_light_ns.class_(
+    "AddressableLightDisplay", display.DisplayBuffer, cg.PollingComponent
+)
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(AddressableLightDisplay),
+            cv.Required(CONF_ADDRESSABLE_LIGHT_ID): cv.use_id(
+                light.AddressableLightState
+            ),
+            cv.Required(CONF_WIDTH): cv.positive_int,
+            cv.Required(CONF_HEIGHT): cv.positive_int,
+            cv.Optional(
+                CONF_UPDATE_INTERVAL, default="16ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_PIXEL_MAPPER): cv.returning_lambda,
+        }
+    ),
+    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
+)
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    wrapped_light = yield cg.get_variable(config[CONF_ADDRESSABLE_LIGHT_ID])
+    cg.add(var.set_width(config[CONF_WIDTH]))
+    cg.add(var.set_height(config[CONF_HEIGHT]))
+    cg.add(var.set_light(wrapped_light))
+
+    yield cg.register_component(var, config)
+    yield display.register_display(var, config)
+
+    if CONF_PIXEL_MAPPER in config:
+        pixel_mapper_template_ = yield cg.process_lambda(
+            config[CONF_PIXEL_MAPPER],
+            [(int, "x"), (int, "y")],
+            return_type=cg.int_,
+        )
+        cg.add(var.set_pixel_mapper(pixel_mapper_template_))
+
+    if CONF_LAMBDA in config:
+        lambda_ = yield cg.process_lambda(
+            config[CONF_LAMBDA], [(display.DisplayBufferRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))
@@ -2,29 +2,54 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, i2c
 from esphome import pins
-from esphome.const import CONF_ID, CONF_VOLTAGE, \
-    UNIT_VOLT, ICON_FLASH, UNIT_AMPERE, UNIT_WATT
+from esphome.const import (
+    CONF_ID,
+    CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+)

-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]

-ade7953_ns = cg.esphome_ns.namespace('ade7953')
-ADE7953 = ade7953_ns.class_('ADE7953', cg.PollingComponent, i2c.I2CDevice)
+ade7953_ns = cg.esphome_ns.namespace("ade7953")
+ADE7953 = ade7953_ns.class_("ADE7953", cg.PollingComponent, i2c.I2CDevice)

-CONF_IRQ_PIN = 'irq_pin'
-CONF_CURRENT_A = 'current_a'
-CONF_CURRENT_B = 'current_b'
-CONF_ACTIVE_POWER_A = 'active_power_a'
-CONF_ACTIVE_POWER_B = 'active_power_b'
+CONF_IRQ_PIN = "irq_pin"
+CONF_CURRENT_A = "current_a"
+CONF_CURRENT_B = "current_b"
+CONF_ACTIVE_POWER_A = "active_power_a"
+CONF_ACTIVE_POWER_B = "active_power_b"

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ADE7953),
-    cv.Optional(CONF_IRQ_PIN): pins.input_pin,
-    cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
-    cv.Optional(CONF_CURRENT_A): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
-    cv.Optional(CONF_CURRENT_B): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
-    cv.Optional(CONF_ACTIVE_POWER_A): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
-    cv.Optional(CONF_ACTIVE_POWER_B): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x38))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ADE7953),
+            cv.Optional(CONF_IRQ_PIN): pins.input_pin,
+            cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+                UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE
+            ),
+            cv.Optional(CONF_CURRENT_A): sensor.sensor_schema(
+                UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT
+            ),
+            cv.Optional(CONF_CURRENT_B): sensor.sensor_schema(
+                UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_A): sensor.sensor_schema(
+                UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_B): sensor.sensor_schema(
+                UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)


 def to_code(config):
@@ -35,10 +60,15 @@ def to_code(config):
    if CONF_IRQ_PIN in config:
        cg.add(var.set_irq_pin(config[CONF_IRQ_PIN]))

-    for key in [CONF_VOLTAGE, CONF_CURRENT_A, CONF_CURRENT_B, CONF_ACTIVE_POWER_A,
-                CONF_ACTIVE_POWER_B]:
+    for key in [
+        CONF_VOLTAGE,
+        CONF_CURRENT_A,
+        CONF_CURRENT_B,
+        CONF_ACTIVE_POWER_A,
+        CONF_ACTIVE_POWER_B,
+    ]:
        if key not in config:
            continue
        conf = config[key]
        sens = yield sensor.new_sensor(conf)
-        cg.add(getattr(var, f'set_{key}_sensor')(sens))
+        cg.add(getattr(var, f"set_{key}_sensor")(sens))
@@ -3,18 +3,24 @@ import esphome.config_validation as cv
 from esphome.components import i2c
 from esphome.const import CONF_ID

-DEPENDENCIES = ['i2c']
-AUTO_LOAD = ['sensor', 'voltage_sampler']
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensor", "voltage_sampler"]
 MULTI_CONF = True

-ads1115_ns = cg.esphome_ns.namespace('ads1115')
-ADS1115Component = ads1115_ns.class_('ADS1115Component', cg.Component, i2c.I2CDevice)
+ads1115_ns = cg.esphome_ns.namespace("ads1115")
+ADS1115Component = ads1115_ns.class_("ADS1115Component", cg.Component, i2c.I2CDevice)

-CONF_CONTINUOUS_MODE = 'continuous_mode'
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ADS1115Component),
-    cv.Optional(CONF_CONTINUOUS_MODE, default=False): cv.boolean,
-}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(None))
+CONF_CONTINUOUS_MODE = "continuous_mode"
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1115Component),
+            cv.Optional(CONF_CONTINUOUS_MODE, default=False): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(None))
+)


 def to_code(config):
@@ -1,53 +1,67 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, voltage_sampler
-from esphome.const import CONF_GAIN, CONF_MULTIPLEXER, ICON_FLASH, UNIT_VOLT, CONF_ID
+from esphome.const import (
+    CONF_GAIN,
+    CONF_MULTIPLEXER,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    UNIT_VOLT,
+    CONF_ID,
+)
 from . import ads1115_ns, ADS1115Component

-DEPENDENCIES = ['ads1115']
+DEPENDENCIES = ["ads1115"]

-ADS1115Multiplexer = ads1115_ns.enum('ADS1115Multiplexer')
+ADS1115Multiplexer = ads1115_ns.enum("ADS1115Multiplexer")
 MUX = {
-    'A0_A1': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
-    'A0_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
-    'A1_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
-    'A2_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
-    'A0_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
-    'A1_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
-    'A2_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
-    'A3_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
+    "A0_A1": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
+    "A0_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
+    "A1_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
+    "A2_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
+    "A0_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
+    "A1_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
+    "A2_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
+    "A3_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
 }

-ADS1115Gain = ads1115_ns.enum('ADS1115Gain')
+ADS1115Gain = ads1115_ns.enum("ADS1115Gain")
 GAIN = {
-    '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
-    '4.096': ADS1115Gain.ADS1115_GAIN_4P096,
-    '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
-    '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
-    '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
-    '0.256': ADS1115Gain.ADS1115_GAIN_0P256,
+    "6.144": ADS1115Gain.ADS1115_GAIN_6P144,
+    "4.096": ADS1115Gain.ADS1115_GAIN_4P096,
+    "2.048": ADS1115Gain.ADS1115_GAIN_2P048,
+    "1.024": ADS1115Gain.ADS1115_GAIN_1P024,
+    "0.512": ADS1115Gain.ADS1115_GAIN_0P512,
+    "0.256": ADS1115Gain.ADS1115_GAIN_0P256,
 }


 def validate_gain(value):
    if isinstance(value, float):
-        value = f'{value:0.03f}'
+        value = f"{value:0.03f}"
    elif not isinstance(value, str):
        raise cv.Invalid(f'invalid gain "{value}"')

    return cv.enum(GAIN)(value)


-ADS1115Sensor = ads1115_ns.class_('ADS1115Sensor', sensor.Sensor, cg.PollingComponent,
-                                  voltage_sampler.VoltageSampler)
+ADS1115Sensor = ads1115_ns.class_(
+    "ADS1115Sensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)

-CONF_ADS1115_ID = 'ads1115_id'
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 3).extend({
-    cv.GenerateID(): cv.declare_id(ADS1115Sensor),
-    cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
-    cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space='_'),
-    cv.Required(CONF_GAIN): validate_gain,
-}).extend(cv.polling_component_schema('60s'))
+CONF_ADS1115_ID = "ads1115_id"
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 3, DEVICE_CLASS_VOLTAGE)
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1115Sensor),
+            cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
+            cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space="_"),
+            cv.Required(CONF_GAIN): validate_gain,
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+)


 def to_code(config):
@@ -1,19 +1,37 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    ICON_EMPTY,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+)

-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]

-aht10_ns = cg.esphome_ns.namespace('aht10')
-AHT10Component = aht10_ns.class_('AHT10Component', cg.PollingComponent, i2c.I2CDevice)
+aht10_ns = cg.esphome_ns.namespace("aht10")
+AHT10Component = aht10_ns.class_("AHT10Component", cg.PollingComponent, i2c.I2CDevice)

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AHT10Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 2),
-    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 2),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x38))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AHT10Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                UNIT_CELSIUS, ICON_EMPTY, 2, DEVICE_CLASS_TEMPERATURE
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                UNIT_PERCENT, ICON_EMPTY, 2, DEVICE_CLASS_HUMIDITY
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)


 def to_code(config):
@@ -1,19 +1,39 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    UNIT_CELSIUS,
+    ICON_EMPTY,
+    UNIT_PERCENT,
+)

-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]

-am2320_ns = cg.esphome_ns.namespace('am2320')
-AM2320Component = am2320_ns.class_('AM2320Component', cg.PollingComponent, i2c.I2CDevice)
+am2320_ns = cg.esphome_ns.namespace("am2320")
+AM2320Component = am2320_ns.class_(
+    "AM2320Component", cg.PollingComponent, i2c.I2CDevice
+)

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AM2320Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
-    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x5C))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AM2320Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x5C))
+)


 def to_code(config):
@@ -10,24 +10,28 @@ from esphome.core import CORE, HexInt

 _LOGGER = logging.getLogger(__name__)

-DEPENDENCIES = ['display']
+DEPENDENCIES = ["display"]
 MULTI_CONF = True

-Animation_ = display.display_ns.class_('Animation')
+Animation_ = display.display_ns.class_("Animation")

-CONF_RAW_DATA_ID = 'raw_data_id'
+CONF_RAW_DATA_ID = "raw_data_id"

-ANIMATION_SCHEMA = cv.Schema({
-    cv.Required(CONF_ID): cv.declare_id(Animation_),
-    cv.Required(CONF_FILE): cv.file_,
-    cv.Optional(CONF_RESIZE): cv.dimensions,
-    cv.Optional(CONF_TYPE, default='BINARY'): cv.enum(espImage.IMAGE_TYPE, upper=True),
-    cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-})
+ANIMATION_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(Animation_),
+        cv.Required(CONF_FILE): cv.file_,
+        cv.Optional(CONF_RESIZE): cv.dimensions,
+        cv.Optional(CONF_TYPE, default="BINARY"): cv.enum(
+            espImage.IMAGE_TYPE, upper=True
+        ),
+        cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
+    }
+)

 CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, ANIMATION_SCHEMA)

-CODEOWNERS = ['@syndlex']
+CODEOWNERS = ["@syndlex"]


 def to_code(config):
@@ -46,26 +50,28 @@ def to_code(config):
        width, height = image.size
    else:
        if width > 500 or height > 500:
-            _LOGGER.warning("The image you requested is very big. Please consider using"
-                            " the resize parameter.")
+            _LOGGER.warning(
+                "The image you requested is very big. Please consider using"
+                " the resize parameter."
+            )

-    if config[CONF_TYPE] == 'GRAYSCALE':
+    if config[CONF_TYPE] == "GRAYSCALE":
        data = [0 for _ in range(height * width * frames)]
        pos = 0
        for frameIndex in range(frames):
            image.seek(frameIndex)
-            frame = image.convert('L', dither=Image.NONE)
+            frame = image.convert("L", dither=Image.NONE)
            pixels = list(frame.getdata())
            for pix in pixels:
                data[pos] = pix
                pos += 1

-    elif config[CONF_TYPE] == 'RGB24':
+    elif config[CONF_TYPE] == "RGB24":
        data = [0 for _ in range(height * width * 3 * frames)]
        pos = 0
        for frameIndex in range(frames):
            image.seek(frameIndex)
-            frame = image.convert('RGB')
+            frame = image.convert("RGB")
            pixels = list(frame.getdata())
            for pix in pixels:
                data[pos] = pix[0]
@@ -75,12 +81,12 @@ def to_code(config):
                data[pos] = pix[2]
                pos += 1

-    elif config[CONF_TYPE] == 'BINARY':
+    elif config[CONF_TYPE] == "BINARY":
        width8 = ((width + 7) // 8) * 8
        data = [0 for _ in range((height * width8 // 8) * frames)]
        for frameIndex in range(frames):
            image.seek(frameIndex)
-            frame = image.convert('1', dither=Image.NONE)
+            frame = image.convert("1", dither=Image.NONE)
            for y in range(height):
                for x in range(width):
                    if frame.getpixel((x, y)):
@@ -90,5 +96,11 @@ def to_code(config):

    rhs = [HexInt(x) for x in data]
    prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
-    cg.new_Pvariable(config[CONF_ID], prog_arr, width, height, frames,
-                     espImage.IMAGE_TYPE[config[CONF_TYPE]])
+    cg.new_Pvariable(
+        config[CONF_ID],
+        prog_arr,
+        width,
+        height,
+        frames,
+        espImage.IMAGE_TYPE[config[CONF_TYPE]],
+    )
@@ -3,18 +3,24 @@ import esphome.config_validation as cv
 from esphome.components import i2c
 from esphome.const import CONF_ID

-DEPENDENCIES = ['i2c']
-AUTO_LOAD = ['sensor', 'binary_sensor']
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensor", "binary_sensor"]
 MULTI_CONF = True

-CONF_APDS9960_ID = 'apds9960_id'
+CONF_APDS9960_ID = "apds9960_id"

-apds9960_nds = cg.esphome_ns.namespace('apds9960')
-APDS9960 = apds9960_nds.class_('APDS9960', cg.PollingComponent, i2c.I2CDevice)
+apds9960_nds = cg.esphome_ns.namespace("apds9960")
+APDS9960 = apds9960_nds.class_("APDS9960", cg.PollingComponent, i2c.I2CDevice)

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(APDS9960),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x39))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(APDS9960),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x39))
+)


 def to_code(config):
@@ -4,20 +4,24 @@ from esphome.components import binary_sensor
 from esphome.const import CONF_DIRECTION, CONF_DEVICE_CLASS, DEVICE_CLASS_MOVING
 from . import APDS9960, CONF_APDS9960_ID

-DEPENDENCIES = ['apds9960']
+DEPENDENCIES = ["apds9960"]

 DIRECTIONS = {
-    'UP': 'set_up_direction',
-    'DOWN': 'set_down_direction',
-    'LEFT': 'set_left_direction',
-    'RIGHT': 'set_right_direction',
+    "UP": "set_up_direction",
+    "DOWN": "set_down_direction",
+    "LEFT": "set_left_direction",
+    "RIGHT": "set_right_direction",
 }

-CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
-    cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
-    cv.Optional(CONF_DEVICE_CLASS, default=DEVICE_CLASS_MOVING): binary_sensor.device_class,
-})
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+        cv.Optional(
+            CONF_DEVICE_CLASS, default=DEVICE_CLASS_MOVING
+        ): binary_sensor.device_class,
+    }
+)


 def to_code(config):
@@ -1,23 +1,27 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor
-from esphome.const import CONF_TYPE, UNIT_PERCENT, ICON_LIGHTBULB
+from esphome.const import CONF_TYPE, DEVICE_CLASS_EMPTY, UNIT_PERCENT, ICON_LIGHTBULB
 from . import APDS9960, CONF_APDS9960_ID

-DEPENDENCIES = ['apds9960']
+DEPENDENCIES = ["apds9960"]

 TYPES = {
-    'CLEAR': 'set_clear_channel',
-    'RED': 'set_red_channel',
-    'GREEN': 'set_green_channel',
-    'BLUE': 'set_blue_channel',
-    'PROXIMITY': 'set_proximity',
+    "CLEAR": "set_clear_channel",
+    "RED": "set_red_channel",
+    "GREEN": "set_green_channel",
+    "BLUE": "set_blue_channel",
+    "PROXIMITY": "set_proximity",
 }

-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_PERCENT, ICON_LIGHTBULB, 1).extend({
-    cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
-    cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
-})
+CONFIG_SCHEMA = sensor.sensor_schema(
+    UNIT_PERCENT, ICON_LIGHTBULB, 1, DEVICE_CLASS_EMPTY
+).extend(
+    {
+        cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+    }
+)


 def to_code(config):
@@ -2,46 +2,69 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 from esphome.automation import Condition
-from esphome.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
-    CONF_REBOOT_TIMEOUT, CONF_SERVICE, CONF_VARIABLES, CONF_SERVICES, CONF_TRIGGER_ID, CONF_EVENT, \
-    CONF_TAG
+from esphome.const import (
+    CONF_DATA,
+    CONF_DATA_TEMPLATE,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_REBOOT_TIMEOUT,
+    CONF_SERVICE,
+    CONF_VARIABLES,
+    CONF_SERVICES,
+    CONF_TRIGGER_ID,
+    CONF_EVENT,
+    CONF_TAG,
+)
 from esphome.core import coroutine_with_priority

-DEPENDENCIES = ['network']
-AUTO_LOAD = ['async_tcp']
-CODEOWNERS = ['@OttoWinter']
+DEPENDENCIES = ["network"]
+AUTO_LOAD = ["async_tcp"]
+CODEOWNERS = ["@OttoWinter"]

-api_ns = cg.esphome_ns.namespace('api')
-APIServer = api_ns.class_('APIServer', cg.Component, cg.Controller)
-HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', automation.Action)
-APIConnectedCondition = api_ns.class_('APIConnectedCondition', Condition)
+api_ns = cg.esphome_ns.namespace("api")
+APIServer = api_ns.class_("APIServer", cg.Component, cg.Controller)
+HomeAssistantServiceCallAction = api_ns.class_(
+    "HomeAssistantServiceCallAction", automation.Action
+)
+APIConnectedCondition = api_ns.class_("APIConnectedCondition", Condition)

-UserServiceTrigger = api_ns.class_('UserServiceTrigger', automation.Trigger)
-ListEntitiesServicesArgument = api_ns.class_('ListEntitiesServicesArgument')
+UserServiceTrigger = api_ns.class_("UserServiceTrigger", automation.Trigger)
+ListEntitiesServicesArgument = api_ns.class_("ListEntitiesServicesArgument")
 SERVICE_ARG_NATIVE_TYPES = {
-    'bool': bool,
-    'int': cg.int32,
-    'float': float,
-    'string': cg.std_string,
-    'bool[]': cg.std_vector.template(bool),
-    'int[]': cg.std_vector.template(cg.int32),
-    'float[]': cg.std_vector.template(float),
-    'string[]': cg.std_vector.template(cg.std_string),
+    "bool": bool,
+    "int": cg.int32,
+    "float": float,
+    "string": cg.std_string,
+    "bool[]": cg.std_vector.template(bool),
+    "int[]": cg.std_vector.template(cg.int32),
+    "float[]": cg.std_vector.template(float),
+    "string[]": cg.std_vector.template(cg.std_string),
 }

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(APIServer),
-    cv.Optional(CONF_PORT, default=6053): cv.port,
-    cv.Optional(CONF_PASSWORD, default=''): cv.string_strict,
-    cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_SERVICES): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger),
-        cv.Required(CONF_SERVICE): cv.valid_name,
-        cv.Optional(CONF_VARIABLES, default={}): cv.Schema({
-            cv.validate_id_name: cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
-        }),
-    }),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(APIServer),
+        cv.Optional(CONF_PORT, default=6053): cv.port,
+        cv.Optional(CONF_PASSWORD, default=""): cv.string_strict,
+        cv.Optional(
+            CONF_REBOOT_TIMEOUT, default="15min"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_SERVICES): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger),
+                cv.Required(CONF_SERVICE): cv.valid_name,
+                cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+                    {
+                        cv.validate_id_name: cv.one_of(
+                            *SERVICE_ARG_NATIVE_TYPES, lower=True
+                        ),
+                    }
+                ),
+            }
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)


@coroutine_with_priority(40.0)
@@ -63,28 +86,36 @@ def to_code(config):
            func_args.append((native, name))
            service_arg_names.append(name)
        templ = cg.TemplateArguments(*template_args)
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], templ,
-                                   conf[CONF_SERVICE], service_arg_names)
+        trigger = cg.new_Pvariable(
+            conf[CONF_TRIGGER_ID], templ, conf[CONF_SERVICE], service_arg_names
+        )
        cg.add(var.register_user_service(trigger))
        yield automation.build_automation(trigger, func_args, conf)

-    cg.add_define('USE_API')
+    cg.add_define("USE_API")
    cg.add_global(api_ns.using)


 KEY_VALUE_SCHEMA = cv.Schema({cv.string: cv.templatable(cv.string_strict)})

-HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_SERVICE): cv.templatable(cv.string),
-    cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_VARIABLES, default={}): cv.Schema({cv.string: cv.returning_lambda}),
-})
+HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_SERVICE): cv.templatable(cv.string),
+        cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+            {cv.string: cv.returning_lambda}
+        ),
+    }
+)


-@automation.register_action('homeassistant.service', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_SERVICE_ACTION_SCHEMA)
+@automation.register_action(
+    "homeassistant.service",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_SERVICE_ACTION_SCHEMA,
+)
 def homeassistant_service_to_code(config, action_id, template_arg, args):
    serv = yield cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, serv, False)
@@ -104,23 +135,30 @@ def homeassistant_service_to_code(config, action_id, template_arg, args):

 def validate_homeassistant_event(value):
    value = cv.string(value)
-    if not value.startswith('esphome.'):
-        raise cv.Invalid("ESPHome can only generate Home Assistant events that begin with "
-                         "esphome. For example 'esphome.xyz'")
+    if not value.startswith("esphome."):
+        raise cv.Invalid(
+            "ESPHome can only generate Home Assistant events that begin with "
+            "esphome. For example 'esphome.xyz'"
+        )
    return value


-HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_EVENT): validate_homeassistant_event,
-    cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_VARIABLES, default={}): KEY_VALUE_SCHEMA,
-})
+HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_EVENT): validate_homeassistant_event,
+        cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_VARIABLES, default={}): KEY_VALUE_SCHEMA,
+    }
+)


-@automation.register_action('homeassistant.event', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_EVENT_ACTION_SCHEMA)
+@automation.register_action(
+    "homeassistant.event",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_EVENT_ACTION_SCHEMA,
+)
 def homeassistant_event_to_code(config, action_id, template_arg, args):
    serv = yield cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, serv, True)
@@ -138,23 +176,29 @@ def homeassistant_event_to_code(config, action_id, template_arg, args):
    yield var


-HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
-}, key=CONF_TAG)
+HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
+    },
+    key=CONF_TAG,
+)


-@automation.register_action('homeassistant.tag_scanned', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA)
+@automation.register_action(
+    "homeassistant.tag_scanned",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA,
+)
 def homeassistant_tag_scanned_to_code(config, action_id, template_arg, args):
    serv = yield cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    cg.add(var.set_service('esphome.tag_scanned'))
+    cg.add(var.set_service("esphome.tag_scanned"))
    templ = yield cg.templatable(config[CONF_TAG], args, cg.std_string)
-    cg.add(var.add_data('tag_id', templ))
+    cg.add(var.add_data("tag_id", templ))
    yield var


-@automation.register_condition('api.connected', APIConnectedCondition, {})
+@automation.register_condition("api.connected", APIConnectedCondition, {})
 def api_connected_to_code(config, condition_id, template_arg, args):
    yield cg.new_Pvariable(condition_id, template_arg)
@@ -46,6 +46,7 @@ service APIConnection {
 // The Home Assistant protocol is structured as a simple
 // TCP socket with short binary messages encoded in the protocol buffers format
 // First, a message in this protocol has a specific format:
+//  * A zero byte.
 //  * VarInt denoting the size of the message object. (type is not part of this)
 //  * VarInt denoting the type of message.
 //  * The message object encoded as a ProtoBuf message
@@ -302,6 +303,7 @@ message ListEntitiesFanResponse {
  bool supports_oscillation = 5;
  bool supports_speed = 6;
  bool supports_direction = 7;
+  int32 supported_speed_count = 8;
 }
 enum FanSpeed {
  FAN_SPEED_LOW = 0;
@@ -321,8 +323,9 @@ message FanStateResponse {
  fixed32 key = 1;
  bool state = 2;
  bool oscillating = 3;
-  FanSpeed speed = 4;
+  FanSpeed speed = 4 [deprecated = true];
  FanDirection direction = 5;
+  int32 speed_level = 6;
 }
 message FanCommandRequest {
  option (id) = 31;
@@ -333,12 +336,14 @@ message FanCommandRequest {
  fixed32 key = 1;
  bool has_state = 2;
  bool state = 3;
-  bool has_speed = 4;
-  FanSpeed speed = 5;
+  bool has_speed = 4 [deprecated = true];
+  FanSpeed speed = 5 [deprecated = true];
  bool has_oscillating = 6;
  bool oscillating = 7;
  bool has_direction = 8;
  FanDirection direction = 9;
+  bool has_speed_level = 10;
+  int32 speed_level = 11;
 }

 // ==================== LIGHT ====================
@@ -418,6 +423,7 @@ message ListEntitiesSensorResponse {
  string unit_of_measurement = 6;
  int32 accuracy_decimals = 7;
  bool force_update = 8;
+  string device_class = 9;
 }
 message SensorStateResponse {
  option (id) = 25;
@@ -9,6 +9,9 @@
 #ifdef USE_HOMEASSISTANT_TIME
 #include "esphome/components/homeassistant/time/homeassistant_time.h"
 #endif
+#ifdef USE_FAN
+#include "esphome/components/fan/fan_helpers.h"
+#endif

 namespace esphome {
 namespace api {
@@ -246,8 +249,10 @@ bool APIConnection::send_fan_state(fan::FanState *fan) {
  resp.state = fan->state;
  if (traits.supports_oscillation())
    resp.oscillating = fan->oscillating;
-  if (traits.supports_speed())
-    resp.speed = static_cast<enums::FanSpeed>(fan->speed);
+  if (traits.supports_speed()) {
+    resp.speed_level = fan->speed;
+    resp.speed = static_cast<enums::FanSpeed>(fan::speed_level_to_enum(fan->speed, traits.supported_speed_count()));
+  }
  if (traits.supports_direction())
    resp.direction = static_cast<enums::FanDirection>(fan->direction);
  return this->send_fan_state_response(resp);
@@ -262,6 +267,7 @@ bool APIConnection::send_fan_info(fan::FanState *fan) {
  msg.supports_oscillation = traits.supports_oscillation();
  msg.supports_speed = traits.supports_speed();
  msg.supports_direction = traits.supports_direction();
+  msg.supported_speed_count = traits.supported_speed_count();
  return this->send_list_entities_fan_response(msg);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
@@ -269,13 +275,19 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
  if (fan == nullptr)
    return;

+  auto traits = fan->get_traits();
+
  auto call = fan->make_call();
  if (msg.has_state)
    call.set_state(msg.state);
  if (msg.has_oscillating)
    call.set_oscillating(msg.oscillating);
-  if (msg.has_speed)
-    call.set_speed(static_cast<fan::FanSpeed>(msg.speed));
+  if (msg.has_speed_level) {
+    // Prefer level
+    call.set_speed(msg.speed_level);
+  } else if (msg.has_speed) {
+    call.set_speed(fan::speed_enum_to_level(static_cast<fan::FanSpeed>(msg.speed), traits.supported_speed_count()));
+  }
  if (msg.has_direction)
    call.set_direction(static_cast<fan::FanDirection>(msg.direction));
  call.perform();
@@ -382,6 +394,7 @@ bool APIConnection::send_sensor_info(sensor::Sensor *sensor) {
  msg.unit_of_measurement = sensor->get_unit_of_measurement();
  msg.accuracy_decimals = sensor->get_accuracy_decimals();
  msg.force_update = sensor->get_force_update();
+  msg.device_class = sensor->get_device_class();
  return this->send_list_entities_sensor_response(msg);
 }
 #endif
@@ -589,7 +602,7 @@ HelloResponse APIConnection::hello(const HelloRequest &msg) {

  HelloResponse resp;
  resp.api_version_major = 1;
-  resp.api_version_minor = 3;
+  resp.api_version_minor = 4;
  resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
  this->connection_state_ = ConnectionState::CONNECTED;
  return resp;
@@ -774,6 +774,10 @@ bool ListEntitiesFanResponse::decode_varint(uint32_t field_id, ProtoVarInt value
      this->supports_direction = value.as_bool();
      return true;
    }
+    case 8: {
+      this->supported_speed_count = value.as_int32();
+      return true;
+    }
    default:
      return false;
  }
@@ -814,6 +818,7 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
  buffer.encode_bool(5, this->supports_oscillation);
  buffer.encode_bool(6, this->supports_speed);
  buffer.encode_bool(7, this->supports_direction);
+  buffer.encode_int32(8, this->supported_speed_count);
 }
 void ListEntitiesFanResponse::dump_to(std::string &out) const {
  char buffer[64];
@@ -846,6 +851,11 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
  out.append("  supports_direction: ");
  out.append(YESNO(this->supports_direction));
  out.append("\n");
+
+  out.append("  supported_speed_count: ");
+  sprintf(buffer, "%d", this->supported_speed_count);
+  out.append(buffer);
+  out.append("\n");
  out.append("}");
 }
 bool FanStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -866,6 +876,10 @@ bool FanStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
      this->direction = value.as_enum<enums::FanDirection>();
      return true;
    }
+    case 6: {
+      this->speed_level = value.as_int32();
+      return true;
+    }
    default:
      return false;
  }
@@ -886,6 +900,7 @@ void FanStateResponse::encode(ProtoWriteBuffer buffer) const {
  buffer.encode_bool(3, this->oscillating);
  buffer.encode_enum<enums::FanSpeed>(4, this->speed);
  buffer.encode_enum<enums::FanDirection>(5, this->direction);
+  buffer.encode_int32(6, this->speed_level);
 }
 void FanStateResponse::dump_to(std::string &out) const {
  char buffer[64];
@@ -910,6 +925,11 @@ void FanStateResponse::dump_to(std::string &out) const {
  out.append("  direction: ");
  out.append(proto_enum_to_string<enums::FanDirection>(this->direction));
  out.append("\n");
+
+  out.append("  speed_level: ");
+  sprintf(buffer, "%d", this->speed_level);
+  out.append(buffer);
+  out.append("\n");
  out.append("}");
 }
 bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -946,6 +966,14 @@ bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
      this->direction = value.as_enum<enums::FanDirection>();
      return true;
    }
+    case 10: {
+      this->has_speed_level = value.as_bool();
+      return true;
+    }
+    case 11: {
+      this->speed_level = value.as_int32();
+      return true;
+    }
    default:
      return false;
  }
@@ -970,6 +998,8 @@ void FanCommandRequest::encode(ProtoWriteBuffer buffer) const {
  buffer.encode_bool(7, this->oscillating);
  buffer.encode_bool(8, this->has_direction);
  buffer.encode_enum<enums::FanDirection>(9, this->direction);
+  buffer.encode_bool(10, this->has_speed_level);
+  buffer.encode_int32(11, this->speed_level);
 }
 void FanCommandRequest::dump_to(std::string &out) const {
  char buffer[64];
@@ -1010,6 +1040,15 @@ void FanCommandRequest::dump_to(std::string &out) const {
  out.append("  direction: ");
  out.append(proto_enum_to_string<enums::FanDirection>(this->direction));
  out.append("\n");
+
+  out.append("  has_speed_level: ");
+  out.append(YESNO(this->has_speed_level));
+  out.append("\n");
+
+  out.append("  speed_level: ");
+  sprintf(buffer, "%d", this->speed_level);
+  out.append(buffer);
+  out.append("\n");
  out.append("}");
 }
 bool ListEntitiesLightResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -1494,6 +1533,10 @@ bool ListEntitiesSensorResponse::decode_length(uint32_t field_id, ProtoLengthDel
      this->unit_of_measurement = value.as_string();
      return true;
    }
+    case 9: {
+      this->device_class = value.as_string();
+      return true;
+    }
    default:
      return false;
  }
@@ -1517,6 +1560,7 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
  buffer.encode_string(6, this->unit_of_measurement);
  buffer.encode_int32(7, this->accuracy_decimals);
  buffer.encode_bool(8, this->force_update);
+  buffer.encode_string(9, this->device_class);
 }
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
  char buffer[64];
@@ -1554,6 +1598,10 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
  out.append("  force_update: ");
  out.append(YESNO(this->force_update));
  out.append("\n");
+
+  out.append("  device_class: ");
+  out.append("'").append(this->device_class).append("'");
+  out.append("\n");
  out.append("}");
 }
 bool SensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -284,6 +284,7 @@ class ListEntitiesFanResponse : public ProtoMessage {
  bool supports_oscillation{false};  // NOLINT
  bool supports_speed{false};        // NOLINT
  bool supports_direction{false};    // NOLINT
+  int32_t supported_speed_count{0};  // NOLINT
  void encode(ProtoWriteBuffer buffer) const override;
  void dump_to(std::string &out) const override;

@@ -299,6 +300,7 @@ class FanStateResponse : public ProtoMessage {
  bool oscillating{false};          // NOLINT
  enums::FanSpeed speed{};          // NOLINT
  enums::FanDirection direction{};  // NOLINT
+  int32_t speed_level{0};           // NOLINT
  void encode(ProtoWriteBuffer buffer) const override;
  void dump_to(std::string &out) const override;

@@ -317,6 +319,8 @@ class FanCommandRequest : public ProtoMessage {
  bool oscillating{false};          // NOLINT
  bool has_direction{false};        // NOLINT
  enums::FanDirection direction{};  // NOLINT
+  bool has_speed_level{false};      // NOLINT
+  int32_t speed_level{0};           // NOLINT
  void encode(ProtoWriteBuffer buffer) const override;
  void dump_to(std::string &out) const override;

@@ -403,6 +407,7 @@ class ListEntitiesSensorResponse : public ProtoMessage {
  std::string unit_of_measurement{};  // NOLINT
  int32_t accuracy_decimals{0};       // NOLINT
  bool force_update{false};           // NOLINT
+  std::string device_class{};         // NOLINT
  void encode(ProtoWriteBuffer buffer) const override;
  void dump_to(std::string &out) const override;

@@ -1,33 +1,43 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.const import CONF_INDOOR, CONF_WATCHDOG_THRESHOLD, \
-    CONF_NOISE_LEVEL, CONF_SPIKE_REJECTION, CONF_LIGHTNING_THRESHOLD, \
-    CONF_MASK_DISTURBER, CONF_DIV_RATIO, CONF_CAPACITANCE
+from esphome.const import (
+    CONF_INDOOR,
+    CONF_WATCHDOG_THRESHOLD,
+    CONF_NOISE_LEVEL,
+    CONF_SPIKE_REJECTION,
+    CONF_LIGHTNING_THRESHOLD,
+    CONF_MASK_DISTURBER,
+    CONF_DIV_RATIO,
+    CONF_CAPACITANCE,
+)
 from esphome.core import coroutine

-AUTO_LOAD = ['sensor', 'binary_sensor']
+AUTO_LOAD = ["sensor", "binary_sensor"]
 MULTI_CONF = True

-CONF_AS3935_ID = 'as3935_id'
+CONF_AS3935_ID = "as3935_id"

-as3935_ns = cg.esphome_ns.namespace('as3935')
-AS3935 = as3935_ns.class_('AS3935Component', cg.Component)
+as3935_ns = cg.esphome_ns.namespace("as3935")
+AS3935 = as3935_ns.class_("AS3935Component", cg.Component)

-CONF_IRQ_PIN = 'irq_pin'
-AS3935_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AS3935),
-    cv.Required(CONF_IRQ_PIN): pins.gpio_input_pin_schema,
-
-    cv.Optional(CONF_INDOOR, default=True): cv.boolean,
-    cv.Optional(CONF_NOISE_LEVEL, default=2): cv.int_range(min=1, max=7),
-    cv.Optional(CONF_WATCHDOG_THRESHOLD, default=2): cv.int_range(min=1, max=10),
-    cv.Optional(CONF_SPIKE_REJECTION, default=2): cv.int_range(min=1, max=11),
-    cv.Optional(CONF_LIGHTNING_THRESHOLD, default=1): cv.one_of(1, 5, 9, 16, int=True),
-    cv.Optional(CONF_MASK_DISTURBER, default=False): cv.boolean,
-    cv.Optional(CONF_DIV_RATIO, default=0): cv.one_of(0, 16, 32, 64, 128, int=True),
-    cv.Optional(CONF_CAPACITANCE, default=0): cv.int_range(min=0, max=15),
-})
+CONF_IRQ_PIN = "irq_pin"
+AS3935_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(AS3935),
+        cv.Required(CONF_IRQ_PIN): pins.gpio_input_pin_schema,
+        cv.Optional(CONF_INDOOR, default=True): cv.boolean,
+        cv.Optional(CONF_NOISE_LEVEL, default=2): cv.int_range(min=1, max=7),
+        cv.Optional(CONF_WATCHDOG_THRESHOLD, default=2): cv.int_range(min=1, max=10),
+        cv.Optional(CONF_SPIKE_REJECTION, default=2): cv.int_range(min=1, max=11),
+        cv.Optional(CONF_LIGHTNING_THRESHOLD, default=1): cv.one_of(
+            1, 5, 9, 16, int=True
+        ),
+        cv.Optional(CONF_MASK_DISTURBER, default=False): cv.boolean,
+        cv.Optional(CONF_DIV_RATIO, default=0): cv.one_of(0, 16, 32, 64, 128, int=True),
+        cv.Optional(CONF_CAPACITANCE, default=0): cv.int_range(min=0, max=15),
+    }
+)


@coroutine
@@ -3,11 +3,13 @@ import esphome.config_validation as cv
 from esphome.components import binary_sensor
 from . import AS3935, CONF_AS3935_ID

-DEPENDENCIES = ['as3935']
+DEPENDENCIES = ["as3935"]

-CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
-})
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
+    }
+)


 def to_code(config):
@@ -1,19 +1,30 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor
-from esphome.const import CONF_DISTANCE, CONF_LIGHTNING_ENERGY, \
-    UNIT_KILOMETER, UNIT_EMPTY, ICON_SIGNAL_DISTANCE_VARIANT, ICON_FLASH
+from esphome.const import (
+    CONF_DISTANCE,
+    CONF_LIGHTNING_ENERGY,
+    DEVICE_CLASS_EMPTY,
+    UNIT_KILOMETER,
+    UNIT_EMPTY,
+    ICON_SIGNAL_DISTANCE_VARIANT,
+    ICON_FLASH,
+)
 from . import AS3935, CONF_AS3935_ID

-DEPENDENCIES = ['as3935']
+DEPENDENCIES = ["as3935"]

-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
-    cv.Optional(CONF_DISTANCE):
-        sensor.sensor_schema(UNIT_KILOMETER, ICON_SIGNAL_DISTANCE_VARIANT, 1),
-    cv.Optional(CONF_LIGHTNING_ENERGY):
-        sensor.sensor_schema(UNIT_EMPTY, ICON_FLASH, 1),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
+        cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
+            UNIT_KILOMETER, ICON_SIGNAL_DISTANCE_VARIANT, 1, DEVICE_CLASS_EMPTY
+        ),
+        cv.Optional(CONF_LIGHTNING_ENERGY): sensor.sensor_schema(
+            UNIT_EMPTY, ICON_FLASH, 1, DEVICE_CLASS_EMPTY
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)


 def to_code(config):
@@ -3,15 +3,21 @@ import esphome.config_validation as cv
 from esphome.components import as3935, i2c
 from esphome.const import CONF_ID

-AUTO_LOAD = ['as3935']
-DEPENDENCIES = ['i2c']
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["i2c"]

-as3935_i2c_ns = cg.esphome_ns.namespace('as3935_i2c')
-I2CAS3935 = as3935_i2c_ns.class_('I2CAS3935Component', as3935.AS3935, i2c.I2CDevice)
+as3935_i2c_ns = cg.esphome_ns.namespace("as3935_i2c")
+I2CAS3935 = as3935_i2c_ns.class_("I2CAS3935Component", as3935.AS3935, i2c.I2CDevice)

-CONFIG_SCHEMA = cv.All(as3935.AS3935_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(I2CAS3935),
-}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x03)))
+CONFIG_SCHEMA = cv.All(
+    as3935.AS3935_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(I2CAS3935),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x03))
+)


 def to_code(config):
@@ -3,15 +3,21 @@ import esphome.config_validation as cv
 from esphome.components import as3935, spi
 from esphome.const import CONF_ID

-AUTO_LOAD = ['as3935']
-DEPENDENCIES = ['spi']
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["spi"]

-as3935_spi_ns = cg.esphome_ns.namespace('as3935_spi')
-SPIAS3935 = as3935_spi_ns.class_('SPIAS3935Component', as3935.AS3935, spi.SPIDevice)
+as3935_spi_ns = cg.esphome_ns.namespace("as3935_spi")
+SPIAS3935 = as3935_spi_ns.class_("SPIAS3935Component", as3935.AS3935, spi.SPIDevice)

-CONFIG_SCHEMA = cv.All(as3935.AS3935_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(SPIAS3935),
-}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema(cs_pin_required=True)))
+CONFIG_SCHEMA = cv.All(
+    as3935.AS3935_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(SPIAS3935),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(spi.spi_device_schema(cs_pin_required=True))
+)


 def to_code(config):
--- a/Show More
+++ b/Show More