Bump version to v1.12.0

* Update Hassio base image to 1.4.1

* Fix rotary encoder typo

Fixes https://github.com/esphome/issues/issues/136

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,47 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-
----
-
-<!-- Thanks for reporting a bug for this project. READ THIS FIRST:
-- Please make sure to submit issues in the right GitHub repository, if unsure just post it here:
-  - esphomeyaml [here] - This is mostly for reporting bugs when compiling and when you get a long stack trace while compiling or if a configuration fails to validate.
-  - esphomelib [https://github.com/OttoWinter/esphomelib] - Report bugs there if the ESP is crashing or a feature is not working as expected.
-  - esphomedocs [https://github.com/OttoWinter/esphomedocs] - Report bugs there if the documentation is wrong/outdated.
-- Provide as many details as possible. Paste logs, configuration sample and code into the backticks (```). Do not delete any text from this template!
--->
-
-**Operating environment (Hass.io/Docker/pip/etc.):**
-<!--
-Please provide details about your environment.
--->
-
-**ESP (ESP32/ESP8266/Board/Sonoff):**
-<!--
-Please provide details about which ESP you're using.
--->
-
-**Affected component:**
-<!--
-Please add the link to the documentation at https://esphomelib.com/esphomeyaml/index.html of the component in question.
--->
-
-
-**Description of problem:**
-
-
-**Problem-relevant YAML-configuration entries:**
-```yaml
-
-```
-
-**Traceback (if applicable):**
-<!--
-Please copy the traceback here if compilation is failing. If possible, also connect to the ESP and copy its logs into the backticks.
--->
-```
-
-```
-
-**Additional information:**

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,22 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-
----
-
-<!-- READ THIS FIRST:
- - This is for feature requests only, if you want to have a certain new sensor/module supported, please use the "new integration" template.
- - Please be as descriptive as possible, especially use-cases that can otherwise not be solved boost the problem's priority.
--->
-
-**Is your feature request related to a problem? Please describe.**
-<!-- 
-A clear and concise description of what the problem is. 
--->
-Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A description of what you want to happen.
-
-**Additional context**
-Add any other context about the feature request here.

.github/ISSUE_TEMPLATE/new-integration.md

@@ -1,20 +0,0 @@
----
-name: New integration
-about: Suggest a new integration for esphomelib
-
----
-
-<!-- READ THIS FIRST:
- - This is for new integrations (such as new sensors/modules) only, for new features within the environment please use the "feature request" template.
- - Do not delete anything from this template and fill out the form as precisely as possible.
--->
-
-**What new integration would you wish to have?**
-<!-- A name/description of the new integration/board. -->
-
-**If possible, provide a link to an existing library for the integration:**
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Additional context**

.github/PULL_REQUEST_TEMPLATE.md

@@ -3,18 +3,12 @@
 
 **Related issue (if applicable):** fixes <link to issue>
 
-**Pull request in [esphomedocs](https://github.com/OttoWinter/esphomedocs) with documentation (if applicable):** OttoWinter/esphomedocs#<esphomedocs PR number goes here>
-**Pull request in [esphomelib](https://github.com/OttoWinter/esphomelib) with C++ framework changes (if applicable):** OttoWinter/esphomelib#<esphomelib PR number goes here>
-
-## Example entry for YAML configuration (if applicable):
-```yaml
-
-```
+**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>
+**Pull request in [esphome-core](https://github.com/esphome/esphome-core) with C++ framework changes (if applicable):** esphome/esphome-core#<esphome-core PR number goes here>
 
 ## Checklist:
   - [ ] The code change is tested and works locally.
   - [ ] Tests have been added to verify that the new code works (under `tests/` folder).
-  - [ ] Check this box if you have read, understand, comply, and agree with the [Code of Conduct](https://github.com/OttoWinter/esphomeyaml/blob/master/CODE_OF_CONDUCT.md).
 
 If user exposed functionality or configuration variables are added/changed:
   - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).

.github/issue-close-app.yml

@@ -0,0 +1,7 @@
+comment: >-
+  https://github.com/esphome/esphome/issues/430
+issueConfigs:
+- content:
+  - "OTHERWISE THE ISSUE WILL BE CLOSED AUTOMATICALLY"
+
+caseInsensitive: false

.gitignore

@@ -105,3 +105,4 @@ venv.bak/
 
 config/
 tests/build/
+tests/.esphome/

.gitlab-ci.yml

@@ -2,308 +2,134 @@
 # Based on https://gitlab.com/hassio-addons/addon-node-red/blob/master/.gitlab-ci.yml
 variables:
   DOCKER_DRIVER: overlay2
+  DOCKER_HOST: tcp://docker:2375/
 
 stages:
   - lint
   - test
-  - build
   - deploy
 
 .lint: &lint
+  image: esphome/esphome-base-amd64
   stage: lint
+  before_script:
+    - pip install -e .
+    - pip install flake8==3.6.0 pylint==1.9.4 pillow
   tags:
-    - python2.7
-    - esphomeyaml-lint
+    - docker
 
 .test: &test
+  image: esphome/esphome-base-amd64
   stage: test
   before_script:
     - pip install -e .
   tags:
-    - python2.7
-    - esphomeyaml-test
+    - docker
   variables:
     TZ: UTC
-  cache:
-    paths:
-      - tests/build
 
-.docker-builder: &docker-builder
+.docker-base: &docker-base
+  image: esphome/esphome-base-builder
   before_script:
     - docker info
-    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
+    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
+  script:
+    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
+    - TAG="${CI_COMMIT_TAG#v}"
+    - TAG="${TAG:-${CI_COMMIT_SHA:0:7}}"
+    - echo "Tag ${TAG}"
+
+    - |
+      if [[ "${IS_HASSIO}" == "YES" ]]; then
+        BUILD_FROM=esphome/esphome-hassio-base-${BUILD_ARCH}:1.4.1
+        BUILD_TO=esphome/esphome-hassio-${BUILD_ARCH}
+        DOCKERFILE=docker/Dockerfile.hassio
+      else
+        BUILD_FROM=esphome/esphome-base-${BUILD_ARCH}:1.4.1
+        if [[ "${BUILD_ARCH}" == "amd64" ]]; then
+          BUILD_TO=esphome/esphome
+        else
+          BUILD_TO=esphome/esphome-${BUILD_ARCH}
+        fi
+        DOCKERFILE=docker/Dockerfile
+      fi
+
+    - |
+      docker build \
+        --build-arg "BUILD_FROM=${BUILD_FROM}" \
+        --build-arg "BUILD_VERSION=${TAG}" \
+        --tag "${BUILD_TO}:${TAG}" \
+        --file "${DOCKERFILE}" \
+        .
+    - |
+      if [[ "${RELEASE}" = "YES" ]]; then
+        echo "Pushing to ${BUILD_TO}:${TAG}"
+        docker push "${BUILD_TO}:${TAG}"
+      fi
+    - |
+      if [[ "${LATEST}" = "YES" ]]; then
+        echo "Pushing to :latest"
+        docker tag ${BUILD_TO}:${TAG} ${BUILD_TO}:latest
+        docker push ${BUILD_TO}:latest
+      fi
+    - |
+      if [[ "${BETA}" = "YES" ]]; then
+        echo "Pushing to :beta"
+        docker tag \
+          ${BUILD_TO}:${TAG} \
+          ${BUILD_TO}:beta
+        docker push ${BUILD_TO}:beta
+      fi
+    - |
+      if [[ "${DEV}" = "YES" ]]; then
+        echo "Pushing to :dev"
+        docker tag \
+          ${BUILD_TO}:${TAG} \
+          ${BUILD_TO}:dev
+        docker push ${BUILD_TO}:dev
+      fi
   services:
     - docker:dind
   tags:
-    - hassio-builder
+    - docker
+  stage: deploy
 
 flake8:
   <<: *lint
   script:
-    - flake8 esphomeyaml
+    - flake8 esphome
 
 pylint:
   <<: *lint
   script:
-    - pylint esphomeyaml
+    - pylint esphome
 
 test1:
   <<: *test
   script:
-    - esphomeyaml tests/test1.yaml compile
+    - esphome tests/test1.yaml compile
 
 test2:
   <<: *test
   script:
-    - esphomeyaml tests/test2.yaml compile
+    - esphome tests/test2.yaml compile
 
-.build-hassio: &build-hassio
-  <<: *docker-builder
-  stage: build
+test3:
+  <<: *test
   script:
-    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
-    - BUILD_FROM=homeassistant/${ADDON_ARCH}-base-ubuntu:latest
-    - ADDON_VERSION="${CI_COMMIT_TAG#v}"
-    - ADDON_VERSION="${ADDON_VERSION:-${CI_COMMIT_SHA:0:7}}"
-    - ESPHOMELIB_VERSION="${ESPHOMELIB_VERSION:-dev}"
-    - echo "Build from ${BUILD_FROM}"
-    - echo "Add-on version ${ADDON_VERSION}"
-    - echo "Esphomelib version ${ESPHOMELIB_VERSION}"
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev"
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
-    - |
-      docker build \
-        --build-arg "BUILD_FROM=${BUILD_FROM}" \
-        --build-arg "ADDON_ARCH=${ADDON_ARCH}" \
-        --build-arg "ADDON_VERSION=${ADDON_VERSION}" \
-        --build-arg "ESPHOMELIB_VERSION=${ESPHOMELIB_VERSION}" \
-        --tag "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev" \
-        --tag "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        --file "docker/Dockerfile.hassio" \
-        .
-    - |
-      if [ "${DO_PUSH:-true}" = true ]; then
-        echo "Pushing to CI registry"
-        docker push ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}
-        docker push ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:dev
-      fi
-
-# Generic deploy template
-.deploy-release: &deploy-release
-  <<: *docker-builder
-  stage: deploy
-  script:
-    - version="${CI_COMMIT_TAG#v}"
-    - echo "Publishing release version ${version}"
-    - docker pull "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
-    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
-
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-  only:
-  - /^v\d+\.\d+\.\d+$/
-  except:
-  - /^(?!master).+@/
-
-.deploy-beta: &deploy-beta
-  <<: *docker-builder
-  stage: deploy
-  script:
-    - version="${CI_COMMIT_TAG#v}"
-    - echo "Publishing beta version ${version}"
-    - docker pull "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
-    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
-
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-  only:
-  - /^v\d+\.\d+\.\d+b\d+$/
-  except:
-  - /^(?!rc).+@/
-
-# Build jobs
-build:normal:
-  <<: *docker-builder
-  stage: build
-  script:
-    - docker build -t "${CI_REGISTRY}/esphomeyaml:dev" .
-
-.build-hassio-edge: &build-hassio-edge
-  <<: *build-hassio
-  except:
-    - /^v\d+\.\d+\.\d+$/
-    - /^v\d+\.\d+\.\d+b\d+$/
-
-.build-hassio-release: &build-hassio-release
-  <<: *build-hassio
-  only:
-    - /^v\d+\.\d+\.\d+$/
-    - /^v\d+\.\d+\.\d+b\d+$/
-
-build:hassio-armhf-edge:
-  <<: *build-hassio-edge
-  variables:
-    ADDON_ARCH: armhf
-    DO_PUSH: "false"
-
-build:hassio-armhf:
-  <<: *build-hassio-release
-  variables:
-    ADDON_ARCH: armhf
-    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
-
-#build:hassio-aarch64-edge:
-#  <<: *build-hassio-edge
-#  variables:
-#    ADDON_ARCH: aarch64
-#    DO_PUSH: "false"
-
-#build:hassio-aarch64:
-#  <<: *build-hassio-release
-#  variables:
-#    ADDON_ARCH: aarch64
-#    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
-
-build:hassio-i386-edge:
-  <<: *build-hassio-edge
-  variables:
-    ADDON_ARCH: i386
-    DO_PUSH: "false"
-
-build:hassio-i386:
-  <<: *build-hassio-release
-  variables:
-    ADDON_ARCH: i386
-    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
-
-build:hassio-amd64-edge:
-  <<: *build-hassio-edge
-  variables:
-    ADDON_ARCH: amd64
-    DO_PUSH: "false"
-
-build:hassio-amd64:
-  <<: *build-hassio-release
-  variables:
-    ADDON_ARCH: amd64
-    ESPHOMELIB_VERSION: "${CI_COMMIT_TAG}"
-
-# Deploy jobs
-deploy-release:armhf:
-  <<: *deploy-release
-  variables:
-    ADDON_ARCH: armhf
-
-deploy-beta:armhf:
-  <<: *deploy-beta
-  variables:
-    ADDON_ARCH: armhf
-
-#deploy-release:aarch64:
-#  <<: *deploy-release
-#  variables:
-#    ADDON_ARCH: aarch64
-#
-#deploy-beta:aarch64:
-#  <<: *deploy-beta
-#  variables:
-#    ADDON_ARCH: aarch64
-
-deploy-release:i386:
-  <<: *deploy-release
-  variables:
-    ADDON_ARCH: i386
-
-deploy-beta:i386:
-  <<: *deploy-beta
-  variables:
-    ADDON_ARCH: i386
-
-deploy-release:amd64:
-  <<: *deploy-release
-  variables:
-    ADDON_ARCH: amd64
-
-deploy-beta:amd64:
-  <<: *deploy-beta
-  variables:
-    ADDON_ARCH: amd64
+    - esphome tests/test3.yaml compile
 
 .deploy-pypi: &deploy-pypi
   stage: deploy
+  image: python:2.7
   before_script:
   - pip install -e .
   - pip install twine
   script:
-  - python setup.py sdist
+  - python setup.py sdist bdist_wheel
   - twine upload dist/*
   tags:
-  - python2.7
-  - esphomeyaml-test
+  - docker
 
 deploy-release:pypi:
   <<: *deploy-pypi
@@ -318,3 +144,204 @@ deploy-beta:pypi:
     - /^v\d+\.\d+\.\d+b\d+$/
   except:
     - /^(?!rc).+@/
+
+.latest: &latest
+  <<: *docker-base
+  only:
+  - /^v([0-9\.]+)$/
+  except:
+  - branches
+
+.latest-vars: &latest-vars
+  RELEASE: YES
+  LATEST: YES
+  # Also push to beta tag
+  BETA: YES
+
+.beta: &beta
+  <<: *docker-base
+  only:
+  - /^v([0-9\.]+b\d+)$/
+  except:
+  - branches
+
+.beta-vars: &beta-vars
+  RELEASE: YES
+  BETA: YES
+
+.dev: &dev
+  <<: *docker-base
+  only:
+  - dev
+
+.dev-vars: &dev-vars
+  DEV: YES
+
+#aarch64-beta-docker:
+#  <<: *beta
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "NO"
+#    RELEASE: "YES"
+#aarch64-beta-hassio:
+#  <<: *beta
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "YES"
+#    RELEASE: "YES"
+#aarch64-dev-docker:
+#  <<: *dev
+#  variables:
+#    BUILD_ARCH: aarch64
+#    DEV: "YES"
+#    IS_HASSIO: "NO"
+#aarch64-dev-hassio:
+#  <<: *dev
+#  variables:
+#    BUILD_ARCH: aarch64
+#    DEV: "YES"
+#    IS_HASSIO: "YES"
+#aarch64-latest-docker:
+#  <<: *latest
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "NO"
+#    LATEST: "YES"
+#    RELEASE: "YES"
+#aarch64-latest-hassio:
+#  <<: *latest
+#  variables:
+#    BETA: "YES"
+#    BUILD_ARCH: aarch64
+#    IS_HASSIO: "YES"
+#    LATEST: "YES"
+#    RELEASE: "YES"
+amd64-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+amd64-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+amd64-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: amd64
+    DEV: "YES"
+    IS_HASSIO: "NO"
+amd64-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: amd64
+    DEV: "YES"
+    IS_HASSIO: "YES"
+amd64-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+amd64-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: amd64
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"
+armhf-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+armhf-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+armhf-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: armhf
+    DEV: "YES"
+    IS_HASSIO: "NO"
+armhf-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: armhf
+    DEV: "YES"
+    IS_HASSIO: "YES"
+armhf-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+armhf-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: armhf
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"
+i386-beta-docker:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "NO"
+    RELEASE: "YES"
+i386-beta-hassio:
+  <<: *beta
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "YES"
+    RELEASE: "YES"
+i386-dev-docker:
+  <<: *dev
+  variables:
+    BUILD_ARCH: i386
+    DEV: "YES"
+    IS_HASSIO: "NO"
+i386-dev-hassio:
+  <<: *dev
+  variables:
+    BUILD_ARCH: i386
+    DEV: "YES"
+    IS_HASSIO: "YES"
+i386-latest-docker:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "NO"
+    LATEST: "YES"
+    RELEASE: "YES"
+i386-latest-hassio:
+  <<: *latest
+  variables:
+    BETA: "YES"
+    BUILD_ARCH: i386
+    IS_HASSIO: "YES"
+    LATEST: "YES"
+    RELEASE: "YES"

.travis.yml

@@ -1,20 +1,38 @@
 sudo: false
 language: python
-python:
-  - "2.7"
-jobs:
+
+cache:
+  directories:
+    - "~/.platformio"
+    - "$TRAVIS_BUILD_DIR/tests/build/test1/.piolibdeps"
+    - "$TRAVIS_BUILD_DIR/tests/build/test2/.piolibdeps"
+    - "$TRAVIS_BUILD_DIR/tests/build/test3/.piolibdeps"
+
+matrix:
+  fast_finish: true
   include:
-    - name: "Lint"
-      install:
-        - pip install -r requirements.txt
-        - pip install flake8==3.5.0 pylint==1.9.3 tzlocal pillow
+    - python: "2.7"
+      env: TARGET=Lint2.7
+      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
       script:
-        - flake8 esphomeyaml
-        - pylint esphomeyaml
-    - name: "Test"
-      install:
-        - pip install -e .
-        - pip install tzlocal pillow
+        - flake8 esphome
+        - pylint esphome
+    - python: "3.5.3"
+      env: TARGET=Lint3.5
+      install: pip install -U https://github.com/platformio/platformio-core/archive/develop.zip && pip install -e . && pip install flake8==3.6.0 pylint==2.3.0 pillow
       script:
-        - esphomeyaml tests/test1.yaml compile
-        - esphomeyaml tests/test2.yaml compile
+        - flake8 esphome
+        - pylint esphome
+    - python: "2.7"
+      env: TARGET=Test2.7
+      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
+      script:
+        - esphome tests/test1.yaml compile
+        - esphome tests/test2.yaml compile
+        - esphome tests/test3.yaml compile
+    #- python: "3.5.3"
+    #  env: TARGET=Test3.5
+    #  install: pip install -U https://github.com/platformio/platformio-core/archive/develop.zip && pip install -e . && pip install flake8==3.6.0 pylint==2.3.0 pillow
+    #  script:
+    #    - esphome tests/test1.yaml compile
+    #    - esphome tests/test2.yaml compile

CONTRIBUTING.md

@@ -1,16 +1,16 @@
-# Contributing to esphomeyaml
+# Contributing to ESPHome
 
-esphomeyaml is a part of esphomelib and is responsible for reading in YAML configuration files,
+This python project is responsible for reading in YAML configuration files,
 converting them to C++ code. This code is then converted to a platformio project and compiled
-with [esphomelib](https://github.com/OttoWinter/esphomelib), the C++ framework behind the project.
+with [esphome-core](https://github.com/esphome/esphome-core), the C++ framework behind the project.
 
-For a detailed guide, please see https://esphomelib.com/esphomeyaml/guides/contributing.html#contributing-to-esphomeyaml
+For a detailed guide, please see https://esphome.io/guides/contributing.html#contributing-to-esphomeyaml
 
 Things to note when contributing:
 
  - Please test your changes :)
  - If a new feature is added or an existing user-facing feature is changed, you should also 
-   update the [docs](https://github.com/OttoWinter/esphomedocs). See [contributing to esphomedocs](https://esphomelib.com/esphomeyaml/guides/contributing.html#contributing-to-esphomedocs)
+   update the [docs](https://github.com/esphome/esphome-docs). See [contributing to esphome-docs](https://esphome.io/guides/contributing.html#contributing-to-esphomedocs)
    for more information.
  - Please also update the tests in the `tests/` folder. You can do so by just adding a line in one of the YAML files
    which checks if your new feature compiles correctly.

Dockerfile

@@ -1,29 +0,0 @@
-ARG BUILD_FROM=python:2.7
-FROM ${BUILD_FROM}
-MAINTAINER Otto Winter <contact@otto-winter.com>
-
-RUN apt-get update && apt-get install -y \
-        python-pil \
-        git \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* && \
-    pip install --no-cache-dir --no-binary :all: platformio && \
-    platformio settings set enable_telemetry No && \
-    platformio settings set check_libraries_interval 1000000 && \
-    platformio settings set check_platformio_interval 1000000 && \
-    platformio settings set check_platforms_interval 1000000
-
-ENV ESPHOMEYAML_OTA_HOST_PORT=6123
-EXPOSE 6123
-VOLUME /config
-WORKDIR /usr/src/app
-
-COPY docker/platformio.ini /pio/platformio.ini
-RUN platformio run -d /pio; rm -rf /pio
-
-COPY . .
-RUN pip install --no-cache-dir --no-binary :all: -e . && \
-    pip install --no-cache-dir --no-binary :all: tzlocal
-
-WORKDIR /config
-ENTRYPOINT ["esphomeyaml"]
-CMD ["/config", "dashboard"]

MANIFEST.in

@@ -1,4 +1,6 @@
+include LICENSE
 include README.md
-include esphomeyaml/dashboard/templates/index.html
-include esphomeyaml/dashboard/static/materialize-stepper.min.css
-include esphomeyaml/dashboard/static/materialize-stepper.min.js
+include esphome/dashboard/templates/*.html
+include esphome/dashboard/static/*.js
+include esphome/dashboard/static/*.css
+include esphome/dashboard/static/*.ico

README.md

@@ -1,38 +1,9 @@
-# esphomeyaml for [esphomelib](https://github.com/OttoWinter/esphomelib)
+# ESPHome [![Build Status](https://travis-ci.org/esphome/esphome.svg?branch=master)](https://travis-ci.org/esphome/esphome) [![Discord Chat](https://img.shields.io/discord/429907082951524364.svg)](https://discord.gg/KhAMKrd) [![GitHub release](https://img.shields.io/github/release/esphome/esphome.svg)](https://GitHub.com/esphome/esphome/releases/)
 
-### Getting Started Guide: https://esphomelib.com/esphomeyaml/guides/getting_started_command_line.html
+[![ESPHome Logo](https://esphome.io/_images/logo-text.png)](https://esphome.io/)
 
-### Available Components: https://esphomelib.com/esphomeyaml/index.html
+**Documentation:** https://esphome.io/
 
-esphomeyaml is the solution for your ESP8266/ESP32 projects with Home Assistant. It allows you to create **custom firmwares** for your microcontrollers with no programming experience required. All you need to know is the YAML configuration format which is also used by [Home Assistant](https://www.home-assistant.io).
+For issues, please go to [the issue tracker](https://github.com/esphome/issues/issues).
 
-esphomeyaml will:
-
- * Read your configuration file and warn you about potential errors (like using the invalid pins.)
- * Create a custom C++ sketch file for you using esphomeyaml's powerful C++ generation engine.
- * Compile the sketch file for you using [platformio](http://platformio.org/).
- * Upload the binary to your ESP via Over the Air updates.
- * Automatically start remote logs via MQTT.
-
-And all of that with a single command 🎉:
-
-```bash
-esphomeyaml configuration.yaml run
-```
-
-## Features
-
- * **No programming experience required:** just edit YAML configuration
-    files like you're used to with Home Assistant.
- * **Flexible:** Use [esphomelib](https://github.com/OttoWinter/esphomelib)'s powerful core to create custom sensors/outputs.
- * **Fast and efficient:** Written in C++ and keeps memory consumption to a minimum.
- * **Made for [Home Assistant](https://www.home-assistant.io):** Almost all [Home Assistant](https://www.home-assistant.io) features are supported out of the box. Including RGB lights and many more.
- * **Easy reproducible configuration:** No need to go through a long setup process for every single node. Just copy a configuration file and run a single command.
- * **Smart Over The Air Updates:** esphomeyaml has OTA updates deeply integrated into the system. It even automatically enters a recovery mode if a boot loop is detected.
- * **Powerful logging engine:** View colorful logs and debug issues remotely.
- * **Open Source**
- * For me: Makes documenting esphomelib's features a lot easier.
-
-## Special Thanks
-
-Special Thanks to the Home Assistant project. Lots of the code base of esphomeyaml is based off of Home Assistant, for example the loading and config validation code.
+For feature requests, please see [feature requests](https://github.com/esphome/feature-requests/issues).

docker/Dockerfile

@@ -0,0 +1,10 @@
+ARG BUILD_FROM=esphome/esphome-base-amd64:1.4.1
+FROM ${BUILD_FROM}
+
+COPY . .
+RUN \
+    pip2 install --no-cache-dir --no-binary :all: -e .
+
+WORKDIR /config
+ENTRYPOINT ["esphome"]
+CMD ["/config", "dashboard"]

docker/Dockerfile.builder

@@ -1,30 +0,0 @@
-FROM multiarch/ubuntu-core:amd64-xenial
-
-# setup locals
-RUN apt-get update && apt-get install -y \
-        jq \
-        git \
-        python3-setuptools \
-    && rm -rf /var/lib/apt/lists/* \
-ENV LANG C.UTF-8
-
-# Install docker
-# https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/
-RUN apt-get update && apt-get install -y \
-        apt-transport-https \
-        ca-certificates \
-        curl \
-        software-properties-common \
-    && rm -rf /var/lib/apt/lists/* \
-    && curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add - \
-    && add-apt-repository "deb https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
-    && apt-get update && apt-get install -y docker-ce \
-    && rm -rf /var/lib/apt/lists/*
-
-# setup arm binary support
-RUN apt-get update && apt-get install -y \
-        qemu-user-static \
-        binfmt-support \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /data

docker/Dockerfile.hassio

@@ -1,42 +1,20 @@
-# Dockerfile for HassIO add-on
-ARG BUILD_FROM=homeassistant/amd64-base-ubuntu:latest
+ARG BUILD_FROM=esphome/esphome-hassio-base-amd64:1.4.1
 FROM ${BUILD_FROM}
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-        python \
-        python-pip \
-        python-setuptools \
-        python-pil \
-        git \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* && \
-    pip install --no-cache-dir --no-binary :all: platformio && \
-    platformio settings set enable_telemetry No && \
-    platformio settings set check_libraries_interval 1000000 && \
-    platformio settings set check_platformio_interval 1000000 && \
-    platformio settings set check_platforms_interval 1000000
+# Copy root filesystem
+COPY docker/rootfs/ /
+COPY setup.py setup.cfg MANIFEST.in /opt/esphome/
+COPY esphome /opt/esphome/esphome
 
-COPY docker/platformio.ini /pio/platformio.ini
-RUN platformio run -d /pio; rm -rf /pio
+RUN \
+    pip2 install --no-cache-dir --no-binary :all: -e /opt/esphome
 
-ARG ESPHOMELIB_VERSION="dev"
-RUN platformio lib -g install "https://github.com/OttoWinter/esphomelib.git#${ESPHOMELIB_VERSION}"
-
-COPY . .
-RUN pip install --no-cache-dir --no-binary :all: -e . && \
-    pip install --no-cache-dir --no-binary :all: tzlocal
-
-CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]
-
-# Build arugments
-ARG ADDON_ARCH
-ARG ADDON_VERSION
+# Build arguments
+ARG BUILD_VERSION=dev
 
 # Labels
 LABEL \
-    io.hass.name="esphomeyaml" \
-    io.hass.description="esphomeyaml HassIO add-on for intelligently managing all your ESP8266/ESP32 devices." \
-    io.hass.arch="${ADDON_ARCH}" \
+    io.hass.name="ESPHome" \
+    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
     io.hass.type="addon" \
-    io.hass.version="${ADDON_VERSION}" \
-    io.hass.url="https://esphomelib.com/esphomeyaml/index.html" \
-    maintainer="Otto Winter <contact@otto-winter.com>"
+    io.hass.version=${BUILD_VERSION}

docker/Dockerfile.lint

@@ -3,4 +3,4 @@ FROM python:2.7
 COPY requirements.txt /requirements.txt
 
 RUN pip install -r /requirements.txt && \
-    pip install flake8==3.5.0 pylint==1.9.3 tzlocal pillow
+    pip install flake8==3.6.0 pylint==1.9.4 pillow

docker/Dockerfile.test

@@ -8,12 +8,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
         git \
     && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/*rm -rf /var/lib/apt/lists/* /tmp/* && \
     pip install --no-cache-dir --no-binary :all: platformio && \
-    platformio settings set enable_telemetry No
+    platformio settings set enable_telemetry No && \
+    platformio settings set check_libraries_interval 1000000 && \
+    platformio settings set check_platformio_interval 1000000 && \
+    platformio settings set check_platforms_interval 1000000
 
 COPY docker/platformio.ini /pio/platformio.ini
 RUN platformio run -d /pio; rm -rf /pio
 
 COPY requirements.txt /requirements.txt
 
-RUN pip install --no-cache-dir -r /requirements.txt && \
-    pip install --no-cache-dir tzlocal pillow
+RUN pip install --no-cache-dir -r /requirements.txt

docker/hooks/build

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# the Docker repository tag being built.
+declare CACHE_TAG
+echo "CACHE_TAG: ${CACHE_TAG}"
+# the name and tag of the Docker repository being built. (This variable is a combination of DOCKER_REPO:CACHE_TAG.)
+declare IMAGE_NAME
+echo "IMAGE_NAME: ${IMAGE_NAME}"
+# the architecture to build
+declare BUILD_ARCH
+echo "BUILD_ARCH: ${BUILD_ARCH}"
+# whether this is a hassio build
+declare IS_HASSIO
+echo "IS_HASSIO: ${IS_HASSIO}"
+echo "PWD: $PWD"
+
+if [[ ${IS_HASSIO} = "YES" ]]; then
+    docker build \
+      --build-arg "BUILD_FROM=esphome/esphome-hassio-base-${BUILD_ARCH}:1.4.1" \
+      --build-arg "BUILD_VERSION=${CACHE_TAG}" \
+      -t "${IMAGE_NAME}" -f ../docker/Dockerfile.hassio ..
+else
+    docker build \
+      --build-arg "BUILD_FROM=esphome/esphome-base-${BUILD_ARCH}:1.4.1" \
+      -t "${IMAGE_NAME}" -f ../docker/Dockerfile ..
+fi

docker/hooks/pre_build

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+# the architecture to build
+declare BUILD_ARCH
+
+echo "BUILD_ARCH: ${BUILD_ARCH}"
+
+if [[ ${BUILD_ARCH} = "amd64" ]]; then
+    echo "No qemu required..."
+    exit 0
+fi
+if [[ ${BUILD_ARCH} = "i386" ]]; then
+    echo "No qemu required..."
+    exit 0
+fi
+
+echo "Installing qemu..."
+docker run --rm --privileged multiarch/qemu-user-static:register --reset

docker/platformio.ini

@@ -2,11 +2,11 @@
 ; platforms
 
 [env:espressif8266]
-platform = espressif8266
+platform = espressif8266@1.8.0
 board = nodemcuv2
 framework = arduino
 
 [env:espressif32]
-platform = espressif32
+platform = espressif32@1.5.0
 board = nodemcu-32s
 framework = arduino

docker/rootfs/etc/cont-init.d/10-requirements.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files check if all user configuration requirements are met
+# ==============================================================================
+
+# Check SSL requirements, if enabled
+if bashio::config.true 'ssl'; then
+    if ! bashio::config.has_value 'certfile'; then
+        bashio::fatal 'SSL is enabled, but no certfile was specified.'
+        bashio::exit.nok
+    fi
+
+    if ! bashio::config.has_value 'keyfile'; then
+        bashio::fatal 'SSL is enabled, but no keyfile was specified'
+        bashio::exit.nok
+    fi
+
+
+    certfile="/ssl/$(bashio::config 'certfile')"
+    keyfile="/ssl/$(bashio::config 'keyfile')"
+
+    if ! bashio::fs.file_exists "${certfile}"; then
+        if ! bashio::fs.file_exists "${keyfile}"; then
+            # Both files are missing, let's print a friendlier error message
+            bashio::log.fatal 'You enabled encrypted connections using the "ssl": true option.'
+            bashio::log.fatal "However, the SSL files '${certfile}' and '${keyfile}'"
+            bashio::log.fatal "were not found. If you're using Hass.io on your local network and don't want"
+            bashio::log.fatal 'to encrypt connections to the ESPHome dashboard, you can manually disable'
+            bashio::log.fatal 'SSL by setting "ssl" to false."'
+            bashio::exit.nok
+        fi
+        bashio::log.fatal "The configured certfile '${certfile}' was not found."
+        bashio::exit.nok
+    fi
+
+    if ! bashio::fs.file_exists "/ssl/$(bashio::config 'keyfile')"; then
+        bashio::log.fatal "The configured keyfile '${keyfile}' was not found."
+        bashio::exit.nok
+    fi
+fi

docker/rootfs/etc/cont-init.d/20-nginx.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Configures NGINX for use with ESPHome
+# ==============================================================================
+
+declare certfile
+declare keyfile
+declare port
+
+mkdir -p /var/log/nginx
+
+# Enable SSL
+if bashio::config.true 'ssl'; then
+    rm /etc/nginx/nginx.conf
+    mv /etc/nginx/nginx-ssl.conf /etc/nginx/nginx.conf
+
+    certfile=$(bashio::config 'certfile')
+    keyfile=$(bashio::config 'keyfile')
+
+    sed -i "s/%%certfile%%/${certfile}/g" /etc/nginx/nginx.conf
+    sed -i "s/%%keyfile%%/${keyfile}/g" /etc/nginx/nginx.conf
+fi
+
+port=$(bashio::config 'port')
+sed -i "s/%%port%%/${port}/g" /etc/nginx/nginx.conf

docker/rootfs/etc/cont-init.d/30-esphome.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files installs the user ESPHome version if specified
+# ==============================================================================
+
+declare esphome_version
+
+if bashio::config.has_value 'esphome_version'; then
+    esphome_version=$(bashio::config 'esphome_version')
+    full_url="https://github.com/esphome/esphome/archive/${esphome_version}.zip"
+    bashio::log.info "Installing esphome version '${esphome_version}' (${full_url})..."
+    pip2 install --no-cache-dir --no-binary :all: "${full_url}" \
+      || bashio::exit.nok "Failed installing esphome pinned version."
+fi

docker/rootfs/etc/cont-init.d/40-migrate.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files migrates the esphome config directory from the old path
+# ==============================================================================
+
+if [[ ! -d /config/esphome && -d /config/esphomeyaml ]]; then
+    echo "Moving config directory from /config/esphomeyaml to /config/esphome"
+    mv /config/esphomeyaml /config/esphome
+    mv /config/esphome/.esphomeyaml /config/esphome/.esphome
+fi

docker/rootfs/etc/nginx/nginx-ssl.conf

@@ -0,0 +1,62 @@
+worker_processes  1;
+pid /var/run/nginx.pid;
+error_log stderr;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    access_log         stdout;
+    include            mime.types;
+    default_type       application/octet-stream;
+    sendfile           on;
+    keepalive_timeout  65;
+
+    upstream esphome {
+        ip_hash;
+        server unix:/var/run/esphome.sock;
+    }
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+
+    server {
+        server_name hassio.local;
+        listen %%port%% default_server ssl;
+        root /dev/null;
+
+        ssl_certificate /ssl/%%certfile%%;
+        ssl_certificate_key /ssl/%%keyfile%%;
+        ssl_protocols TLSv1.2;
+        ssl_prefer_server_ciphers on;
+        ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:DHE-RSA-AES256-SHA;
+        ssl_ecdh_curve secp384r1;
+        ssl_session_timeout  10m;
+        ssl_session_cache shared:SSL:10m;
+        ssl_session_tickets off;
+        ssl_stapling on;
+        ssl_stapling_verify on;
+
+        # Redirect http requests to https on the same port.
+        # https://rageagainstshell.com/2016/11/redirect-http-to-https-on-the-same-port-in-nginx/
+        error_page 497 https://$http_host$request_uri;
+
+        location / {
+            proxy_redirect off;
+            proxy_pass http://esphome;
+
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header Authorization "";
+
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Host $http_host;
+            proxy_set_header X-NginX-Proxy true;
+        }
+    }
+}

docker/rootfs/etc/nginx/nginx.conf

@@ -0,0 +1,46 @@
+worker_processes  1;
+pid /var/run/nginx.pid;
+error_log stderr;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    access_log         stdout;
+    include            mime.types;
+    default_type       application/octet-stream;
+    sendfile           on;
+    keepalive_timeout  65;
+
+    upstream esphome {
+        ip_hash;
+        server unix:/var/run/esphome.sock;
+    }
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+
+    server {
+        server_name hassio.local;
+        listen %%port%% default_server;
+        root /dev/null;
+
+        location / {
+            proxy_redirect off;
+            proxy_pass http://esphome;
+
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+            proxy_set_header Authorization "";
+
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Host $http_host;
+            proxy_set_header X-NginX-Proxy true;
+        }
+    }
+}

docker/rootfs/etc/services.d/esphome/finish

@@ -0,0 +1,9 @@
+#!/usr/bin/execlineb -S0
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Take down the S6 supervision tree when ESPHome fails
+# ==============================================================================
+if -n { s6-test $# -ne 0 }
+if -n { s6-test ${1} -eq 256 }
+
+s6-svscanctl -t /var/run/s6/services

docker/rootfs/etc/services.d/esphome/run

@@ -0,0 +1,26 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Runs the ESPHome dashboard
+# ==============================================================================
+
+export ESPHOME_IS_HASSIO=true
+
+if bashio::config.true 'leave_front_door_open'; then
+    export DISABLE_HA_AUTHENTICATION=true
+fi
+
+if bashio::config.true 'streamer_mode'; then
+    export ESPHOME_STREAMER_MODE=true
+fi
+
+if bashio::config.true 'status_use_ping'; then
+    export ESPHOME_DASHBOARD_USE_PING=true
+fi
+
+if bashio::config.has_value 'relative_url'; then
+    export ESPHOME_DASHBOARD_RELATIVE_URL=$(bashio::config 'relative_url')
+fi
+
+bashio::log.info "Starting ESPHome dashboard..."
+exec esphome /config/esphome dashboard --socket /var/run/esphome.sock --hassio

docker/rootfs/etc/services.d/nginx/finish

@@ -0,0 +1,9 @@
+#!/usr/bin/execlineb -S0
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Take down the S6 supervision tree when NGINX fails
+# ==============================================================================
+if -n { s6-test $# -ne 0 }
+if -n { s6-test ${1} -eq 256 }
+
+s6-svscanctl -t /var/run/s6/services

docker/rootfs/etc/services.d/nginx/run

@@ -0,0 +1,8 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# Runs the NGINX proxy
+# ==============================================================================
+
+bashio::log.info "Starting NGINX..."
+exec nginx -g "daemon off;"

esphome/__main__.py

@@ -1,26 +1,29 @@
 from __future__ import print_function
 
 import argparse
-from collections import OrderedDict
+from datetime import datetime
 import logging
 import os
 import random
 import sys
-from datetime import datetime
 
-from esphomeyaml import const, core, core_config, mqtt, wizard, writer, yaml_util, platformio_api
-from esphomeyaml.config import get_component, iter_components, read_config
-from esphomeyaml.const import CONF_BAUD_RATE, CONF_BUILD_PATH, CONF_DOMAIN, CONF_ESPHOMEYAML, \
-    CONF_HOSTNAME, CONF_LOGGER, CONF_MANUAL_IP, CONF_NAME, CONF_STATIC_IP, CONF_USE_CUSTOM_CODE, \
-    CONF_WIFI, ESP_PLATFORM_ESP8266
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import AssignmentExpression, Expression, RawStatement, \
-    _EXPRESSIONS, add, add_job, color, flush_tasks, indent, statement, relative_path
-from esphomeyaml.util import safe_print, run_external_command
+from esphome import const, core_config, mqtt, platformio_api, wizard, writer, yaml_util
+from esphome.api.client import run_logs
+from esphome.config import get_component, iter_components, read_config, strip_default_ids
+from esphome.const import CONF_BAUD_RATE, CONF_BROKER, CONF_ESPHOME, CONF_LOGGER, \
+    CONF_USE_CUSTOM_CODE
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import Expression, RawStatement, add, statement
+from esphome.helpers import color, indent
+from esphome.py_compat import IS_PY2, safe_input, text_type
+from esphome.storage_json import StorageJSON, storage_path
+from esphome.util import run_external_command, run_external_process, safe_print, \
+    is_dev_esphome_version
 
 _LOGGER = logging.getLogger(__name__)
 
-PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'web_server', 'i2c']
+PRE_INITIALIZE = ['esphome', 'logger', 'wifi', 'ethernet', 'ota', 'mqtt', 'web_server', 'api',
+                  'i2c']
 
 
 def get_serial_ports():
@@ -32,37 +35,64 @@ def get_serial_ports():
             continue
         if "VID:PID" in info:
             result.append((port, desc))
+    result.sort(key=lambda x: x[0])
     return result
 
 
-def choose_serial_port(config):
-    result = get_serial_ports()
+def choose_prompt(options):
+    if not options:
+        raise ValueError
+
+    if len(options) == 1:
+        return options[0][1]
+
+    safe_print(u"Found multiple options, please choose one:")
+    for i, (desc, _) in enumerate(options):
+        safe_print(u"  [{}] {}".format(i + 1, desc))
 
-    if not result:
-        return 'OTA'
-    safe_print(u"Found multiple serial port options, please choose one:")
-    for i, (res, desc) in enumerate(result):
-        safe_print(u"  [{}] {} ({})".format(i, res, desc))
-    safe_print(u"  [{}] Over The Air ({})".format(len(result), get_upload_host(config)))
-    safe_print()
     while True:
-        opt = raw_input('(number): ')
-        if opt in result:
-            opt = result.index(opt)
+        opt = safe_input('(number): ')
+        if opt in options:
+            opt = options.index(opt)
             break
         try:
             opt = int(opt)
-            if opt < 0 or opt > len(result):
+            if opt < 1 or opt > len(options):
                 raise ValueError
             break
         except ValueError:
             safe_print(color('red', u"Invalid option: '{}'".format(opt)))
-    if opt == len(result):
-        return 'OTA'
-    return result[opt][0]
+    return options[opt - 1][1]
 
 
-def run_miniterm(config, port, escape=False):
+def choose_upload_log_host(default, check_default, show_ota, show_mqtt, show_api):
+    options = []
+    for res, desc in get_serial_ports():
+        options.append((u"{} ({})".format(res, desc), res))
+    if (show_ota and 'ota' in CORE.config) or (show_api and 'api' in CORE.config):
+        options.append((u"Over The Air ({})".format(CORE.address), CORE.address))
+        if default == 'OTA':
+            return CORE.address
+    if show_mqtt and 'mqtt' in CORE.config:
+        options.append((u"MQTT ({})".format(CORE.config['mqtt'][CONF_BROKER]), 'MQTT'))
+        if default == 'OTA':
+            return 'MQTT'
+    if default is not None:
+        return default
+    if check_default is not None and check_default in [opt[1] for opt in options]:
+        return check_default
+    return choose_prompt(options)
+
+
+def get_port_type(port):
+    if port.startswith('/') or port.startswith('COM'):
+        return 'SERIAL'
+    if port == 'MQTT':
+        return 'MQTT'
+    return 'NETWORK'
+
+
+def run_miniterm(config, port):
     import serial
     if CONF_LOGGER not in config:
         _LOGGER.info("Logger is not enabled. Not starting UART logs.")
@@ -80,11 +110,13 @@ def run_miniterm(config, port, escape=False):
             except serial.SerialException:
                 _LOGGER.error("Serial port closed!")
                 return
-            line = raw.replace('\r', '').replace('\n', '')
+            if IS_PY2:
+                line = raw.replace('\r', '').replace('\n', '')
+            else:
+                line = raw.replace(b'\r', b'').replace(b'\n', b'').decode('utf8',
+                                                                          'backslashreplace')
             time = datetime.now().time().strftime('[%H:%M:%S]')
             message = time + line
-            if escape:
-                message = message.replace('\033', '\\033')
             safe_print(message)
 
             backtrace_state = platformio_api.process_stacktrace(
@@ -94,114 +126,108 @@ def run_miniterm(config, port, escape=False):
 def write_cpp(config):
     _LOGGER.info("Generating C++ source...")
 
-    add_job(core_config.to_code, config[CONF_ESPHOMEYAML], domain='esphomeyaml')
+    CORE.add_job(core_config.to_code, config[CONF_ESPHOME], domain='esphome')
     for domain in PRE_INITIALIZE:
-        if domain == CONF_ESPHOMEYAML or domain not in config:
+        if domain == CONF_ESPHOME or domain not in config:
             continue
-        add_job(get_component(domain).to_code, config[domain], domain=domain)
+        CORE.add_job(get_component(domain).to_code, config[domain], domain=domain)
 
     for domain, component, conf in iter_components(config):
         if domain in PRE_INITIALIZE or not hasattr(component, 'to_code'):
             continue
-        add_job(component.to_code, conf, domain=domain)
+        CORE.add_job(component.to_code, conf, domain=domain)
 
-    flush_tasks()
+    CORE.flush_tasks()
     add(RawStatement(''))
     add(RawStatement(''))
     all_code = []
-    for exp in _EXPRESSIONS:
-        if not config[CONF_ESPHOMEYAML][CONF_USE_CUSTOM_CODE]:
+    for exp in CORE.expressions:
+        if not config[CONF_ESPHOME][CONF_USE_CUSTOM_CODE]:
             if isinstance(exp, Expression) and not exp.required:
                 continue
-            if isinstance(exp, AssignmentExpression) and not exp.obj.required:
-                if not exp.has_side_effects():
-                    continue
-                exp = exp.rhs
-        all_code.append(unicode(statement(exp)))
+        all_code.append(text_type(statement(exp)))
 
-    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
-    writer.write_platformio_project(config, build_path)
+    writer.write_platformio_project()
 
     code_s = indent('\n'.join(line.rstrip() for line in all_code))
-    cpp_path = os.path.join(build_path, 'src', 'main.cpp')
-    writer.write_cpp(code_s, cpp_path)
+    writer.write_cpp(code_s)
     return 0
 
 
 def compile_program(args, config):
     _LOGGER.info("Compiling app...")
-    return platformio_api.run_compile(config, args.verbose)
-
-
-def get_upload_host(config):
-    if CONF_MANUAL_IP in config[CONF_WIFI]:
-        host = str(config[CONF_WIFI][CONF_MANUAL_IP][CONF_STATIC_IP])
-    elif CONF_HOSTNAME in config[CONF_WIFI]:
-        host = config[CONF_WIFI][CONF_HOSTNAME] + config[CONF_WIFI][CONF_DOMAIN]
-    else:
-        host = config[CONF_ESPHOMEYAML][CONF_NAME] + config[CONF_WIFI][CONF_DOMAIN]
-    return host
+    rc = platformio_api.run_compile(config, args.verbose)
+    if rc != 0 and CORE.is_dev_esphome_core_version and not is_dev_esphome_version():
+        _LOGGER.warning("You're using 'esphome_core_version: dev' but not using the "
+                        "dev version of the ESPHome tool.")
+        _LOGGER.warning("Expect compile errors if these versions are out of sync.")
+        _LOGGER.warning("Please install the dev version of ESPHome too when using "
+                        "'esphome_core_version: dev'.")
+        _LOGGER.warning(" - Hass.io: Install 'ESPHome (dev)' addon")
+        _LOGGER.warning(" - Docker: docker run [...] esphome/esphome:dev [...]")
+        _LOGGER.warning(" - PIP: pip install -U https://github.com/esphome/esphome/archive/dev.zip")
+    return rc
 
 
 def upload_using_esptool(config, port):
-    import esptool
-
-    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
-    path = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
+    path = CORE.firmware_bin
     cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
            '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
-    # pylint: disable=protected-access
-    return run_external_command(esptool._main, *cmd)
+
+    if os.environ.get('ESPHOME_USE_SUBPROCESS') is None:
+        import esptool
+        # pylint: disable=protected-access
+        return run_external_command(esptool._main, *cmd)
+
+    return run_external_process(*cmd)
 
 
-def upload_program(config, args, port):
-    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
-
+def upload_program(config, args, host):
     # if upload is to a serial port use platformio, otherwise assume ota
-    serial_port = port.startswith('/') or port.startswith('COM')
-    if port != 'OTA' and serial_port:
-        if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266 and args.use_esptoolpy:
-            return upload_using_esptool(config, port)
-        return platformio_api.run_upload(config, args.verbose, port)
+    if get_port_type(host) == 'SERIAL':
+        if CORE.is_esp8266:
+            return upload_using_esptool(config, host)
+        return platformio_api.run_upload(config, args.verbose, host)
 
-    if 'ota' not in config:
-        _LOGGER.error("No serial port found and OTA not enabled. Can't upload!")
-        return -1
+    from esphome.components import ota
+    from esphome import espota2
 
-    # If hostname/ip is explicitly provided as upload-port argument, use this instead of zeroconf
-    # hostname. This is to support use cases where zeroconf (hostname.local) does not work.
-    if port != 'OTA':
-        host = port
-    else:
-        host = get_upload_host(config)
-
-    from esphomeyaml.components import ota
-    from esphomeyaml import espota2
-
-    bin_file = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
     if args.host_port is not None:
         host_port = args.host_port
     else:
-        host_port = int(os.getenv('ESPHOMEYAML_OTA_HOST_PORT', random.randint(10000, 60000)))
+        host_port = int(os.getenv('ESPHOME_OTA_HOST_PORT', random.randint(10000, 60000)))
 
     verbose = args.verbose
     remote_port = ota.get_port(config)
     password = ota.get_auth(config)
 
-    res = espota2.run_ota(host, remote_port, password, bin_file)
+    storage = StorageJSON.load(storage_path())
+    res = espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
     if res == 0:
+        if storage is not None and storage.use_legacy_ota:
+            storage.use_legacy_ota = False
+            storage.save(storage_path())
         return res
-    _LOGGER.warn("OTA v2 method failed. Trying with legacy OTA...")
-    return espota2.run_legacy_ota(verbose, host_port, host, remote_port, password, bin_file)
+    if storage is not None and not storage.use_legacy_ota:
+        return res
+
+    _LOGGER.warning("OTA v2 method failed. Trying with legacy OTA...")
+    return espota2.run_legacy_ota(verbose, host_port, host, remote_port, password,
+                                  CORE.firmware_bin)
 
 
-def show_logs(config, args, port, escape=False):
-    serial_port = port.startswith('/') or port.startswith('COM')
-    if port != 'OTA' and serial_port:
-        run_miniterm(config, port, escape=escape)
+def show_logs(config, args, port):
+    if 'logger' not in config:
+        raise EsphomeError("Logger is not configured!")
+    if get_port_type(port) == 'SERIAL':
+        run_miniterm(config, port)
         return 0
-    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id,
-                          escape=escape)
+    if get_port_type(port) == 'NETWORK' and 'api' in config:
+        return run_logs(config, port)
+    if get_port_type(port) == 'MQTT' and 'mqtt' in config:
+        return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+
+    raise ValueError
 
 
 def clean_mqtt(config, args):
@@ -239,26 +265,8 @@ def command_wizard(args):
     return wizard.wizard(args.configuration)
 
 
-def strip_default_ids(config):
-    value = config
-    if isinstance(config, list):
-        value = type(config)()
-        for x in config:
-            if isinstance(x, core.ID) and not x.is_manual:
-                continue
-            value.append(strip_default_ids(x))
-        return value
-    elif isinstance(config, dict):
-        value = type(config)()
-        for k, v in config.iteritems():
-            if isinstance(v, core.ID) and not v.is_manual:
-                continue
-            value[k] = strip_default_ids(v)
-        return value
-    return value
-
-
 def command_config(args, config):
+    _LOGGER.info("Configuration is valid!")
     if not args.verbose:
         config = strip_default_ids(config)
     safe_print(yaml_util.dump(config))
@@ -280,7 +288,8 @@ def command_compile(args, config):
 
 
 def command_upload(args, config):
-    port = args.upload_port or choose_serial_port(config)
+    port = choose_upload_log_host(default=args.upload_port, check_default=None,
+                                  show_ota=True, show_mqtt=False, show_api=False)
     exit_code = upload_program(config, args, port)
     if exit_code != 0:
         return exit_code
@@ -289,8 +298,9 @@ def command_upload(args, config):
 
 
 def command_logs(args, config):
-    port = args.serial_port or choose_serial_port(config)
-    return show_logs(config, args, port, escape=args.escape)
+    port = choose_upload_log_host(default=args.serial_port, check_default=None,
+                                  show_ota=False, show_mqtt=True, show_api=True)
+    return show_logs(config, args, port)
 
 
 def command_run(args, config):
@@ -301,14 +311,17 @@ def command_run(args, config):
     if exit_code != 0:
         return exit_code
     _LOGGER.info(u"Successfully compiled program.")
-    port = args.upload_port or choose_serial_port(config)
+    port = choose_upload_log_host(default=args.upload_port, check_default=None,
+                                  show_ota=True, show_mqtt=False, show_api=True)
     exit_code = upload_program(config, args, port)
     if exit_code != 0:
         return exit_code
     _LOGGER.info(u"Successfully uploaded program.")
     if args.no_logs:
         return 0
-    return show_logs(config, args, port, escape=args.escape)
+    port = choose_upload_log_host(default=args.upload_port, check_default=port,
+                                  show_ota=False, show_mqtt=True, show_api=True)
+    return show_logs(config, args, port)
 
 
 def command_clean_mqtt(args, config):
@@ -325,9 +338,8 @@ def command_version(args):
 
 
 def command_clean(args, config):
-    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
     try:
-        writer.clean_build(build_path)
+        writer.clean_build()
     except OSError as err:
         _LOGGER.error("Error deleting build files: %s", err)
         return 1
@@ -335,30 +347,8 @@ def command_clean(args, config):
     return 0
 
 
-def command_hass_config(args, config):
-    from esphomeyaml.components import mqtt as mqtt_component
-
-    _LOGGER.info("This is what you should put in your Home Assistant YAML configuration.")
-    _LOGGER.info("Please note this is only necessary if you're not using MQTT discovery.")
-    data = mqtt_component.GenerateHassConfigData(config)
-    hass_config = OrderedDict()
-    for domain, component, conf in iter_components(config):
-        if not hasattr(component, 'to_hass_config'):
-            continue
-        func = getattr(component, 'to_hass_config')
-        ret = func(data, conf)
-        if not isinstance(ret, (list, tuple)):
-            ret = [ret]
-        ret = [x for x in ret if x is not None]
-        domain_conf = hass_config.setdefault(domain.split('.')[0], [])
-        domain_conf += ret
-
-    safe_print(yaml_util.dump(hass_config))
-    return 0
-
-
 def command_dashboard(args):
-    from esphomeyaml.dashboard import dashboard
+    from esphome.dashboard import dashboard
 
     return dashboard.start_web_server(args)
 
@@ -378,14 +368,15 @@ POST_CONFIG_ACTIONS = {
     'clean-mqtt': command_clean_mqtt,
     'mqtt-fingerprint': command_mqtt_fingerprint,
     'clean': command_clean,
-    'hass-config': command_hass_config,
 }
 
 
 def parse_args(argv):
-    parser = argparse.ArgumentParser(prog='esphomeyaml')
-    parser.add_argument('-v', '--verbose', help="Enable verbose esphomeyaml logs.",
+    parser = argparse.ArgumentParser(prog='esphome')
+    parser.add_argument('-v', '--verbose', help="Enable verbose esphome logs.",
                         action='store_true')
+    parser.add_argument('--dashboard', help="Internal flag to set if the command is run from the "
+                                            "dashboard.", action='store_true')
     parser.add_argument('configuration', help='Your YAML configuration file.')
 
     subparsers = parser.add_subparsers(help='Commands', dest='command')
@@ -403,9 +394,6 @@ def parse_args(argv):
     parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
                                                      "For example /dev/cu.SLAB_USBtoUART.")
     parser_upload.add_argument('--host-port', help="Specify the host port.", type=int)
-    parser_upload.add_argument('--use-esptoolpy',
-                               help="Use esptool.py for the uploading (only for ESP8266)",
-                               action='store_true')
 
     parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
                                                      'and show all MQTT logs.')
@@ -415,8 +403,6 @@ def parse_args(argv):
     parser_logs.add_argument('--client-id', help='Manually set the client id.')
     parser_logs.add_argument('--serial-port', help="Manually specify a serial port to use"
                                                    "For example /dev/cu.SLAB_USBtoUART.")
-    parser_logs.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
-                             action='store_true')
 
     parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
                                                    'upload it, and start MQTT logs.')
@@ -429,11 +415,6 @@ def parse_args(argv):
     parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
     parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
     parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
-    parser_run.add_argument('--escape', help="Escape ANSI color codes for running in dashboard",
-                            action='store_true')
-    parser_run.add_argument('--use-esptoolpy',
-                            help="Use esptool.py for the uploading (only for ESP8266)",
-                            action='store_true')
 
     parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
                                                             "retain messages.")
@@ -443,49 +424,55 @@ def parse_args(argv):
     parser_clean.add_argument('--client-id', help='Manually set the client id.')
 
     subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
-                                         "you through setting up esphomeyaml.")
+                                         "you through setting up esphome.")
 
     subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
 
-    subparsers.add_parser('version', help="Print the esphomeyaml version and exit.")
+    subparsers.add_parser('version', help="Print the esphome version and exit.")
 
     subparsers.add_parser('clean', help="Delete all temporary build files.")
 
     dashboard = subparsers.add_parser('dashboard',
                                       help="Create a simple web server for a dashboard.")
-    dashboard.add_argument("--port", help="The HTTP port to open connections on.", type=int,
-                           default=6052)
+    dashboard.add_argument("--port", help="The HTTP port to open connections on. Defaults to 6052.",
+                           type=int, default=6052)
     dashboard.add_argument("--password", help="The optional password to require for all requests.",
                            type=str, default='')
     dashboard.add_argument("--open-ui", help="Open the dashboard UI in a browser.",
                            action='store_true')
-
-    subparsers.add_parser('hass-config', help="Dump the configuration entries that should be added"
-                                              "to Home Assistant when not using MQTT discovery.")
+    dashboard.add_argument("--hassio",
+                           help="Internal flag used to tell esphome is started as a Hass.io "
+                                "add-on.",
+                           action="store_true")
+    dashboard.add_argument("--socket",
+                           help="Make the dashboard serve under a unix socket", type=str)
 
     return parser.parse_args(argv[1:])
 
 
-def run_esphomeyaml(argv):
+def run_esphome(argv):
     args = parse_args(argv)
+    CORE.dashboard = args.dashboard
+
     setup_log(args.verbose)
     if args.command in PRE_CONFIG_ACTIONS:
         try:
             return PRE_CONFIG_ACTIONS[args.command](args)
-        except ESPHomeYAMLError as e:
+        except EsphomeError as e:
             _LOGGER.error(e)
             return 1
 
-    core.CONFIG_PATH = args.configuration
+    CORE.config_path = args.configuration
 
-    config = read_config(core.CONFIG_PATH)
+    config = read_config(args.verbose)
     if config is None:
         return 1
+    CORE.config = config
 
     if args.command in POST_CONFIG_ACTIONS:
         try:
             return POST_CONFIG_ACTIONS[args.command](args, config)
-        except ESPHomeYAMLError as e:
+        except EsphomeError as e:
             _LOGGER.error(e)
             return 1
     safe_print(u"Unknown command {}".format(args.command))
@@ -494,8 +481,8 @@ def run_esphomeyaml(argv):
 
 def main():
     try:
-        return run_esphomeyaml(sys.argv)
-    except ESPHomeYAMLError as e:
+        return run_esphome(sys.argv)
+    except EsphomeError as e:
         _LOGGER.error(e)
         return 1
     except KeyboardInterrupt:

esphome/api/api.proto

@@ -0,0 +1,330 @@
+syntax = "proto3";
+
+// 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:
+//  * 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
+
+// The connection is established in 4 steps:
+//  * First, the client connects to the server and sends a "Hello Request" identifying itself
+//  * The server responds with a "Hello Response" and selects the protocol version
+//  * After receiving this message, the client attempts to authenticate itself using
+//    the password and a "Connect Request"
+//  * The server responds with a "Connect Response" and notifies of invalid password.
+// If anything in this initial process fails, the connection must immediately closed
+// by both sides and _no_ disconnection message is to be sent.
+
+// Message sent at the beginning of each connection
+// Can only be sent by the client and only at the beginning of the connection
+message HelloRequest {
+  // Description of client (like User Agent)
+  // For example "Home Assistant"
+  // Not strictly necessary to send but nice for debugging
+  // purposes.
+  string client_info = 1;
+}
+
+// Confirmation of successful connection request.
+// Can only be sent by the server and only at the beginning of the connection
+message HelloResponse {
+  // The version of the API to use. The _client_ (for example Home Assistant) needs to check
+  // for compatibility and if necessary adopt to an older API.
+  // Major is for breaking changes in the base protocol - a mismatch will lead to immediate disconnect_client_
+  // Minor is for breaking changes in individual messages - a mismatch will lead to a warning message
+  uint32 api_version_major = 1;
+  uint32 api_version_minor = 2;
+
+  // A string identifying the server (ESP); like client info this may be empty
+  // and only exists for debugging/logging purposes.
+  // For example "ESPHome v1.10.0 on ESP8266"
+  string server_info = 3;
+}
+
+// Message sent at the beginning of each connection to authenticate the client
+// Can only be sent by the client and only at the beginning of the connection
+message ConnectRequest {
+  // The password to log in with
+  string password = 1;
+}
+
+// Confirmation of successful connection. After this the connection is available for all traffic.
+// Can only be sent by the server and only at the beginning of the connection
+message ConnectResponse {
+  bool invalid_password = 1;
+}
+
+// Request to close the connection.
+// Can be sent by both the client and server
+message DisconnectRequest {
+  // Do not close the connection before the acknowledgement arrives
+}
+
+message DisconnectResponse {
+  // Empty - Both parties are required to close the connection after this
+  // message has been received.
+}
+
+message PingRequest {
+  // Empty
+}
+
+message PingResponse {
+  // Empty
+}
+
+message DeviceInfoRequest {
+  // Empty
+}
+
+message DeviceInfoResponse {
+  bool uses_password = 1;
+
+  // The name of the node, given by "App.set_name()"
+  string name = 2;
+
+  // The mac address of the device. For example "AC:BC:32:89:0E:A9"
+  string mac_address = 3;
+
+  // A string describing the ESPHome version. For example "1.10.0"
+  string esphome_core_version = 4;
+
+  // A string describing the date of compilation, this is generated by the compiler
+  // and therefore may not be in the same format all the time.
+  // If the user isn't using esphome, this will also not be set.
+  string compilation_time = 5;
+
+  // The model of the board. For example NodeMCU
+  string model = 6;
+
+  bool has_deep_sleep = 7;
+}
+
+message ListEntitiesRequest {
+  // Empty
+}
+
+message ListEntitiesBinarySensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string device_class = 5;
+  bool is_status_binary_sensor = 6;
+}
+message ListEntitiesCoverResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool is_optimistic = 5;
+}
+message ListEntitiesFanResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool supports_oscillation = 5;
+  bool supports_speed = 6;
+}
+message ListEntitiesLightResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  bool supports_brightness = 5;
+  bool supports_rgb = 6;
+  bool supports_white_value = 7;
+  bool supports_color_temperature = 8;
+  float min_mireds = 9;
+  float max_mireds = 10;
+  repeated string effects = 11;
+}
+message ListEntitiesSensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  string unit_of_measurement = 6;
+  int32 accuracy_decimals = 7;
+}
+message ListEntitiesSwitchResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool optimistic = 6;
+}
+message ListEntitiesTextSensorResponse {
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+}
+message ListEntitiesDoneResponse {
+  // Empty
+}
+
+message SubscribeStatesRequest {
+  // Empty
+}
+message BinarySensorStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+}
+message CoverStateResponse {
+  fixed32 key = 1;
+  enum CoverState {
+    OPEN = 0;
+    CLOSED = 1;
+  }
+  CoverState state = 2;
+}
+enum FanSpeed {
+  LOW = 0;
+  MEDIUM = 1;
+  HIGH = 2;
+}
+message FanStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+  bool oscillating = 3;
+  FanSpeed speed = 4;
+}
+message LightStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+  float brightness = 3;
+  float red = 4;
+  float green = 5;
+  float blue = 6;
+  float white = 7;
+  float color_temperature = 8;
+  string effect = 9;
+}
+message SensorStateResponse {
+  fixed32 key = 1;
+  float state = 2;
+}
+message SwitchStateResponse {
+  fixed32 key = 1;
+  bool state = 2;
+}
+message TextSensorStateResponse {
+  fixed32 key = 1;
+  string state = 2;
+}
+
+message CoverCommandRequest {
+  fixed32 key = 1;
+  enum CoverCommand {
+    OPEN = 0;
+    CLOSE = 1;
+    STOP = 2;
+  }
+  bool has_state = 2;
+  CoverCommand command = 3;
+}
+message FanCommandRequest {
+  fixed32 key = 1;
+  bool has_state = 2;
+  bool state = 3;
+  bool has_speed = 4;
+  FanSpeed speed = 5;
+  bool has_oscillating = 6;
+  bool oscillating = 7;
+}
+message LightCommandRequest {
+  fixed32 key = 1;
+  bool has_state = 2;
+  bool state = 3;
+  bool has_brightness = 4;
+  float brightness = 5;
+  bool has_rgb = 6;
+  float red = 7;
+  float green = 8;
+  float blue = 9;
+  bool has_white = 10;
+  float white = 11;
+  bool has_color_temperature = 12;
+  float color_temperature = 13;
+  bool has_transition_length = 14;
+  uint32 transition_length = 15;
+  bool has_flash_length = 16;
+  uint32 flash_length = 17;
+  bool has_effect = 18;
+  string effect = 19;
+}
+message SwitchCommandRequest {
+  fixed32 key = 1;
+  bool state = 2;
+}
+
+enum LogLevel {
+  NONE = 0;
+  ERROR = 1;
+  WARN = 2;
+  INFO = 3;
+  DEBUG = 4;
+  VERBOSE = 5;
+  VERY_VERBOSE = 6;
+}
+
+message SubscribeLogsRequest {
+  LogLevel level = 1;
+  bool dump_config = 2;
+}
+
+message SubscribeLogsResponse {
+  LogLevel level = 1;
+  string tag = 2;
+  string message = 3;
+  bool send_failed = 4;
+}
+
+message SubscribeServiceCallsRequest {
+
+}
+
+message ServiceCallResponse {
+  string service = 1;
+  map<string, string> data = 2;
+  map<string, string> data_template = 3;
+  map<string, string> variables = 4;
+}
+
+// 1. Client sends SubscribeHomeAssistantStatesRequest
+// 2. Server responds with zero or more SubscribeHomeAssistantStateResponse (async)
+// 3. Client sends HomeAssistantStateResponse for state changes.
+message SubscribeHomeAssistantStatesRequest {
+
+}
+
+message SubscribeHomeAssistantStateResponse {
+  string entity_id = 1;
+}
+
+message HomeAssistantStateResponse {
+  string entity_id = 1;
+  string state = 2;
+}
+
+message GetTimeRequest {
+
+}
+
+message GetTimeResponse {
+  fixed32 epoch_seconds = 1;
+}
+

esphome/api/client.py

@@ -0,0 +1,495 @@
+from datetime import datetime
+import functools
+import logging
+import socket
+import threading
+import time
+
+# pylint: disable=unused-import
+from typing import Optional  # noqa
+from google.protobuf import message  # noqa
+
+from esphome import const
+import esphome.api.api_pb2 as pb
+from esphome.const import CONF_PASSWORD, CONF_PORT
+from esphome.core import EsphomeError
+from esphome.helpers import resolve_ip_address, indent, color
+from esphome.py_compat import text_type, IS_PY2, byte_to_bytes, char_to_byte, format_bytes
+from esphome.util import safe_print
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIConnectionError(EsphomeError):
+    pass
+
+
+MESSAGE_TYPE_TO_PROTO = {
+    1: pb.HelloRequest,
+    2: pb.HelloResponse,
+    3: pb.ConnectRequest,
+    4: pb.ConnectResponse,
+    5: pb.DisconnectRequest,
+    6: pb.DisconnectResponse,
+    7: pb.PingRequest,
+    8: pb.PingResponse,
+    9: pb.DeviceInfoRequest,
+    10: pb.DeviceInfoResponse,
+    11: pb.ListEntitiesRequest,
+    12: pb.ListEntitiesBinarySensorResponse,
+    13: pb.ListEntitiesCoverResponse,
+    14: pb.ListEntitiesFanResponse,
+    15: pb.ListEntitiesLightResponse,
+    16: pb.ListEntitiesSensorResponse,
+    17: pb.ListEntitiesSwitchResponse,
+    18: pb.ListEntitiesTextSensorResponse,
+    19: pb.ListEntitiesDoneResponse,
+    20: pb.SubscribeStatesRequest,
+    21: pb.BinarySensorStateResponse,
+    22: pb.CoverStateResponse,
+    23: pb.FanStateResponse,
+    24: pb.LightStateResponse,
+    25: pb.SensorStateResponse,
+    26: pb.SwitchStateResponse,
+    27: pb.TextSensorStateResponse,
+    28: pb.SubscribeLogsRequest,
+    29: pb.SubscribeLogsResponse,
+    30: pb.CoverCommandRequest,
+    31: pb.FanCommandRequest,
+    32: pb.LightCommandRequest,
+    33: pb.SwitchCommandRequest,
+    34: pb.SubscribeServiceCallsRequest,
+    35: pb.ServiceCallResponse,
+    36: pb.GetTimeRequest,
+    37: pb.GetTimeResponse,
+}
+
+
+def _varuint_to_bytes(value):
+    if value <= 0x7F:
+        return byte_to_bytes(value)
+
+    ret = bytes()
+    while value:
+        temp = value & 0x7F
+        value >>= 7
+        if value:
+            ret += byte_to_bytes(temp | 0x80)
+        else:
+            ret += byte_to_bytes(temp)
+
+    return ret
+
+
+def _bytes_to_varuint(value):
+    result = 0
+    bitpos = 0
+    for c in value:
+        val = char_to_byte(c)
+        result |= (val & 0x7F) << bitpos
+        bitpos += 7
+        if (val & 0x80) == 0:
+            return result
+    return None
+
+
+# pylint: disable=too-many-instance-attributes,not-callable
+class APIClient(threading.Thread):
+    def __init__(self, address, port, password):
+        threading.Thread.__init__(self)
+        self._address = address  # type: str
+        self._port = port  # type: int
+        self._password = password  # type: Optional[str]
+        self._socket = None  # type: Optional[socket.socket]
+        self._socket_open_event = threading.Event()
+        self._socket_write_lock = threading.Lock()
+        self._connected = False
+        self._authenticated = False
+        self._message_handlers = []
+        self._keepalive = 5
+        self._ping_timer = None
+        self._refresh_ping()
+
+        self.on_disconnect = None
+        self.on_connect = None
+        self.on_login = None
+        self.auto_reconnect = False
+        self._running_event = threading.Event()
+        self._stop_event = threading.Event()
+
+    @property
+    def stopped(self):
+        return self._stop_event.is_set()
+
+    def _refresh_ping(self):
+        if self._ping_timer is not None:
+            self._ping_timer.cancel()
+            self._ping_timer = None
+
+        def func():
+            self._ping_timer = None
+
+            if self._connected:
+                try:
+                    self.ping()
+                except APIConnectionError:
+                    self._fatal_error()
+                else:
+                    self._refresh_ping()
+
+        self._ping_timer = threading.Timer(self._keepalive, func)
+        self._ping_timer.start()
+
+    def _cancel_ping(self):
+        if self._ping_timer is not None:
+            self._ping_timer.cancel()
+            self._ping_timer = None
+
+    def _close_socket(self):
+        self._cancel_ping()
+        if self._socket is not None:
+            self._socket.close()
+            self._socket = None
+        self._socket_open_event.clear()
+        self._connected = False
+        self._authenticated = False
+        self._message_handlers = []
+
+    def stop(self, force=False):
+        if self.stopped:
+            raise ValueError
+
+        if self._connected and not force:
+            try:
+                self.disconnect()
+            except APIConnectionError:
+                pass
+        self._close_socket()
+
+        self._stop_event.set()
+        if not force:
+            self.join()
+
+    def connect(self):
+        if not self._running_event.wait(0.1):
+            raise APIConnectionError("You need to call start() first!")
+
+        if self._connected:
+            raise APIConnectionError("Already connected!")
+
+        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)")
+            raise APIConnectionError(err)
+
+        _LOGGER.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._socket.settimeout(10.0)
+        self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        try:
+            self._socket.connect((ip, self._port))
+        except socket.error as err:
+            self._fatal_error()
+            raise APIConnectionError("Error connecting to {}: {}".format(ip, err))
+        self._socket.settimeout(0.1)
+
+        self._socket_open_event.set()
+
+        hello = pb.HelloRequest()
+        hello.client_info = 'ESPHome v{}'.format(const.__version__)
+        try:
+            resp = self._send_message_await_response(hello, pb.HelloResponse)
+        except APIConnectionError as err:
+            self._fatal_error()
+            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)
+        self._connected = True
+        if self.on_connect is not None:
+            self.on_connect()
+
+    def _check_connected(self):
+        if not self._connected:
+            self._fatal_error()
+            raise APIConnectionError("Must be connected!")
+
+    def login(self):
+        self._check_connected()
+        if self._authenticated:
+            raise APIConnectionError("Already logged in!")
+
+        connect = pb.ConnectRequest()
+        if self._password is not None:
+            connect.password = self._password
+        resp = self._send_message_await_response(connect, pb.ConnectResponse)
+        if resp.invalid_password:
+            raise APIConnectionError("Invalid password!")
+
+        self._authenticated = True
+        if self.on_login is not None:
+            self.on_login()
+
+    def _fatal_error(self):
+        was_connected = self._connected
+
+        self._close_socket()
+
+        if was_connected and self.on_disconnect is not None:
+            self.on_disconnect()
+
+    def _write(self, data):  # type: (bytes) -> None
+        if self._socket is None:
+            raise APIConnectionError("Socket closed")
+
+        _LOGGER.debug("Write: %s", format_bytes(data))
+        with self._socket_write_lock:
+            try:
+                self._socket.sendall(data)
+            except socket.error as err:
+                self._fatal_error()
+                raise APIConnectionError("Error while writing data: {}".format(err))
+
+    def _send_message(self, msg):
+        # type: (message.Message) -> None
+        for message_type, klass in MESSAGE_TYPE_TO_PROTO.items():
+            if isinstance(msg, klass):
+                break
+        else:
+            raise ValueError
+
+        encoded = msg.SerializeToString()
+        _LOGGER.debug("Sending %s:\n%s", type(msg), indent(text_type(msg)))
+        if IS_PY2:
+            req = chr(0x00)
+        else:
+            req = bytes([0])
+        req += _varuint_to_bytes(len(encoded))
+        req += _varuint_to_bytes(message_type)
+        req += encoded
+        self._write(req)
+        self._refresh_ping()
+
+    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=1):
+        event = threading.Event()
+        responses = []
+
+        def on_message(resp):
+            if do_append(resp):
+                responses.append(resp)
+            if do_stop(resp):
+                event.set()
+
+        self._message_handlers.append(on_message)
+        self._send_message(send_msg)
+        ret = event.wait(timeout)
+        try:
+            self._message_handlers.remove(on_message)
+        except ValueError:
+            pass
+        if not ret:
+            raise APIConnectionError("Timeout while waiting for message response!")
+        return responses
+
+    def _send_message_await_response(self, send_msg, response_type, timeout=1):
+        def is_response(msg):
+            return isinstance(msg, response_type)
+
+        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)
+
+    def ping(self):
+        self._check_connected()
+        return self._send_message_await_response(pb.PingRequest(), pb.PingResponse)
+
+    def disconnect(self):
+        self._check_connected()
+
+        try:
+            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
+        except APIConnectionError:
+            pass
+        self._close_socket()
+
+        if self.on_disconnect is not None:
+            self.on_disconnect()
+
+    def _check_authenticated(self):
+        if not self._authenticated:
+            raise APIConnectionError("Must login first!")
+
+    def subscribe_logs(self, on_log, log_level=None, dump_config=False):
+        self._check_authenticated()
+
+        def on_msg(msg):
+            if isinstance(msg, pb.SubscribeLogsResponse):
+                on_log(msg)
+
+        self._message_handlers.append(on_msg)
+        req = pb.SubscribeLogsRequest(dump_config=dump_config)
+        if log_level is not None:
+            req.level = log_level
+        self._send_message(req)
+
+    def _recv(self, amount):
+        ret = bytes()
+        if amount == 0:
+            return ret
+
+        while len(ret) < amount:
+            if self.stopped:
+                raise APIConnectionError("Stopped!")
+            if not self._socket_open_event.is_set():
+                raise APIConnectionError("No socket!")
+            try:
+                val = self._socket.recv(amount - len(ret))
+            except AttributeError:
+                raise APIConnectionError("Socket was closed")
+            except socket.timeout:
+                continue
+            except socket.error as err:
+                raise APIConnectionError("Error while receiving data: {}".format(err))
+            ret += val
+        return ret
+
+    def _recv_varint(self):
+        raw = bytes()
+        while not raw or char_to_byte(raw[-1]) & 0x80:
+            raw += self._recv(1)
+        return _bytes_to_varuint(raw)
+
+    def _run_once(self):
+        if not self._socket_open_event.wait(0.1):
+            return
+
+        # Preamble
+        if char_to_byte(self._recv(1)[0]) != 0x00:
+            raise APIConnectionError("Invalid preamble")
+
+        length = self._recv_varint()
+        msg_type = self._recv_varint()
+
+        raw_msg = self._recv(length)
+        if msg_type not in MESSAGE_TYPE_TO_PROTO:
+            _LOGGER.debug("Skipping message type %s", msg_type)
+            return
+
+        msg = MESSAGE_TYPE_TO_PROTO[msg_type]()
+        msg.ParseFromString(raw_msg)
+        _LOGGER.debug("Got message: %s:\n%s", type(msg), indent(str(msg)))
+        for msg_handler in self._message_handlers[:]:
+            msg_handler(msg)
+        self._handle_internal_messages(msg)
+        self._refresh_ping()
+
+    def run(self):
+        self._running_event.set()
+        while not self.stopped:
+            try:
+                self._run_once()
+            except APIConnectionError as err:
+                if self.stopped:
+                    break
+                if self._connected:
+                    _LOGGER.error("Error while reading incoming messages: %s", err)
+                    self._fatal_error()
+        self._running_event.clear()
+
+    def _handle_internal_messages(self, msg):
+        if isinstance(msg, pb.DisconnectRequest):
+            self._send_message(pb.DisconnectResponse())
+            if self._socket is not None:
+                self._socket.close()
+                self._socket = None
+            self._connected = False
+            if self.on_disconnect is not None:
+                self.on_disconnect()
+        elif isinstance(msg, pb.PingRequest):
+            self._send_message(pb.PingResponse())
+        elif isinstance(msg, pb.GetTimeRequest):
+            resp = pb.GetTimeResponse()
+            resp.epoch_seconds = int(time.time())
+            self._send_message(resp)
+
+
+def run_logs(config, address):
+    conf = config['api']
+    port = conf[CONF_PORT]
+    password = conf[CONF_PASSWORD]
+    _LOGGER.info("Starting log output from %s using esphome API", address)
+
+    cli = APIClient(address, port, password)
+    stopping = False
+    retry_timer = []
+
+    has_connects = []
+
+    def try_connect(tries=0, is_disconnect=True):
+        if stopping:
+            return
+
+        if is_disconnect:
+            _LOGGER.warning(u"Disconnected from API.")
+
+        while retry_timer:
+            retry_timer.pop(0).cancel()
+
+        error = None
+        try:
+            cli.connect()
+            cli.login()
+        except APIConnectionError as err:  # noqa
+            error = err
+
+        if error is None:
+            _LOGGER.info("Successfully connected to %s", address)
+            return
+
+        wait_time = min(2**tries, 300)
+        if not has_connects:
+            _LOGGER.warning(u"Initial connection failed. The ESP might not be connected "
+                            u"to WiFi yet (%s). Re-Trying in %s seconds",
+                            error, wait_time)
+        else:
+            _LOGGER.warning(u"Couldn't connect to API (%s). Trying to reconnect in %s seconds",
+                            error, wait_time)
+        timer = threading.Timer(wait_time, functools.partial(try_connect, tries + 1, is_disconnect))
+        timer.start()
+        retry_timer.append(timer)
+
+    def on_log(msg):
+        time_ = datetime.now().time().strftime(u'[%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)')
+        safe_print(time_ + text)
+
+    def on_login():
+        try:
+            cli.subscribe_logs(on_log, dump_config=not has_connects)
+            has_connects.append(True)
+        except APIConnectionError:
+            cli.disconnect()
+
+    cli.on_disconnect = try_connect
+    cli.on_login = on_login
+    cli.start()
+
+    try:
+        try_connect(is_disconnect=False)
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        stopping = True
+        cli.stop(True)
+        while retry_timer:
+            retry_timer.pop(0).cancel()
+    return 0

esphome/automation.py

@@ -0,0 +1,384 @@
+import copy
+
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_ABOVE, CONF_ACTION_ID, CONF_AND, CONF_AUTOMATION_ID, CONF_BELOW, \
+    CONF_CONDITION, CONF_CONDITION_ID, CONF_DELAY, CONF_ELSE, CONF_ID, CONF_IF, CONF_LAMBDA, \
+    CONF_OR, CONF_RANGE, CONF_THEN, CONF_TRIGGER_ID, CONF_WAIT_UNTIL, CONF_WHILE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, TemplateArguments, add, get_variable, \
+    process_lambda, templatable
+from esphome.cpp_types import Action, App, Component, PollingComponent, Trigger, bool_, \
+    esphome_ns, float_, uint32, void
+from esphome.util import ServiceRegistry
+
+
+def maybe_simple_id(*validators):
+    validator = vol.All(*validators)
+
+    def validate(value):
+        if isinstance(value, dict):
+            return validator(value)
+        return validator({CONF_ID: value})
+
+    return validate
+
+
+def validate_recursive_condition(value):
+    is_list = isinstance(value, list)
+    value = cv.ensure_list()(value)[:]
+    for i, item in enumerate(value):
+        path = [i] if is_list else []
+        item = copy.deepcopy(item)
+        if not isinstance(item, dict):
+            raise vol.Invalid(u"Condition must consist of key-value mapping! Got {}".format(item),
+                              path)
+        key = next((x for x in item if x != CONF_CONDITION_ID), None)
+        if key is None:
+            raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
+        if key not in CONDITION_REGISTRY:
+            raise vol.Invalid(u"Unable to find condition with the name '{}', is the "
+                              u"component loaded?".format(key), path + [key])
+        item.setdefault(CONF_CONDITION_ID, None)
+        key2 = next((x for x in item if x not in (CONF_CONDITION_ID, key)), None)
+        if key2 is not None:
+            raise vol.Invalid(u"Cannot have two conditions in one item. Key '{}' overrides '{}'! "
+                              u"Did you forget to indent the block inside the condition?"
+                              u"".format(key, key2), path)
+        validator = CONDITION_REGISTRY[key][0]
+        try:
+            condition = validator(item[key] or {})
+        except vol.Invalid as err:
+            err.prepend(path)
+            raise err
+        value[i] = {
+            CONF_CONDITION_ID: cv.declare_variable_id(Condition)(item[CONF_CONDITION_ID]),
+            key: condition,
+        }
+    return value
+
+
+def validate_recursive_action(value):
+    is_list = isinstance(value, list)
+    if not is_list:
+        value = [value]
+    for i, item in enumerate(value):
+        path = [i] if is_list else []
+        item = copy.deepcopy(item)
+        if not isinstance(item, dict):
+            raise vol.Invalid(u"Action must consist of key-value mapping! Got {}".format(item),
+                              path)
+        key = next((x for x in item if x != CONF_ACTION_ID), None)
+        if key is None:
+            raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
+        if key not in ACTION_REGISTRY:
+            raise vol.Invalid(u"Unable to find action with the name '{}', is the component loaded?"
+                              u"".format(key), path + [key])
+        item.setdefault(CONF_ACTION_ID, None)
+        key2 = next((x for x in item if x not in (CONF_ACTION_ID, key)), None)
+        if key2 is not None:
+            raise vol.Invalid(u"Cannot have two actions in one item. Key '{}' overrides '{}'! "
+                              u"Did you forget to indent the block inside the action?"
+                              u"".format(key, key2), path)
+        validator = ACTION_REGISTRY[key][0]
+        try:
+            action = validator(item[key] or {})
+        except vol.Invalid as err:
+            err.prepend(path)
+            raise err
+        value[i] = {
+            CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
+            key: action,
+        }
+    return value
+
+
+ACTION_REGISTRY = ServiceRegistry()
+CONDITION_REGISTRY = ServiceRegistry()
+
+# pylint: disable=invalid-name
+DelayAction = esphome_ns.class_('DelayAction', Action, Component)
+LambdaAction = esphome_ns.class_('LambdaAction', Action)
+IfAction = esphome_ns.class_('IfAction', Action)
+WhileAction = esphome_ns.class_('WhileAction', Action)
+WaitUntilAction = esphome_ns.class_('WaitUntilAction', Action, Component)
+UpdateComponentAction = esphome_ns.class_('UpdateComponentAction', Action)
+Automation = esphome_ns.class_('Automation')
+
+Condition = esphome_ns.class_('Condition')
+AndCondition = esphome_ns.class_('AndCondition', Condition)
+OrCondition = esphome_ns.class_('OrCondition', Condition)
+RangeCondition = esphome_ns.class_('RangeCondition', Condition)
+LambdaCondition = esphome_ns.class_('LambdaCondition', Condition)
+
+
+def validate_automation(extra_schema=None, extra_validators=None, single=False):
+    if extra_schema is None:
+        extra_schema = {}
+    if isinstance(extra_schema, vol.Schema):
+        extra_schema = extra_schema.schema
+    schema = AUTOMATION_SCHEMA.extend(extra_schema)
+
+    def validator_(value):
+        if isinstance(value, list):
+            try:
+                # First try as a sequence of actions
+                return [schema({CONF_THEN: value})]
+            except vol.Invalid as err:
+                if err.path and err.path[0] == CONF_THEN:
+                    err.path.pop(0)
+
+                # Next try as a sequence of automations
+                try:
+                    return cv.Schema([schema])(value)
+                except vol.Invalid as err2:
+                    if 'Unable to find action' in str(err):
+                        raise err2
+                    raise vol.MultipleInvalid([err, err2])
+        elif isinstance(value, dict):
+            if CONF_THEN in value:
+                return [schema(value)]
+            return [schema({CONF_THEN: value})]
+        # This should only happen with invalid configs, but let's have a nice error message.
+        return [schema(value)]
+
+    def validator(value):
+        value = validator_(value)
+        if extra_validators is not None:
+            value = cv.Schema([extra_validators])(value)
+        if single:
+            if len(value) != 1:
+                raise vol.Invalid("Cannot have more than 1 automation for templates")
+            return value[0]
+        return value
+
+    return validator
+
+
+AUTOMATION_SCHEMA = cv.Schema({
+    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(Trigger),
+    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(Automation),
+    vol.Required(CONF_THEN): validate_recursive_action,
+})
+
+AND_CONDITION_SCHEMA = validate_recursive_condition
+
+
+@CONDITION_REGISTRY.register(CONF_AND, AND_CONDITION_SCHEMA)
+def and_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = AndCondition.new(template_arg, conditions)
+    type = AndCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+OR_CONDITION_SCHEMA = validate_recursive_condition
+
+
+@CONDITION_REGISTRY.register(CONF_OR, OR_CONDITION_SCHEMA)
+def or_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = OrCondition.new(template_arg, conditions)
+    type = OrCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+RANGE_CONDITION_SCHEMA = vol.All(cv.Schema({
+    vol.Optional(CONF_ABOVE): cv.templatable(cv.float_),
+    vol.Optional(CONF_BELOW): cv.templatable(cv.float_),
+}), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
+
+
+@CONDITION_REGISTRY.register(CONF_RANGE, RANGE_CONDITION_SCHEMA)
+def range_condition_to_code(config, condition_id, template_arg, args):
+    for conditions in build_conditions(config, template_arg, args):
+        yield
+    rhs = RangeCondition.new(template_arg, conditions)
+    type = RangeCondition.template(template_arg)
+    condition = Pvariable(condition_id, rhs, type=type)
+    if CONF_ABOVE in config:
+        for template_ in templatable(config[CONF_ABOVE], args, float_):
+            yield
+        condition.set_min(template_)
+    if CONF_BELOW in config:
+        for template_ in templatable(config[CONF_BELOW], args, float_):
+            yield
+        condition.set_max(template_)
+    yield condition
+
+
+DELAY_ACTION_SCHEMA = cv.templatable(cv.positive_time_period_milliseconds)
+
+
+@ACTION_REGISTRY.register(CONF_DELAY, DELAY_ACTION_SCHEMA)
+def delay_action_to_code(config, action_id, template_arg, args):
+    rhs = App.register_component(DelayAction.new(template_arg))
+    type = DelayAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config, args, uint32):
+        yield
+    add(action.set_delay(template_))
+    yield action
+
+
+IF_ACTION_SCHEMA = vol.All({
+    vol.Required(CONF_CONDITION): validate_recursive_condition,
+    vol.Optional(CONF_THEN): validate_recursive_action,
+    vol.Optional(CONF_ELSE): validate_recursive_action,
+}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE))
+
+
+@ACTION_REGISTRY.register(CONF_IF, IF_ACTION_SCHEMA)
+def if_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = IfAction.new(template_arg, conditions)
+    type = IfAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    if CONF_THEN in config:
+        for actions in build_actions(config[CONF_THEN], template_arg, args):
+            yield None
+        add(action.add_then(actions))
+    if CONF_ELSE in config:
+        for actions in build_actions(config[CONF_ELSE], template_arg, args):
+            yield None
+        add(action.add_else(actions))
+    yield action
+
+
+WHILE_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_CONDITION): validate_recursive_condition,
+    vol.Required(CONF_THEN): validate_recursive_action,
+})
+
+
+@ACTION_REGISTRY.register(CONF_WHILE, WHILE_ACTION_SCHEMA)
+def while_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = WhileAction.new(template_arg, conditions)
+    type = WhileAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for actions in build_actions(config[CONF_THEN], template_arg, args):
+        yield None
+    add(action.add_then(actions))
+    yield action
+
+
+def validate_wait_until(value):
+    schema = cv.Schema({
+        vol.Required(CONF_CONDITION): validate_recursive_condition
+    })
+    if isinstance(value, dict) and CONF_CONDITION in value:
+        return schema(value)
+    return validate_wait_until({CONF_CONDITION: value})
+
+
+WAIT_UNTIL_ACTION_SCHEMA = validate_wait_until
+
+
+@ACTION_REGISTRY.register(CONF_WAIT_UNTIL, WAIT_UNTIL_ACTION_SCHEMA)
+def wait_until_action_to_code(config, action_id, template_arg, args):
+    for conditions in build_conditions(config[CONF_CONDITION], template_arg, args):
+        yield None
+    rhs = WaitUntilAction.new(template_arg, conditions)
+    type = WaitUntilAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    add(App.register_component(action))
+    yield action
+
+
+LAMBDA_ACTION_SCHEMA = cv.lambda_
+
+
+@ACTION_REGISTRY.register(CONF_LAMBDA, LAMBDA_ACTION_SCHEMA)
+def lambda_action_to_code(config, action_id, template_arg, args):
+    for lambda_ in process_lambda(config, args, return_type=void):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+LAMBDA_CONDITION_SCHEMA = cv.lambda_
+
+
+@CONDITION_REGISTRY.register(CONF_LAMBDA, LAMBDA_CONDITION_SCHEMA)
+def lambda_condition_to_code(config, condition_id, template_arg, args):
+    for lambda_ in process_lambda(config, args, return_type=bool_):
+        yield
+    rhs = LambdaCondition.new(template_arg, lambda_)
+    type = LambdaCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_COMPONENT_UPDATE = 'component.update'
+COMPONENT_UPDATE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(PollingComponent),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COMPONENT_UPDATE, COMPONENT_UPDATE_ACTION_SCHEMA)
+def component_update_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = UpdateComponentAction.new(template_arg, var)
+    type = UpdateComponentAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+def build_action(full_config, template_arg, args):
+    action_id = full_config[CONF_ACTION_ID]
+    key, config = next((k, v) for k, v in full_config.items() if k in ACTION_REGISTRY)
+
+    builder = ACTION_REGISTRY[key][1]
+    for result in builder(config, action_id, template_arg, args):
+        yield None
+    yield result
+
+
+def build_actions(config, templ, arg_type):
+    actions = []
+    for conf in config:
+        for action in build_action(conf, templ, arg_type):
+            yield None
+        actions.append(action)
+    yield actions
+
+
+def build_condition(full_config, template_arg, args):
+    action_id = full_config[CONF_CONDITION_ID]
+    key, config = next((k, v) for k, v in full_config.items() if k in CONDITION_REGISTRY)
+
+    builder = CONDITION_REGISTRY[key][1]
+    for result in builder(config, action_id, template_arg, args):
+        yield None
+    yield result
+
+
+def build_conditions(config, templ, args):
+    conditions = []
+    for conf in config:
+        for condition in build_condition(conf, templ, args):
+            yield None
+        conditions.append(condition)
+    yield conditions
+
+
+def build_automation_(trigger, args, config):
+    arg_types = [arg[0] for arg in args]
+    templ = TemplateArguments(*arg_types)
+    rhs = App.make_automation(templ, trigger)
+    type = Automation.template(templ)
+    obj = Pvariable(config[CONF_AUTOMATION_ID], rhs, type=type)
+    for actions in build_actions(config[CONF_THEN], templ, args):
+        yield None
+    add(obj.add_actions(actions))
+    yield obj
+
+
+def build_automations(trigger, args, config):
+    CORE.add_job(build_automation_, trigger, args, config)

esphome/components/ads1115.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+ADS1115Component = sensor.sensor_ns.class_('ADS1115Component', Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ADS1115Component),
+    vol.Required(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_ads1115_component(config[CONF_ADDRESS])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphome/components/apds9960.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+CONF_APDS9960_ID = 'apds9960_id'
+APDS9960 = sensor.sensor_ns.class_('APDS9960', PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(APDS9960),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_apds9960(config.get(CONF_UPDATE_INTERVAL))
+    var = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_ADDRESS in config:
+        add(var.set_address(config[CONF_ADDRESS]))
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_APDS9960'

esphome/components/api.py

@@ -0,0 +1,141 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
+import esphome.config_validation as cv
+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
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, StoringController, esphome_ns, Trigger, \
+    bool_, int32, float_, std_string
+
+api_ns = esphome_ns.namespace('api')
+APIServer = api_ns.class_('APIServer', Component, StoringController)
+HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', Action)
+KeyValuePair = api_ns.class_('KeyValuePair')
+TemplatableKeyValuePair = api_ns.class_('TemplatableKeyValuePair')
+APIConnectedCondition = api_ns.class_('APIConnectedCondition', Condition)
+
+UserService = api_ns.class_('UserService', Trigger)
+ServiceTypeArgument = api_ns.class_('ServiceTypeArgument')
+ServiceArgType = api_ns.enum('ServiceArgType')
+SERVICE_ARG_TYPES = {
+    'bool': ServiceArgType.SERVICE_ARG_TYPE_BOOL,
+    'int': ServiceArgType.SERVICE_ARG_TYPE_INT,
+    'float': ServiceArgType.SERVICE_ARG_TYPE_FLOAT,
+    'string': ServiceArgType.SERVICE_ARG_TYPE_STRING,
+}
+SERVICE_ARG_NATIVE_TYPES = {
+    'bool': bool_,
+    'int': int32,
+    'float': float_,
+    'string': std_string,
+}
+
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(APIServer),
+    vol.Optional(CONF_PORT, default=6053): cv.port,
+    vol.Optional(CONF_PASSWORD, default=''): cv.string_strict,
+    vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_SERVICES): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(UserService),
+        vol.Required(CONF_SERVICE): cv.valid_name,
+        vol.Optional(CONF_VARIABLES, default={}): cv.Schema({
+            cv.validate_id_name: cv.one_of(*SERVICE_ARG_TYPES, lower=True),
+        }),
+    }),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.init_api_server()
+    api = Pvariable(config[CONF_ID], rhs)
+
+    if config[CONF_PORT] != 6053:
+        add(api.set_port(config[CONF_PORT]))
+    if config.get(CONF_PASSWORD):
+        add(api.set_password(config[CONF_PASSWORD]))
+    if CONF_REBOOT_TIMEOUT in config:
+        add(api.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+
+    for conf in config.get(CONF_SERVICES, []):
+        template_args = []
+        func_args = []
+        service_type_args = []
+        for name, var_ in conf[CONF_VARIABLES].items():
+            native = SERVICE_ARG_NATIVE_TYPES[var_]
+            template_args.append(native)
+            func_args.append((native, name))
+            service_type_args.append(ServiceTypeArgument(name, SERVICE_ARG_TYPES[var_]))
+        func = api.make_user_service_trigger.template(*template_args)
+        rhs = func(conf[CONF_SERVICE], service_type_args)
+        type_ = UserService.template(*template_args)
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs, type=type_)
+        automation.build_automations(trigger, func_args, conf)
+
+    setup_component(api, config)
+
+
+BUILD_FLAGS = '-DUSE_API'
+
+
+def lib_deps(config):
+    if CORE.is_esp32:
+        return 'AsyncTCP@1.0.3'
+    if CORE.is_esp8266:
+        return 'ESPAsyncTCP@1.1.3'
+    raise NotImplementedError
+
+
+CONF_HOMEASSISTANT_SERVICE = 'homeassistant.service'
+HOMEASSISTANT_SERVIC_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(APIServer),
+    vol.Required(CONF_SERVICE): cv.string,
+    vol.Optional(CONF_DATA): cv.Schema({
+        cv.string: cv.string,
+    }),
+    vol.Optional(CONF_DATA_TEMPLATE): cv.Schema({
+        cv.string: cv.string,
+    }),
+    vol.Optional(CONF_VARIABLES): cv.Schema({
+        cv.string: cv.lambda_,
+    }),
+})
+
+
+@ACTION_REGISTRY.register(CONF_HOMEASSISTANT_SERVICE, HOMEASSISTANT_SERVIC_ACTION_SCHEMA)
+def homeassistant_service_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_home_assistant_service_call_action(template_arg)
+    type = HomeAssistantServiceCallAction.template(template_arg)
+    act = Pvariable(action_id, rhs, type=type)
+    add(act.set_service(config[CONF_SERVICE]))
+    if CONF_DATA in config:
+        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA].items()]
+        add(act.set_data(datas))
+    if CONF_DATA_TEMPLATE in config:
+        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA_TEMPLATE].items()]
+        add(act.set_data_template(datas))
+    if CONF_VARIABLES in config:
+        datas = []
+        for key, value in config[CONF_VARIABLES].items():
+            for value_ in process_lambda(value, []):
+                yield None
+            datas.append(TemplatableKeyValuePair(key, value_))
+        add(act.set_variables(datas))
+    yield act
+
+
+CONF_API_CONNECTED = 'api.connected'
+API_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_API_CONNECTED, API_CONNECTED_CONDITION_SCHEMA)
+def api_connected_to_code(config, condition_id, template_arg, args):
+    rhs = APIConnectedCondition.new(template_arg)
+    type = APIConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/binary_sensor/__init__.py

@@ -1,16 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml import automation, core
-from esphomeyaml.components import mqtt
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DELAYED_OFF, CONF_DELAYED_ON, CONF_DEVICE_CLASS, CONF_FILTERS, \
+from esphome import automation, core
+from esphome.automation import CONDITION_REGISTRY, Condition, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_DELAYED_OFF, CONF_DELAYED_ON, CONF_DEVICE_CLASS, CONF_FILTERS, \
     CONF_HEARTBEAT, CONF_ID, CONF_INTERNAL, CONF_INVALID_COOLDOWN, CONF_INVERT, CONF_INVERTED, \
     CONF_LAMBDA, CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_MQTT_ID, CONF_ON_CLICK, \
-    CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_STATE, \
-    CONF_TIMING, CONF_TRIGGER_ID
-from esphomeyaml.helpers import App, ArrayInitializer, NoArg, Pvariable, StructInitializer, add, \
-    add_job, bool_, esphomelib_ns, process_lambda, setup_mqtt_component, Nameable, Trigger, \
-    Component
+    CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_ON_STATE, \
+    CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable, process_lambda
+from esphome.cpp_types import App, Component, Nameable, Trigger, bool_, esphome_ns, optional
+from esphome.py_compat import string_types
 
 DEVICE_CLASSES = [
     '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@@ -23,17 +26,22 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-binary_sensor_ns = esphomelib_ns.namespace('binary_sensor')
+binary_sensor_ns = esphome_ns.namespace('binary_sensor')
 BinarySensor = binary_sensor_ns.class_('BinarySensor', Nameable)
+BinarySensorPtr = BinarySensor.operator('ptr')
 MQTTBinarySensorComponent = binary_sensor_ns.class_('MQTTBinarySensorComponent', mqtt.MQTTComponent)
 
 # Triggers
-PressTrigger = binary_sensor_ns.class_('PressTrigger', Trigger.template(NoArg))
-ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', Trigger.template(NoArg))
-ClickTrigger = binary_sensor_ns.class_('ClickTrigger', Trigger.template(NoArg))
-DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', Trigger.template(NoArg))
-MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', Trigger.template(NoArg), Component)
+PressTrigger = binary_sensor_ns.class_('PressTrigger', Trigger.template())
+ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', Trigger.template())
+ClickTrigger = binary_sensor_ns.class_('ClickTrigger', Trigger.template())
+DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', Trigger.template())
+MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', Trigger.template(), Component)
 MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
+StateTrigger = binary_sensor_ns.class_('StateTrigger', Trigger.template(bool_))
+
+# Condition
+BinarySensorCondition = binary_sensor_ns.class_('BinarySensorCondition', Condition)
 
 # Filters
 Filter = binary_sensor_ns.class_('Filter')
@@ -43,18 +51,18 @@ HeartbeatFilter = binary_sensor_ns.class_('HeartbeatFilter', Filter, Component)
 InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
 LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
 
-
 FILTER_KEYS = [CONF_INVERT, CONF_DELAYED_ON, CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT]
 
-FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
+FILTERS_SCHEMA = cv.ensure_list({
     vol.Optional(CONF_INVERT): None,
     vol.Optional(CONF_DELAYED_ON): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_DELAYED_OFF): cv.positive_time_period_milliseconds,
-    vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_LAMBDA): cv.lambda_,
-}, cv.has_exactly_one_key(*FILTER_KEYS))])
 
-MULTI_CLICK_TIMING_SCHEMA = vol.Schema({
+    vol.Optional(CONF_HEARTBEAT): cv.invalid("The heartbeat filter has been removed in 1.11.0"),
+}, cv.has_exactly_one_key(*FILTER_KEYS))
+
+MULTI_CLICK_TIMING_SCHEMA = cv.Schema({
     vol.Optional(CONF_STATE): cv.boolean,
     vol.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds,
@@ -62,7 +70,7 @@ MULTI_CLICK_TIMING_SCHEMA = vol.Schema({
 
 
 def parse_multi_click_timing_str(value):
-    if not isinstance(value, basestring):
+    if not isinstance(value, string_types):
         return value
 
     parts = value.lower().split(' ')
@@ -150,7 +158,7 @@ def validate_multi_click_timing(value):
 BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
     cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTBinarySensorComponent),
 
-    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower, cv.one_of(*DEVICE_CLASSES)),
+    vol.Optional(CONF_DEVICE_CLASS): cv.one_of(*DEVICE_CLASSES, lower=True),
     vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
     vol.Optional(CONF_ON_PRESS): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PressTrigger),
@@ -174,11 +182,14 @@ BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
                                            validate_multi_click_timing),
         vol.Optional(CONF_INVALID_COOLDOWN): cv.positive_time_period_milliseconds,
     }),
+    vol.Optional(CONF_ON_STATE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StateTrigger),
+    }),
 
     vol.Optional(CONF_INVERTED): cv.invalid(
         "The inverted binary_sensor property has been replaced by the "
         "new 'invert' binary  sensor filter. Please see "
-        "https://esphomelib.com/esphomeyaml/components/binary_sensor/index.html."
+        "https://esphome.io/components/binary_sensor/index.html."
     ),
 })
 
@@ -192,11 +203,9 @@ def setup_filter(config):
         yield App.register_component(DelayedOffFilter.new(config[CONF_DELAYED_OFF]))
     elif CONF_DELAYED_ON in config:
         yield App.register_component(DelayedOnFilter.new(config[CONF_DELAYED_ON]))
-    elif CONF_HEARTBEAT in config:
-        yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
     elif CONF_LAMBDA in config:
-        lambda_ = None
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')],
+                                      return_type=optional.template(bool_)):
             yield None
         yield LambdaFilter.new(lambda_)
 
@@ -204,14 +213,13 @@ def setup_filter(config):
 def setup_filters(config):
     filters = []
     for conf in config:
-        filter = None
         for filter in setup_filter(conf):
             yield None
         filters.append(filter)
-    yield ArrayInitializer(*filters)
+    yield filters
 
 
-def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
+def setup_binary_sensor_core_(binary_sensor_var, config):
     if CONF_INTERNAL in config:
         add(binary_sensor_var.set_internal(CONF_INTERNAL))
     if CONF_DEVICE_CLASS in config:
@@ -219,7 +227,6 @@ def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
     if CONF_INVERTED in config:
         add(binary_sensor_var.set_inverted(config[CONF_INVERTED]))
     if CONF_FILTERS in config:
-        filters = None
         for filters in setup_filters(config[CONF_FILTERS]):
             yield
         add(binary_sensor_var.add_filters(filters))
@@ -227,23 +234,23 @@ def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
     for conf in config.get(CONF_ON_PRESS, []):
         rhs = binary_sensor_var.make_press_trigger()
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
     for conf in config.get(CONF_ON_RELEASE, []):
         rhs = binary_sensor_var.make_release_trigger()
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
     for conf in config.get(CONF_ON_CLICK, []):
         rhs = binary_sensor_var.make_click_trigger(conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH])
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
     for conf in config.get(CONF_ON_DOUBLE_CLICK, []):
         rhs = binary_sensor_var.make_double_click_trigger(conf[CONF_MIN_LENGTH],
                                                           conf[CONF_MAX_LENGTH])
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
     for conf in config.get(CONF_ON_MULTI_CLICK, []):
         timings = []
@@ -254,39 +261,61 @@ def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
                 ('min_length', tim[CONF_MIN_LENGTH]),
                 ('max_length', tim.get(CONF_MAX_LENGTH, 4294967294)),
             ))
-        timings = ArrayInitializer(*timings, multiline=False)
         rhs = App.register_component(binary_sensor_var.make_multi_click_trigger(timings))
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
         if CONF_INVALID_COOLDOWN in conf:
             add(trigger.set_invalid_cooldown(conf[CONF_INVALID_COOLDOWN]))
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
-    setup_mqtt_component(mqtt_var, config)
+    for conf in config.get(CONF_ON_STATE, []):
+        rhs = binary_sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(bool_, 'x')], conf)
+
+    setup_mqtt_component(binary_sensor_var.Pget_mqtt(), config)
 
 
-def setup_binary_sensor(binary_sensor_obj, mqtt_obj, config):
-    binary_sensor_var = Pvariable(config[CONF_ID], binary_sensor_obj,
-                                  has_side_effects=False)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj,
-                         has_side_effects=False)
-    add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, config)
+def setup_binary_sensor(binary_sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        binary_sensor_obj = Pvariable(config[CONF_ID], binary_sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_binary_sensor_core_, binary_sensor_obj, config)
 
 
 def register_binary_sensor(var, config):
     binary_sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
-    rhs = App.register_binary_sensor(binary_sensor_var)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
-    add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, config)
-
-
-def core_to_hass_config(data, config):
-    ret = mqtt.build_hass_config(data, 'binary_sensor', config,
-                                 include_state=True, include_command=False)
-    if ret is None:
-        return None
-    if CONF_DEVICE_CLASS in config:
-        ret['device_class'] = config[CONF_DEVICE_CLASS]
-    return ret
+    add(App.register_binary_sensor(binary_sensor_var))
+    CORE.add_job(setup_binary_sensor_core_, binary_sensor_var, config)
 
 
 BUILD_FLAGS = '-DUSE_BINARY_SENSOR'
+
+CONF_BINARY_SENSOR_IS_ON = 'binary_sensor.is_on'
+BINARY_SENSOR_IS_ON_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinarySensor),
+    vol.Optional(CONF_FOR): cv.positive_time_period_milliseconds,
+})
+
+
+@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_ON, BINARY_SENSOR_IS_ON_CONDITION_SCHEMA)
+def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_is_on_condition(template_arg, config.get(CONF_FOR))
+    type = BinarySensorCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_BINARY_SENSOR_IS_OFF = 'binary_sensor.is_off'
+BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(BinarySensor),
+    vol.Optional(CONF_FOR): cv.positive_time_period_milliseconds,
+})
+
+
+@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_OFF, BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA)
+def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_is_off_condition(template_arg, config.get(CONF_FOR))
+    type = BinarySensorCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/binary_sensor/apds9960.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor, sensor
+from esphome.components.apds9960 import APDS9960, CONF_APDS9960_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_DIRECTION, CONF_NAME
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['apds9960']
+APDS9960GestureDirectionBinarySensor = sensor.sensor_ns.class_(
+    'APDS9960GestureDirectionBinarySensor', binary_sensor.BinarySensor)
+
+DIRECTIONS = {
+    'UP': 'make_up_direction',
+    'DOWN': 'make_down_direction',
+    'LEFT': 'make_left_direction',
+    'RIGHT': 'make_right_direction',
+}
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(APDS9960GestureDirectionBinarySensor),
+    vol.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
+    cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_APDS9960_ID]):
+        yield
+    func = getattr(hub, DIRECTIONS[config[CONF_DIRECTION]])
+    rhs = func(config[CONF_NAME])
+    binary_sensor.register_binary_sensor(rhs, config)

esphome/components/binary_sensor/custom.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA, CONF_NAME
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomBinarySensorConstructor = binary_sensor.binary_sensor_ns.class_(
+    'CustomBinarySensorConstructor')
+
+PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomBinarySensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_BINARY_SENSORS):
+        cv.ensure_list(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(binary_sensor.BinarySensor),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(binary_sensor.BinarySensorPtr)):
+        yield
+
+    rhs = CustomBinarySensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
+        rhs = custom.Pget_binary_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        binary_sensor.register_binary_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_BINARY_SENSOR'

esphome/components/binary_sensor/esp32_ble_tracker.py

@@ -1,14 +1,15 @@
 import voluptuous as vol
 
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+from esphome.components import binary_sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
     make_address_array
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_MAC_ADDRESS, CONF_NAME
-from esphomeyaml.helpers import esphomelib_ns, get_variable
+import esphome.config_validation as cv
+from esphome.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import esphome_ns
 
 DEPENDENCIES = ['esp32_ble_tracker']
-ESP32BLEPresenceDevice = esphomelib_ns.class_('ESP32BLEPresenceDevice', binary_sensor.BinarySensor)
+ESP32BLEPresenceDevice = esphome_ns.class_('ESP32BLEPresenceDevice', binary_sensor.BinarySensor)
 
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(ESP32BLEPresenceDevice),
@@ -18,12 +19,7 @@ PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend
 
 
 def to_code(config):
-    hub = None
     for hub in get_variable(config[CONF_ESP32_BLE_ID]):
         yield
     rhs = hub.make_presence_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
     binary_sensor.register_binary_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/esp32_touch.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.components.esp32_touch import ESP32TouchComponent
-from esphomeyaml.const import CONF_NAME, CONF_PIN, CONF_THRESHOLD, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import get_variable, global_ns
-from esphomeyaml.pins import validate_gpio_pin
+from esphome.components import binary_sensor
+from esphome.components.esp32_touch import ESP32TouchComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_PIN, CONF_THRESHOLD, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import global_ns
+from esphome.pins import validate_gpio_pin
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -55,7 +56,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/gpio.py

@@ -1,20 +1,19 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, gpio_input_pin_expression, variable, Application, \
-    setup_component, Component
+from esphome import pins
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component
 
-MakeGPIOBinarySensor = Application.struct('MakeGPIOBinarySensor')
 GPIOBinarySensorComponent = binary_sensor.binary_sensor_ns.class_('GPIOBinarySensorComponent',
                                                                   binary_sensor.BinarySensor,
                                                                   Component)
 
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(GPIOBinarySensorComponent),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOBinarySensor),
     vol.Required(CONF_PIN): pins.gpio_input_pin_schema
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
@@ -24,13 +23,9 @@ def to_code(config):
     for pin in gpio_input_pin_expression(config[CONF_PIN]):
         yield
     rhs = App.make_gpio_binary_sensor(config[CONF_NAME], pin)
-    gpio = variable(config[CONF_MAKE_ID], rhs)
-    binary_sensor.setup_binary_sensor(gpio.Pgpio, gpio.Pmqtt, config)
-    setup_component(gpio.Pgpio, config)
+    gpio = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(gpio, config)
+    setup_component(gpio, config)
 
 
 BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/homeassistant.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeassistantBinarySensor = binary_sensor.binary_sensor_ns.class_('HomeassistantBinarySensor',
+                                                                  binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantBinarySensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_binary_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    subs = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_BINARY_SENSOR'

esphome/components/binary_sensor/mpr121.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphome.components import binary_sensor
+from esphome.components.mpr121 import MPR121Component, CONF_MPR121_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_NAME
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['mpr121']
+MPR121Channel = binary_sensor.binary_sensor_ns.class_(
+    'MPR121Channel', binary_sensor.BinarySensor)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MPR121Channel),
+    cv.GenerateID(CONF_MPR121_ID): cv.use_variable_id(MPR121Component),
+    vol.Required(CONF_CHANNEL): vol.All(vol.Coerce(int), vol.Range(min=0, max=11))
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_MPR121_ID]):
+        yield
+    rhs = MPR121Channel.new(config[CONF_NAME], config[CONF_CHANNEL])
+    binary_sensor.register_binary_sensor(hub.add_channel(rhs), config)

esphome/components/binary_sensor/nextion.py

@@ -1,10 +1,10 @@
 import voluptuous as vol
 
-from esphomeyaml.components import binary_sensor, display
-from esphomeyaml.components.display.nextion import Nextion
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_COMPONENT_ID, CONF_NAME, CONF_PAGE_ID
-from esphomeyaml.helpers import get_variable
+from esphome.components import binary_sensor, display
+from esphome.components.display.nextion import Nextion
+import esphome.config_validation as cv
+from esphome.const import CONF_COMPONENT_ID, CONF_NAME, CONF_PAGE_ID
+from esphome.cpp_generator import get_variable
 
 DEPENDENCIES = ['display']
 
@@ -22,13 +22,8 @@ PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend
 
 
 def to_code(config):
-    hub = None
     for hub in get_variable(config[CONF_NEXTION_ID]):
         yield
     rhs = hub.make_touch_component(config[CONF_NAME], config[CONF_PAGE_ID],
                                    config[CONF_COMPONENT_ID])
     binary_sensor.register_binary_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/pn532.py

@@ -1,11 +1,11 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.components.pn532 import PN532Component
-from esphomeyaml.const import CONF_NAME, CONF_UID
-from esphomeyaml.core import HexInt
-from esphomeyaml.helpers import ArrayInitializer, get_variable
+from esphome.components import binary_sensor
+from esphome.components.pn532 import PN532Component
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_UID
+from esphome.core import HexInt
+from esphome.cpp_generator import get_variable
 
 DEPENDENCIES = ['pn532']
 
@@ -41,9 +41,5 @@ def to_code(config):
     for hub in get_variable(config[CONF_PN532_ID]):
         yield
     addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split('-')]
-    rhs = hub.make_tag(config[CONF_NAME], ArrayInitializer(*addr, multiline=False))
+    rhs = hub.make_tag(config[CONF_NAME], addr)
     binary_sensor.register_binary_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/rdm6300.py

@@ -1,9 +1,9 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import binary_sensor, rdm6300
-from esphomeyaml.const import CONF_NAME, CONF_UID
-from esphomeyaml.helpers import get_variable
+from esphome.components import binary_sensor, rdm6300
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_UID
+from esphome.cpp_generator import get_variable
 
 DEPENDENCIES = ['rdm6300']
 
@@ -24,7 +24,3 @@ def to_code(config):
         yield
     rhs = hub.make_card(config[CONF_NAME], config[CONF_UID])
     binary_sensor.register_binary_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/remote_receiver.py

@@ -1,62 +1,84 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.components.remote_receiver import RemoteReceiverComponent, remote_ns
-from esphomeyaml.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
+from esphome.components import binary_sensor
+from esphome.components.remote_receiver import RemoteReceiverComponent, remote_ns
+from esphome.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
     RC_SWITCH_TYPE_A_SCHEMA, RC_SWITCH_TYPE_B_SCHEMA, RC_SWITCH_TYPE_C_SCHEMA, \
     RC_SWITCH_TYPE_D_SCHEMA, binary_code, build_rc_switch_protocol
-from esphomeyaml.const import CONF_ADDRESS, CONF_CHANNEL, CONF_CODE, CONF_COMMAND, CONF_DATA, \
-    CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_LG, CONF_NAME, CONF_NBITS, CONF_NEC, \
-    CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, \
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CHANNEL, CONF_CODE, CONF_COMMAND, CONF_DATA, \
+    CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_JVC, CONF_LG, CONF_NAME, CONF_NBITS, \
+    CONF_NEC, CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, \
     CONF_RC_SWITCH_TYPE_B, CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_SAMSUNG, CONF_SONY, \
-    CONF_STATE
-from esphomeyaml.helpers import ArrayInitializer, Pvariable, get_variable
+    CONF_STATE, CONF_RC5
+from esphome.cpp_generator import Pvariable, get_variable, progmem_array
+from esphome.cpp_types import int32
 
 DEPENDENCIES = ['remote_receiver']
 
-REMOTE_KEYS = [CONF_NEC, CONF_LG, CONF_SONY, CONF_PANASONIC, CONF_SAMSUNG, CONF_RAW,
+REMOTE_KEYS = [CONF_JVC, CONF_NEC, CONF_LG, CONF_SONY, CONF_PANASONIC, CONF_SAMSUNG, CONF_RAW,
                CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B,
-               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D]
+               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_RC5]
 
 CONF_REMOTE_RECEIVER_ID = 'remote_receiver_id'
 CONF_RECEIVER_ID = 'receiver_id'
 
 RemoteReceiver = remote_ns.class_('RemoteReceiver', binary_sensor.BinarySensor)
+JVCReceiver = remote_ns.class_('JVCReceiver', RemoteReceiver)
 LGReceiver = remote_ns.class_('LGReceiver', RemoteReceiver)
 NECReceiver = remote_ns.class_('NECReceiver', RemoteReceiver)
 PanasonicReceiver = remote_ns.class_('PanasonicReceiver', RemoteReceiver)
 RawReceiver = remote_ns.class_('RawReceiver', RemoteReceiver)
 SamsungReceiver = remote_ns.class_('SamsungReceiver', RemoteReceiver)
 SonyReceiver = remote_ns.class_('SonyReceiver', RemoteReceiver)
+RC5Receiver = remote_ns.class_('RC5Receiver', RemoteReceiver)
 RCSwitchRawReceiver = remote_ns.class_('RCSwitchRawReceiver', RemoteReceiver)
 RCSwitchTypeAReceiver = remote_ns.class_('RCSwitchTypeAReceiver', RCSwitchRawReceiver)
 RCSwitchTypeBReceiver = remote_ns.class_('RCSwitchTypeBReceiver', RCSwitchRawReceiver)
 RCSwitchTypeCReceiver = remote_ns.class_('RCSwitchTypeCReceiver', RCSwitchRawReceiver)
 RCSwitchTypeDReceiver = remote_ns.class_('RCSwitchTypeDReceiver', RCSwitchRawReceiver)
 
+
+def validate_raw(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            cv.GenerateID(): cv.declare_variable_id(int32),
+            vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+        })(value)
+    return validate_raw({
+        CONF_DATA: value
+    })
+
+
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(RemoteReceiver),
-    vol.Optional(CONF_LG): vol.Schema({
+    vol.Optional(CONF_JVC): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), cv.one_of(28, 32)),
     }),
-    vol.Optional(CONF_NEC): vol.Schema({
+    vol.Optional(CONF_LG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
+    }),
+    vol.Optional(CONF_NEC): cv.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
         vol.Required(CONF_COMMAND): cv.hex_uint16_t,
     }),
-    vol.Optional(CONF_SAMSUNG): vol.Schema({
+    vol.Optional(CONF_SAMSUNG): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
     }),
-    vol.Optional(CONF_SONY): vol.Schema({
+    vol.Optional(CONF_SONY): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), cv.one_of(12, 15, 20)),
+        vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
     }),
-    vol.Optional(CONF_PANASONIC): vol.Schema({
+    vol.Optional(CONF_PANASONIC): cv.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
         vol.Required(CONF_COMMAND): cv.hex_uint32_t,
     }),
-    vol.Optional(CONF_RAW): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+    vol.Optional(CONF_RC5): cv.Schema({
+        vol.Required(CONF_ADDRESS): vol.All(cv.hex_int, vol.Range(min=0, max=0x1F)),
+        vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)),
+    }),
+    vol.Optional(CONF_RAW): validate_raw,
     vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
@@ -71,42 +93,46 @@ PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend
 def receiver_base(full_config):
     name = full_config[CONF_NAME]
     key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
+    if key == CONF_JVC:
+        return JVCReceiver.new(name, config[CONF_DATA])
     if key == CONF_LG:
         return LGReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
-    elif key == CONF_NEC:
+    if key == CONF_NEC:
         return NECReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    elif key == CONF_PANASONIC:
+    if key == CONF_PANASONIC:
         return PanasonicReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    elif key == CONF_SAMSUNG:
+    if key == CONF_SAMSUNG:
         return SamsungReceiver.new(name, config[CONF_DATA])
-    elif key == CONF_SONY:
+    if key == CONF_SONY:
         return SonyReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
-    elif key == CONF_RAW:
-        data = ArrayInitializer(*config, multiline=False)
-        return RawReceiver.new(name, data)
-    elif key == CONF_RC_SWITCH_RAW:
+    if key == CONF_RC5:
+        return RC5Receiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_RAW:
+        arr = progmem_array(config[CONF_ID], config[CONF_DATA])
+        return RawReceiver.new(name, arr, len(config[CONF_DATA]))
+    if key == CONF_RC_SWITCH_RAW:
         return RCSwitchRawReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                        binary_code(config[CONF_CODE]), len(config[CONF_CODE]))
-    elif key == CONF_RC_SWITCH_TYPE_A:
+    if key == CONF_RC_SWITCH_TYPE_A:
         return RCSwitchTypeAReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                          binary_code(config[CONF_GROUP]),
                                          binary_code(config[CONF_DEVICE]),
                                          config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_B:
+    if key == CONF_RC_SWITCH_TYPE_B:
         return RCSwitchTypeBReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                          config[CONF_ADDRESS], config[CONF_CHANNEL],
                                          config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_C:
+    if key == CONF_RC_SWITCH_TYPE_C:
         return RCSwitchTypeCReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                          ord(config[CONF_FAMILY][0]) - ord('a'),
                                          config[CONF_GROUP], config[CONF_DEVICE],
                                          config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_D:
+    if key == CONF_RC_SWITCH_TYPE_D:
         return RCSwitchTypeDReceiver.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                          ord(config[CONF_GROUP][0]) - ord('a'),
                                          config[CONF_DEVICE], config[CONF_STATE])
-    else:
-        raise NotImplementedError("Unknown receiver type {}".format(config))
+
+    raise NotImplementedError("Unknown receiver type {}".format(config))
 
 
 def to_code(config):
@@ -119,7 +145,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphome/components/binary_sensor/status.py

@@ -0,0 +1,24 @@
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+StatusBinarySensor = binary_sensor.binary_sensor_ns.class_('StatusBinarySensor',
+                                                           binary_sensor.BinarySensor,
+                                                           Component)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(StatusBinarySensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_status_binary_sensor(config[CONF_NAME])
+    status = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(status, config)
+    setup_component(status, config)
+
+
+BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'

esphome/components/binary_sensor/template.py

@@ -0,0 +1,56 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, bool_, optional
+
+TemplateBinarySensor = binary_sensor.binary_sensor_ns.class_('TemplateBinarySensor',
+                                                             binary_sensor.BinarySensor,
+                                                             Component)
+BinarySensorPublishAction = binary_sensor.binary_sensor_ns.class_('BinarySensorPublishAction',
+                                                                  Action)
+
+PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateBinarySensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_binary_sensor(config[CONF_NAME])
+    var = Pvariable(config[CONF_ID], rhs)
+    binary_sensor.setup_binary_sensor(var, config)
+    setup_component(var, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(bool_)):
+            yield
+        add(var.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'
+
+CONF_BINARY_SENSOR_TEMPLATE_PUBLISH = 'binary_sensor.template.publish'
+BINARY_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(binary_sensor.BinarySensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.boolean),
+})
+
+
+@ACTION_REGISTRY.register(CONF_BINARY_SENSOR_TEMPLATE_PUBLISH,
+                          BINARY_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def binary_sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_binary_sensor_publish_action(template_arg)
+    type = BinarySensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, bool_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/cover/__init__.py

@@ -1,17 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
-from esphomeyaml.components import mqtt
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_MQTT_ID, CONF_INTERNAL
-from esphomeyaml.helpers import Pvariable, esphomelib_ns, setup_mqtt_component, add, \
-    TemplateArguments, get_variable, Action, Nameable
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_types import Action, Nameable, esphome_ns
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-cover_ns = esphomelib_ns.namespace('cover')
+cover_ns = esphome_ns.namespace('cover')
 
 Cover = cover_ns.class_('Cover', Nameable)
 MQTTCoverComponent = cover_ns.class_('MQTTCoverComponent', mqtt.MQTTComponent)
@@ -20,6 +22,12 @@ CoverState = cover_ns.class_('CoverState')
 COVER_OPEN = cover_ns.COVER_OPEN
 COVER_CLOSED = cover_ns.COVER_CLOSED
 
+validate_cover_state = cv.one_of('OPEN', 'CLOSED', upper=True)
+COVER_STATES = {
+    'OPEN': COVER_OPEN,
+    'CLOSED': COVER_CLOSED,
+}
+
 # Actions
 OpenAction = cover_ns.class_('OpenAction', Action)
 CloseAction = cover_ns.class_('CloseAction', Action)
@@ -33,16 +41,14 @@ COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
 COVER_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(COVER_SCHEMA.schema)
 
 
-def setup_cover_core_(cover_var, mqtt_var, config):
+def setup_cover_core_(cover_var, config):
     if CONF_INTERNAL in config:
         add(cover_var.set_internal(config[CONF_INTERNAL]))
-    setup_mqtt_component(mqtt_var, config)
+    setup_mqtt_component(cover_var.Pget_mqtt(), config)
 
 
-def setup_cover(cover_obj, mqtt_obj, config):
-    cover_var = Pvariable(config[CONF_ID], cover_obj, has_side_effects=False)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
-    setup_cover_core_(cover_var, mqtt_var, config)
+def setup_cover(cover_obj, config):
+    CORE.add_job(setup_cover_core_, cover_obj, config)
 
 
 BUILD_FLAGS = '-DUSE_COVER'
@@ -54,12 +60,11 @@ COVER_OPEN_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_COVER_OPEN, COVER_OPEN_ACTION_SCHEMA)
-def cover_open_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def cover_open_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_open_action(template_arg)
-    type = OpenAction.template(arg_type)
+    type = OpenAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -70,12 +75,11 @@ COVER_CLOSE_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_COVER_CLOSE, COVER_CLOSE_ACTION_SCHEMA)
-def cover_close_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def cover_close_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_close_action(template_arg)
-    type = CloseAction.template(arg_type)
+    type = CloseAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -86,17 +90,9 @@ COVER_STOP_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_COVER_STOP, COVER_STOP_ACTION_SCHEMA)
-def cover_stop_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def cover_stop_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_stop_action(template_arg)
-    type = StopAction.template(arg_type)
+    type = StopAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
-
-
-def core_to_hass_config(data, config):
-    ret = mqtt.build_hass_config(data, 'cover', config, include_state=True, include_command=True)
-    if ret is None:
-        return None
-    return ret

esphome/components/cover/template.py

@@ -0,0 +1,79 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import cover
+import esphome.config_validation as cv
+from esphome.const import CONF_ASSUMED_STATE, CONF_CLOSE_ACTION, CONF_ID, CONF_LAMBDA, CONF_NAME, \
+    CONF_OPEN_ACTION, CONF_OPTIMISTIC, CONF_STATE, CONF_STOP_ACTION
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, optional
+from esphome.py_compat import string_types
+
+TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
+CoverPublishAction = cover.cover_ns.class_('CoverPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateCover),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_ASSUMED_STATE): cv.boolean,
+    vol.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_cover(config[CONF_NAME])
+    var = Pvariable(config[CONF_ID], rhs)
+
+    cover.setup_cover(var, config)
+    setup_component(var, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(cover.CoverState)):
+            yield
+        add(var.set_state_lambda(template_))
+    if CONF_OPEN_ACTION in config:
+        automation.build_automations(var.get_open_trigger(), [],
+                                     config[CONF_OPEN_ACTION])
+    if CONF_CLOSE_ACTION in config:
+        automation.build_automations(var.get_close_trigger(), [],
+                                     config[CONF_CLOSE_ACTION])
+    if CONF_STOP_ACTION in config:
+        automation.build_automations(var.get_stop_trigger(), [],
+                                     config[CONF_STOP_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+    if CONF_ASSUMED_STATE in config:
+        add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'
+
+CONF_COVER_TEMPLATE_PUBLISH = 'cover.template.publish'
+COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(cover.Cover),
+    vol.Required(CONF_STATE): cv.templatable(cover.validate_cover_state),
+})
+
+
+@ACTION_REGISTRY.register(CONF_COVER_TEMPLATE_PUBLISH,
+                          COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def cover_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_cover_publish_action(template_arg)
+    type = CoverPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    state = config[CONF_STATE]
+    if isinstance(state, string_types):
+        template_ = cover.COVER_STATES[state]
+    else:
+        for template_ in templatable(state, args, cover.CoverState):
+            yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/custom_component.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+import esphome.config_validation as cv
+from esphome.const import CONF_COMPONENTS, CONF_ID, CONF_LAMBDA
+from esphome.cpp_generator import Pvariable, process_lambda, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Component, ComponentPtr, esphome_ns, std_vector
+
+CustomComponentConstructor = esphome_ns.class_('CustomComponentConstructor')
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(CustomComponentConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_COMPONENTS): cv.ensure_list(cv.Schema({
+        cv.GenerateID(): cv.declare_variable_id(Component)
+    }).extend(cv.COMPONENT_SCHEMA.schema)),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(ComponentPtr)):
+        yield
+
+    rhs = CustomComponentConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, comp_config in enumerate(config.get(CONF_COMPONENTS, [])):
+        comp = Pvariable(comp_config[CONF_ID], custom.get_component(i))
+        setup_component(comp, comp_config)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_COMPONENT'

esphome/components/dallas.py

@@ -0,0 +1,27 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DallasComponent = sensor.sensor_ns.class_('DallasComponent', PollingComponent)
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(DallasComponent),
+    vol.Required(CONF_PIN): pins.input_pin,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_dallas_component(config[CONF_PIN], config.get(CONF_UPDATE_INTERVAL))
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphome/components/debug.py

@@ -0,0 +1,14 @@
+import esphome.config_validation as cv
+from esphome.cpp_generator import add
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['logger']
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+def to_code(config):
+    add(App.make_debug_component())
+
+
+BUILD_FLAGS = '-DUSE_DEBUG_COMPONENT'

esphome/components/deep_sleep.py

@@ -1,12 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml import config_validation as cv, pins
-from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
-from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
-    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN, CONF_MODE, CONF_PINS
-from esphomeyaml.helpers import Action, App, Component, Pvariable, TemplateArguments, add, \
-    esphomelib_ns, get_variable, gpio_input_pin_expression, setup_component, global_ns, \
-    StructInitializer
+from esphome import config_validation as cv, pins
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.const import CONF_ID, CONF_MODE, CONF_NUMBER, CONF_PINS, CONF_RUN_CYCLES, \
+    CONF_RUN_DURATION, CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import Action, App, Component, esphome_ns, global_ns
 
 
 def validate_pin_number(value):
@@ -17,11 +17,11 @@ def validate_pin_number(value):
     return value
 
 
-DeepSleepComponent = esphomelib_ns.class_('DeepSleepComponent', Component)
-EnterDeepSleepAction = esphomelib_ns.class_('EnterDeepSleepAction', Action)
-PreventDeepSleepAction = esphomelib_ns.class_('PreventDeepSleepAction', Action)
+DeepSleepComponent = esphome_ns.class_('DeepSleepComponent', Component)
+EnterDeepSleepAction = esphome_ns.class_('EnterDeepSleepAction', Action)
+PreventDeepSleepAction = esphome_ns.class_('PreventDeepSleepAction', Action)
 
-WakeupPinMode = esphomelib_ns.enum('WakeupPinMode')
+WakeupPinMode = esphome_ns.enum('WakeupPinMode')
 WAKEUP_PIN_MODES = {
     'IGNORE': WakeupPinMode.WAKEUP_PIN_MODE_IGNORE,
     'KEEP_AWAKE': WakeupPinMode.WAKEUP_PIN_MODE_KEEP_AWAKE,
@@ -29,7 +29,7 @@ WAKEUP_PIN_MODES = {
 }
 
 esp_sleep_ext1_wakeup_mode_t = global_ns.enum('esp_sleep_ext1_wakeup_mode_t')
-Ext1Wakeup = esphomelib_ns.struct('Ext1Wakeup')
+Ext1Wakeup = esphome_ns.struct('Ext1Wakeup')
 EXT1_WAKEUP_MODES = {
     'ALL_LOW': esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ALL_LOW,
     'ANY_HIGH': esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ANY_HIGH,
@@ -38,20 +38,22 @@ EXT1_WAKEUP_MODES = {
 CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
 CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(DeepSleepComponent),
     vol.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
                                            validate_pin_number),
-    vol.Optional(CONF_WAKEUP_PIN_MODE): vol.All(cv.only_on_esp32, vol.Upper,
-                                                cv.one_of(*WAKEUP_PIN_MODES)),
-    vol.Optional(CONF_ESP32_EXT1_WAKEUP): vol.All(cv.only_on_esp32, vol.Schema({
-        vol.Required(CONF_PINS): vol.All(cv.ensure_list, [pins.shorthand_input_pin],
-                                         [validate_pin_number]),
-        vol.Required(CONF_MODE): vol.All(vol.Upper, cv.one_of(*EXT1_WAKEUP_MODES)),
+    vol.Optional(CONF_WAKEUP_PIN_MODE): vol.All(cv.only_on_esp32,
+                                                cv.one_of(*WAKEUP_PIN_MODES), upper=True),
+    vol.Optional(CONF_ESP32_EXT1_WAKEUP): vol.All(cv.only_on_esp32, cv.Schema({
+        vol.Required(CONF_PINS): cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
+        vol.Required(CONF_MODE): cv.one_of(*EXT1_WAKEUP_MODES, upper=True),
     })),
-    vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
     vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
+
+    vol.Optional(CONF_RUN_CYCLES): cv.invalid("The run_cycles option has been removed in 1.11.0 as "
+                                              "it was essentially the same as a run_duration of 0s."
+                                              "Please use run_duration now.")
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
 
@@ -66,8 +68,6 @@ def to_code(config):
         add(deep_sleep.set_wakeup_pin(pin))
     if CONF_WAKEUP_PIN_MODE in config:
         add(deep_sleep.set_wakeup_pin_mode(WAKEUP_PIN_MODES[config[CONF_WAKEUP_PIN_MODE]]))
-    if CONF_RUN_CYCLES in config:
-        add(deep_sleep.set_run_cycles(config[CONF_RUN_CYCLES]))
     if CONF_RUN_DURATION in config:
         add(deep_sleep.set_run_duration(config[CONF_RUN_DURATION]))
 
@@ -95,12 +95,11 @@ DEEP_SLEEP_ENTER_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_DEEP_SLEEP_ENTER, DEEP_SLEEP_ENTER_ACTION_SCHEMA)
-def deep_sleep_enter_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def deep_sleep_enter_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_enter_deep_sleep_action(template_arg)
-    type = EnterDeepSleepAction.template(arg_type)
+    type = EnterDeepSleepAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -111,10 +110,9 @@ DEEP_SLEEP_PREVENT_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_DEEP_SLEEP_PREVENT, DEEP_SLEEP_PREVENT_ACTION_SCHEMA)
-def deep_sleep_prevent_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def deep_sleep_prevent_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_prevent_deep_sleep_action(template_arg)
-    type = PreventDeepSleepAction.template(arg_type)
+    type = PreventDeepSleepAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)

esphome/components/display/__init__.py

@@ -0,0 +1,127 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome import core
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+import esphome.config_validation as cv
+from esphome.const import CONF_LAMBDA, CONF_ROTATION, CONF_UPDATE_INTERVAL, CONF_PAGES, CONF_ID
+from esphome.core import CORE
+from esphome.cpp_generator import add, process_lambda, Pvariable, templatable, get_variable
+from esphome.cpp_types import esphome_ns, void, Action
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+display_ns = esphome_ns.namespace('display')
+DisplayBuffer = display_ns.class_('DisplayBuffer')
+DisplayPage = display_ns.class_('DisplayPage')
+DisplayPagePtr = DisplayPage.operator('ptr')
+DisplayBufferRef = DisplayBuffer.operator('ref')
+DisplayPageShowAction = display_ns.class_('DisplayPageShowAction', Action)
+DisplayPageShowNextAction = display_ns.class_('DisplayPageShowNextAction', Action)
+DisplayPageShowPrevAction = display_ns.class_('DisplayPageShowPrevAction', Action)
+
+DISPLAY_ROTATIONS = {
+    0: display_ns.DISPLAY_ROTATION_0_DEGREES,
+    90: display_ns.DISPLAY_ROTATION_90_DEGREES,
+    180: display_ns.DISPLAY_ROTATION_180_DEGREES,
+    270: display_ns.DISPLAY_ROTATION_270_DEGREES,
+}
+
+
+def validate_rotation(value):
+    value = cv.string(value)
+    if value.endswith(u"°"):
+        value = value[:-1]
+    try:
+        value = int(value)
+    except ValueError:
+        raise vol.Invalid(u"Expected integer for rotation")
+    return cv.one_of(*DISPLAY_ROTATIONS)(value)
+
+
+BASIC_DISPLAY_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+})
+
+FULL_DISPLAY_PLATFORM_SCHEMA = BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_ROTATION): validate_rotation,
+    vol.Optional(CONF_PAGES): vol.All(cv.ensure_list({
+        cv.GenerateID(): cv.declare_variable_id(DisplayPage),
+        vol.Required(CONF_LAMBDA): cv.lambda_,
+    }), vol.Length(min=1)),
+})
+
+
+def setup_display_core_(display_var, config):
+    if CONF_UPDATE_INTERVAL in config:
+        add(display_var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
+    if CONF_ROTATION in config:
+        add(display_var.set_rotation(DISPLAY_ROTATIONS[config[CONF_ROTATION]]))
+    if CONF_PAGES in config:
+        pages = []
+        for conf in config[CONF_PAGES]:
+            for lambda_ in process_lambda(conf[CONF_LAMBDA], [(DisplayBufferRef, 'it')],
+                                          return_type=void):
+                yield
+            var = Pvariable(conf[CONF_ID], DisplayPage.new(lambda_))
+            pages.append(var)
+        add(display_var.set_pages(pages))
+
+
+CONF_DISPLAY_PAGE_SHOW = 'display.page.show'
+DISPLAY_PAGE_SHOW_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayPage)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW, DISPLAY_PAGE_SHOW_ACTION_SCHEMA)
+def display_page_show_to_code(config, action_id, template_arg, args):
+    type = DisplayPageShowAction.template(template_arg)
+    action = Pvariable(action_id, type.new(), type=type)
+    if isinstance(config[CONF_ID], core.Lambda):
+        for template_ in templatable(config[CONF_ID], args, DisplayPagePtr):
+            yield None
+        add(action.set_page(template_))
+    else:
+        for var in get_variable(config[CONF_ID]):
+            yield None
+        add(action.set_page(var))
+    yield action
+
+
+CONF_DISPLAY_PAGE_SHOW_NEXT = 'display.page.show_next'
+DISPLAY_PAGE_SHOW_NEXT_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW_NEXT, DISPLAY_PAGE_SHOW_NEXT_ACTION_SCHEMA)
+def display_page_show_next_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    type = DisplayPageShowNextAction.template(template_arg)
+    yield Pvariable(action_id, type.new(var), type=type)
+
+
+CONF_DISPLAY_PAGE_SHOW_PREVIOUS = 'display.page.show_previous'
+DISPLAY_PAGE_SHOW_PREVIOUS_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.templatable(cv.use_variable_id(DisplayBuffer)),
+})
+
+
+@ACTION_REGISTRY.register(CONF_DISPLAY_PAGE_SHOW_PREVIOUS, DISPLAY_PAGE_SHOW_PREVIOUS_ACTION_SCHEMA)
+def display_page_show_previous_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    type = DisplayPageShowPrevAction.template(template_arg)
+    yield Pvariable(action_id, type.new(var), type=type)
+
+
+def setup_display(display_var, config):
+    CORE.add_job(setup_display_core_, display_var, config)
+
+
+BUILD_FLAGS = '-DUSE_DISPLAY'

esphome/components/display/lcd_gpio.py

@@ -1,12 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import display
-from esphomeyaml.const import CONF_DATA_PINS, CONF_DIMENSIONS, CONF_ENABLE_PIN, CONF_ID, \
+from esphome import pins
+from esphome.components import display
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA_PINS, CONF_DIMENSIONS, CONF_ENABLE_PIN, CONF_ID, \
     CONF_LAMBDA, CONF_RS_PIN, CONF_RW_PIN
-from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression, process_lambda, \
-    setup_component, PollingComponent
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
 
 LCDDisplay = display.display_ns.class_('LCDDisplay', PollingComponent)
 LCDDisplayRef = LCDDisplay.operator('ref')
@@ -63,7 +64,8 @@ def to_code(config):
         add(lcd.set_rw_pin(rw))
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')],
+                                      return_type=void):
             yield
         add(lcd.set_writer(lambda_))
 

esphome/components/display/lcd_pcf8574.py

@@ -1,11 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import display, i2c
-from esphomeyaml.components.display.lcd_gpio import LCDDisplayRef, validate_lcd_dimensions, \
-    LCDDisplay
-from esphomeyaml.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
-from esphomeyaml.helpers import App, Pvariable, add, process_lambda, setup_component
+from esphome.components import display, i2c
+from esphome.components.display.lcd_gpio import LCDDisplay, LCDDisplayRef, \
+    validate_lcd_dimensions
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, void
 
 DEPENDENCIES = ['i2c']
 
@@ -26,7 +28,8 @@ def to_code(config):
         add(lcd.set_address(config[CONF_ADDRESS]))
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')],
+                                      return_type=void):
             yield
         add(lcd.set_writer(lambda_))
 

esphome/components/display/max7219.py

@@ -1,13 +1,14 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import display, spi
-from esphomeyaml.components.spi import SPIComponent
-from esphomeyaml.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
     CONF_SPI_ID
-from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_output_pin_expression, \
-    process_lambda, setup_component, PollingComponent
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
 
 DEPENDENCIES = ['spi']
 
@@ -38,7 +39,8 @@ def to_code(config):
         add(max7219.set_intensity(config[CONF_INTENSITY]))
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(MAX7219ComponentRef, 'it')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(MAX7219ComponentRef, 'it')],
+                                      return_type=void):
             yield
         add(max7219.set_writer(lambda_))
 

esphome/components/display/nextion.py

@@ -1,10 +1,10 @@
-from esphomeyaml.components import display, uart
-from esphomeyaml.components.uart import UARTComponent
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, get_variable, \
-    process_lambda, \
-    setup_component
+from esphome.components import display, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, void
 
 DEPENDENCIES = ['uart']
 
@@ -24,7 +24,8 @@ def to_code(config):
     nextion = Pvariable(config[CONF_ID], rhs)
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(NextionRef, 'it')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(NextionRef, 'it')],
+                                      return_type=void):
             yield
         add(nextion.set_writer(lambda_))
 

esphome/components/display/ssd1306_i2c.py

@@ -1,25 +1,26 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import display
-from esphomeyaml.components.display import ssd1306_spi
-from esphomeyaml.const import CONF_ADDRESS, CONF_EXTERNAL_VCC, CONF_ID, \
-    CONF_MODEL, CONF_RESET_PIN, CONF_LAMBDA
-from esphomeyaml.helpers import App, Pvariable, add, \
-    gpio_output_pin_expression, process_lambda, setup_component
+from esphome import pins
+from esphome.components import display
+from esphome.components.display import ssd1306_spi
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, CONF_MODEL, \
+    CONF_PAGES, CONF_RESET_PIN
+from esphome.cpp_generator import Pvariable, add, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, void
 
 DEPENDENCIES = ['i2c']
 
 I2CSSD1306 = display.display_ns.class_('I2CSSD1306', ssd1306_spi.SSD1306)
 
-PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(I2CSSD1306),
     vol.Required(CONF_MODEL): ssd1306_spi.SSD1306_MODEL,
     vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_EXTERNAL_VCC): cv.boolean,
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
 
 
 def to_code(config):
@@ -36,7 +37,7 @@ def to_code(config):
         add(ssd.set_address(config[CONF_ADDRESS]))
     if CONF_LAMBDA in config:
         for lambda_ in process_lambda(config[CONF_LAMBDA],
-                                      [(display.DisplayBufferRef, 'it')]):
+                                      [(display.DisplayBufferRef, 'it')], return_type=void):
             yield
         add(ssd.set_writer(lambda_))
 

esphome/components/display/ssd1306_spi.py

@@ -1,14 +1,14 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import display, spi
-from esphomeyaml.components.spi import SPIComponent
-from esphomeyaml.const import CONF_CS_PIN, CONF_DC_PIN, CONF_EXTERNAL_VCC, \
-    CONF_ID, CONF_MODEL, \
-    CONF_RESET_PIN, CONF_SPI_ID, CONF_LAMBDA
-from esphomeyaml.helpers import App, Pvariable, add, get_variable, \
-    gpio_output_pin_expression, process_lambda, setup_component, PollingComponent
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_DC_PIN, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, \
+    CONF_MODEL, CONF_RESET_PIN, CONF_SPI_ID, CONF_PAGES
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, void
 
 DEPENDENCIES = ['spi']
 
@@ -27,9 +27,9 @@ MODELS = {
     'SH1106_64X48': SSD1306Model.SH1106_MODEL_64_48,
 }
 
-SSD1306_MODEL = vol.All(vol.Upper, vol.Replace(' ', '_'), cv.one_of(*MODELS))
+SSD1306_MODEL = cv.one_of(*MODELS, upper=True, space="_")
 
-PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(SPISSD1306),
     cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
     vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
@@ -37,7 +37,7 @@ PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     vol.Required(CONF_MODEL): SSD1306_MODEL,
     vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_EXTERNAL_VCC): cv.boolean,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
 
 
 def to_code(config):
@@ -60,7 +60,7 @@ def to_code(config):
         add(ssd.set_external_vcc(config[CONF_EXTERNAL_VCC]))
     if CONF_LAMBDA in config:
         for lambda_ in process_lambda(config[CONF_LAMBDA],
-                                      [(display.DisplayBufferRef, 'it')]):
+                                      [(display.DisplayBufferRef, 'it')], return_type=void):
             yield
         add(ssd.set_writer(lambda_))
 

esphome/components/display/waveshare_epaper.py

@@ -1,13 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import display, spi
-from esphomeyaml.components.spi import SPIComponent
-from esphomeyaml.const import CONF_BUSY_PIN, CONF_CS_PIN, CONF_DC_PIN, CONF_FULL_UPDATE_EVERY, \
-    CONF_ID, CONF_LAMBDA, CONF_MODEL, CONF_RESET_PIN, CONF_SPI_ID
-from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_input_pin_expression, \
-    gpio_output_pin_expression, process_lambda, setup_component, PollingComponent
+from esphome import pins
+from esphome.components import display, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_BUSY_PIN, CONF_CS_PIN, CONF_DC_PIN, CONF_FULL_UPDATE_EVERY, \
+    CONF_ID, CONF_LAMBDA, CONF_MODEL, CONF_PAGES, CONF_RESET_PIN, CONF_SPI_ID
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App, PollingComponent, void
 
 DEPENDENCIES = ['spi']
 
@@ -15,7 +17,6 @@ WaveshareEPaperTypeA = display.display_ns.WaveshareEPaperTypeA
 WaveshareEPaper = display.display_ns.class_('WaveshareEPaper',
                                             PollingComponent, spi.SPIDevice, display.DisplayBuffer)
 
-
 WaveshareEPaperTypeAModel = display.display_ns.enum('WaveshareEPaperTypeAModel')
 WaveshareEPaperTypeBModel = display.display_ns.enum('WaveshareEPaperTypeBModel')
 
@@ -43,11 +44,12 @@ PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
     vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
     vol.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
-    vol.Required(CONF_MODEL): vol.All(vol.Lower, cv.one_of(*MODELS)),
+    vol.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True),
     vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
     vol.Optional(CONF_FULL_UPDATE_EVERY): cv.uint32_t,
-}).extend(cv.COMPONENT_SCHEMA.schema), validate_full_update_every_only_type_a)
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_full_update_every_only_type_a,
+                          cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
 
 
 def to_code(config):
@@ -69,7 +71,8 @@ def to_code(config):
         raise NotImplementedError()
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')],
+                                      return_type=void):
             yield
         add(epaper.set_writer(lambda_))
     if CONF_RESET_PIN in config:

esphome/components/esp32_ble_beacon.py

@@ -1,20 +1,22 @@
 import voluptuous as vol
 
-from esphomeyaml import config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, CONF_TYPE, CONF_UUID, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, ArrayInitializer, Component, Pvariable, RawExpression, add, \
-    esphomelib_ns, setup_component
+from esphome import config_validation as cv
+from esphome.const import CONF_ID, CONF_SCAN_INTERVAL, CONF_TYPE, CONF_UUID, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable, RawExpression, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+CONFLICTS_WITH = ['esp32_ble_tracker']
 
-ESP32BLEBeacon = esphomelib_ns.class_('ESP32BLEBeacon', Component)
+ESP32BLEBeacon = esphome_ns.class_('ESP32BLEBeacon', Component)
 
 CONF_MAJOR = 'major'
 CONF_MINOR = 'minor'
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon),
-    vol.Required(CONF_TYPE): vol.All(vol.Upper, cv.one_of('IBEACON')),
+    vol.Required(CONF_TYPE): cv.one_of('IBEACON', upper=True),
     vol.Required(CONF_UUID): cv.uuid,
     vol.Optional(CONF_MAJOR): cv.uint16_t,
     vol.Optional(CONF_MINOR): cv.uint16_t,
@@ -25,7 +27,7 @@ CONFIG_SCHEMA = vol.Schema({
 def to_code(config):
     uuid = config[CONF_UUID].hex
     uuid_arr = [RawExpression('0x{}'.format(uuid[i:i + 2])) for i in range(0, len(uuid), 2)]
-    rhs = App.make_esp32_ble_beacon(ArrayInitializer(*uuid_arr, multiline=False))
+    rhs = App.make_esp32_ble_beacon(uuid_arr)
     ble = Pvariable(config[CONF_ID], rhs)
     if CONF_MAJOR in config:
         add(ble.set_major(config[CONF_MAJOR]))

esphome/components/esp32_ble_tracker.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv
+from esphome.components import sensor
+from esphome.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_ESP32_BLE_ID = 'esp32_ble_id'
+ESP32BLETracker = esphome_ns.class_('ESP32BLETracker', Component)
+XiaomiSensor = esphome_ns.class_('XiaomiSensor', sensor.Sensor)
+XiaomiDevice = esphome_ns.class_('XiaomiDevice')
+XIAOMI_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(XiaomiSensor)
+})
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
+    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_seconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def make_address_array(address):
+    return [HexInt(i) for i in address.parts]
+
+
+def to_code(config):
+    rhs = App.make_esp32_ble_tracker()
+    ble = Pvariable(config[CONF_ID], rhs)
+    if CONF_SCAN_INTERVAL in config:
+        add(ble.set_scan_interval(config[CONF_SCAN_INTERVAL]))
+
+    setup_component(ble, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_BLE_TRACKER'

esphome/components/esp32_camera.py

@@ -0,0 +1,130 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv, pins
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NAME, CONF_PIN, CONF_SCL, CONF_SDA, \
+    ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Nameable, PollingComponent, esphome_ns
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+ESP32Camera = esphome_ns.class_('ESP32Camera', PollingComponent, Nameable)
+ESP32CameraFrameSize = esphome_ns.enum('ESP32CameraFrameSize')
+FRAME_SIZES = {
+    '160X120': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
+    'QQVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_160X120,
+    '128x160': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_128X160,
+    'QQVGA2': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_128X160,
+    '176X144': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_176X144,
+    'QCIF': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_176X144,
+    '240X176': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_240X176,
+    'HQVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_240X176,
+    '320X240': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_320X240,
+    'QVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_320X240,
+    '400X296': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_400X296,
+    'CIF': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_400X296,
+    '640X480': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_640X480,
+    'VGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_640X480,
+    '800X600': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_800X600,
+    'SVGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_800X600,
+    '1024X768': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1024X768,
+    'XGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1024X768,
+    '1280x1024': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1280X1024,
+    'SXGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1280X1024,
+    '1600X1200': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1600X1200,
+    'UXGA': ESP32CameraFrameSize.ESP32_CAMERA_SIZE_1600X1200,
+}
+
+CONF_DATA_PINS = 'data_pins'
+CONF_VSYNC_PIN = 'vsync_pin'
+CONF_HREF_PIN = 'href_pin'
+CONF_PIXEL_CLOCK_PIN = 'pixel_clock_pin'
+CONF_EXTERNAL_CLOCK = 'external_clock'
+CONF_I2C_PINS = 'i2c_pins'
+CONF_RESET_PIN = 'reset_pin'
+CONF_POWER_DOWN_PIN = 'power_down_pin'
+
+CONF_MAX_FRAMERATE = 'max_framerate'
+CONF_IDLE_FRAMERATE = 'idle_framerate'
+CONF_RESOLUTION = 'resolution'
+CONF_JPEG_QUALITY = 'jpeg_quality'
+CONF_VERTICAL_FLIP = 'vertical_flip'
+CONF_HORIZONTAL_MIRROR = 'horizontal_mirror'
+CONF_CONTRAST = 'contrast'
+CONF_BRIGHTNESS = 'brightness'
+CONF_SATURATION = 'saturation'
+CONF_TEST_PATTERN = 'test_pattern'
+
+camera_range_param = vol.All(cv.int_, vol.Range(min=-2, max=2))
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32Camera),
+    vol.Required(CONF_NAME): cv.string,
+    vol.Required(CONF_DATA_PINS): vol.All([pins.input_pin], vol.Length(min=8, max=8)),
+    vol.Required(CONF_VSYNC_PIN): pins.input_pin,
+    vol.Required(CONF_HREF_PIN): pins.input_pin,
+    vol.Required(CONF_PIXEL_CLOCK_PIN): pins.input_pin,
+    vol.Required(CONF_EXTERNAL_CLOCK): cv.Schema({
+        vol.Required(CONF_PIN): pins.output_pin,
+        vol.Optional(CONF_FREQUENCY, default='20MHz'): vol.All(cv.frequency, vol.In([20e6, 10e6])),
+    }),
+    vol.Required(CONF_I2C_PINS): cv.Schema({
+        vol.Required(CONF_SDA): pins.output_pin,
+        vol.Required(CONF_SCL): pins.output_pin,
+    }),
+    vol.Optional(CONF_RESET_PIN): pins.output_pin,
+    vol.Optional(CONF_POWER_DOWN_PIN): pins.output_pin,
+
+    vol.Optional(CONF_MAX_FRAMERATE, default='10 fps'): vol.All(cv.framerate,
+                                                                vol.Range(min=0, min_included=False,
+                                                                          max=60)),
+    vol.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'): vol.All(cv.framerate,
+                                                                  vol.Range(min=0, max=1)),
+    vol.Optional(CONF_RESOLUTION, default='640X480'): cv.one_of(*FRAME_SIZES, upper=True),
+    vol.Optional(CONF_JPEG_QUALITY, default=10): vol.All(cv.int_, vol.Range(min=10, max=63)),
+    vol.Optional(CONF_CONTRAST, default=0): camera_range_param,
+    vol.Optional(CONF_BRIGHTNESS, default=0): camera_range_param,
+    vol.Optional(CONF_SATURATION, default=0): camera_range_param,
+    vol.Optional(CONF_VERTICAL_FLIP, default=True): cv.boolean,
+    vol.Optional(CONF_HORIZONTAL_MIRROR, default=True): cv.boolean,
+    vol.Optional(CONF_TEST_PATTERN, default=False): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+SETTERS = {
+    CONF_DATA_PINS: 'set_data_pins',
+    CONF_VSYNC_PIN: 'set_vsync_pin',
+    CONF_HREF_PIN: 'set_href_pin',
+    CONF_PIXEL_CLOCK_PIN: 'set_pixel_clock_pin',
+    CONF_RESET_PIN: 'set_reset_pin',
+    CONF_POWER_DOWN_PIN: 'set_power_down_pin',
+    CONF_JPEG_QUALITY: 'set_jpeg_quality',
+    CONF_VERTICAL_FLIP: 'set_vertical_flip',
+    CONF_HORIZONTAL_MIRROR: 'set_horizontal_mirror',
+    CONF_CONTRAST: 'set_contrast',
+    CONF_BRIGHTNESS: 'set_brightness',
+    CONF_SATURATION: 'set_saturation',
+    CONF_TEST_PATTERN: 'set_test_pattern',
+}
+
+
+def to_code(config):
+    rhs = App.register_component(ESP32Camera.new(config[CONF_NAME]))
+    cam = Pvariable(config[CONF_ID], rhs)
+
+    for key, setter in SETTERS.items():
+        if key in config:
+            add(getattr(cam, setter)(config[key]))
+
+    extclk = config[CONF_EXTERNAL_CLOCK]
+    add(cam.set_external_clock(extclk[CONF_PIN], extclk[CONF_FREQUENCY]))
+    i2c_pins = config[CONF_I2C_PINS]
+    add(cam.set_i2c_pins(i2c_pins[CONF_SDA], i2c_pins[CONF_SCL]))
+    add(cam.set_max_update_interval(1000 / config[CONF_MAX_FRAMERATE]))
+    if config[CONF_IDLE_FRAMERATE] == 0:
+        add(cam.set_idle_update_interval(0))
+    else:
+        add(cam.set_idle_update_interval(1000 / config[CONF_IDLE_FRAMERATE]))
+    add(cam.set_frame_size(FRAME_SIZES[config[CONF_RESOLUTION]]))
+
+
+BUILD_FLAGS = ['-DUSE_ESP32_CAMERA', '-DBOARD_HAS_PSRAM']

esphome/components/esp32_touch.py

@@ -1,12 +1,14 @@
 import voluptuous as vol
 
-from esphomeyaml import config_validation as cv
-from esphomeyaml.components import binary_sensor
-from esphomeyaml.const import CONF_ID, CONF_SETUP_MODE, CONF_IIR_FILTER, \
-    CONF_SLEEP_DURATION, CONF_MEASUREMENT_DURATION, CONF_LOW_VOLTAGE_REFERENCE, \
-    CONF_HIGH_VOLTAGE_REFERENCE, CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
-from esphomeyaml.core import TimePeriod
-from esphomeyaml.helpers import App, Pvariable, add, global_ns, setup_component, Component
+from esphome import config_validation as cv
+from esphome.components import binary_sensor
+from esphome.const import CONF_HIGH_VOLTAGE_REFERENCE, CONF_ID, CONF_IIR_FILTER, \
+    CONF_LOW_VOLTAGE_REFERENCE, CONF_MEASUREMENT_DURATION, CONF_SETUP_MODE, CONF_SLEEP_DURATION, \
+    CONF_VOLTAGE_ATTENUATION, ESP_PLATFORM_ESP32
+from esphome.core import TimePeriod
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, global_ns
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -19,6 +21,7 @@ def validate_voltage(values):
         if not value.endswith('V'):
             value += 'V'
         return cv.one_of(*values)(value)
+
     return validator
 
 
@@ -43,7 +46,7 @@ VOLTAGE_ATTENUATION = {
 
 ESP32TouchComponent = binary_sensor.binary_sensor_ns.class_('ESP32TouchComponent', Component)
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(ESP32TouchComponent),
     vol.Optional(CONF_SETUP_MODE): cv.boolean,
     vol.Optional(CONF_IIR_FILTER): cv.positive_time_period_milliseconds,

esphome/components/ethernet.py

@@ -0,0 +1,85 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import wifi
+import esphome.config_validation as cv
+from esphome.const import CONF_DOMAIN, CONF_ID, CONF_MANUAL_IP, CONF_STATIC_IP, CONF_TYPE, \
+    CONF_USE_ADDRESS, ESP_PLATFORM_ESP32
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression
+from esphome.cpp_types import App, Component, esphome_ns, global_ns
+
+CONFLICTS_WITH = ['wifi']
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+CONF_PHY_ADDR = 'phy_addr'
+CONF_MDC_PIN = 'mdc_pin'
+CONF_MDIO_PIN = 'mdio_pin'
+CONF_CLK_MODE = 'clk_mode'
+CONF_POWER_PIN = 'power_pin'
+
+EthernetType = esphome_ns.enum('EthernetType')
+ETHERNET_TYPES = {
+    'LAN8720': EthernetType.ETHERNET_TYPE_LAN8720,
+    'TLK110': EthernetType.ETHERNET_TYPE_TLK110,
+}
+
+eth_clock_mode_t = global_ns.enum('eth_clock_mode_t')
+CLK_MODES = {
+    'GPIO0_IN': eth_clock_mode_t.ETH_CLOCK_GPIO0_IN,
+    'GPIO0_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO0_OUT,
+    'GPIO16_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO16_OUT,
+    'GPIO17_OUT': eth_clock_mode_t.ETH_CLOCK_GPIO17_OUT,
+}
+
+EthernetComponent = esphome_ns.class_('EthernetComponent', Component)
+
+
+def validate(config):
+    if CONF_USE_ADDRESS not in config:
+        if CONF_MANUAL_IP in config:
+            use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
+        else:
+            use_address = CORE.name + config[CONF_DOMAIN]
+        config[CONF_USE_ADDRESS] = use_address
+    return config
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(EthernetComponent),
+    vol.Required(CONF_TYPE): cv.one_of(*ETHERNET_TYPES, upper=True),
+    vol.Required(CONF_MDC_PIN): pins.output_pin,
+    vol.Required(CONF_MDIO_PIN): pins.input_output_pin,
+    vol.Optional(CONF_CLK_MODE, default='GPIO0_IN'): cv.one_of(*CLK_MODES, upper=True, space='_'),
+    vol.Optional(CONF_PHY_ADDR, default=0): vol.All(cv.int_, vol.Range(min=0, max=31)),
+    vol.Optional(CONF_POWER_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_MANUAL_IP): wifi.STA_MANUAL_IP_SCHEMA,
+    vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
+    vol.Optional(CONF_USE_ADDRESS): cv.string_strict,
+
+    vol.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"),
+}), validate)
+
+
+def to_code(config):
+    rhs = App.init_ethernet()
+    eth = Pvariable(config[CONF_ID], rhs)
+
+    add(eth.set_phy_addr(config[CONF_PHY_ADDR]))
+    add(eth.set_mdc_pin(config[CONF_MDC_PIN]))
+    add(eth.set_mdio_pin(config[CONF_MDIO_PIN]))
+    add(eth.set_type(ETHERNET_TYPES[config[CONF_TYPE]]))
+    add(eth.set_clk_mode(CLK_MODES[config[CONF_CLK_MODE]]))
+    add(eth.set_use_address(config[CONF_USE_ADDRESS]))
+
+    if CONF_POWER_PIN in config:
+        for pin in gpio_output_pin_expression(config[CONF_POWER_PIN]):
+            yield
+        add(eth.set_power_pin(pin))
+
+    if CONF_MANUAL_IP in config:
+        add(eth.set_manual_ip(wifi.manual_ip(config[CONF_MANUAL_IP])))
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_ETHERNET'

esphome/components/fan/__init__.py

@@ -1,19 +1,22 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
-from esphomeyaml.components import mqtt
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_MQTT_ID, CONF_OSCILLATION_COMMAND_TOPIC, \
-    CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC, CONF_INTERNAL, \
-    CONF_SPEED, CONF_OSCILLATING, CONF_OSCILLATION_OUTPUT, CONF_NAME
-from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component, \
-    TemplateArguments, get_variable, templatable, bool_, Action, Nameable, Component
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_OSCILLATING, \
+    CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_STATE_TOPIC, CONF_SPEED, \
+    CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, Application, Component, Nameable, bool_, esphome_ns
+from esphome.py_compat import string_types
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-fan_ns = esphomelib_ns.namespace('fan')
+fan_ns = esphome_ns.namespace('fan')
 FanState = fan_ns.class_('FanState', Nameable, Component)
 MQTTFanComponent = fan_ns.class_('MQTTFanComponent', mqtt.MQTTComponent)
 MakeFan = Application.struct('MakeFan')
@@ -32,13 +35,14 @@ FAN_SPEED_HIGH = FanSpeed.FAN_SPEED_HIGH
 FAN_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(FanState),
     cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTFanComponent),
-    vol.Optional(CONF_OSCILLATION_STATE_TOPIC): cv.publish_topic,
-    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_OSCILLATION_STATE_TOPIC): vol.All(cv.requires_component('mqtt'),
+                                                        cv.publish_topic),
+    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): vol.All(cv.requires_component('mqtt'),
+                                                          cv.subscribe_topic),
 })
 
 FAN_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FAN_SCHEMA.schema)
 
-
 FAN_SPEEDS = {
     'OFF': FAN_SPEED_OFF,
     'LOW': FAN_SPEED_LOW,
@@ -47,34 +51,29 @@ FAN_SPEEDS = {
 }
 
 
-def validate_fan_speed(value):
-    return vol.All(vol.Upper, cv.one_of(*FAN_SPEEDS))(value)
-
-
-def setup_fan_core_(fan_var, mqtt_var, config):
+def setup_fan_core_(fan_var, config):
     if CONF_INTERNAL in config:
         add(fan_var.set_internal(config[CONF_INTERNAL]))
 
+    mqtt_ = fan_var.Pget_mqtt()
     if CONF_OSCILLATION_STATE_TOPIC in config:
-        add(mqtt_var.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
+        add(mqtt_.set_custom_oscillation_state_topic(config[CONF_OSCILLATION_STATE_TOPIC]))
     if CONF_OSCILLATION_COMMAND_TOPIC in config:
-        add(mqtt_var.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
+        add(mqtt_.set_custom_oscillation_command_topic(config[CONF_OSCILLATION_COMMAND_TOPIC]))
     if CONF_SPEED_STATE_TOPIC in config:
-        add(mqtt_var.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
+        add(mqtt_.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
     if CONF_SPEED_COMMAND_TOPIC in config:
-        add(mqtt_var.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
-    setup_mqtt_component(mqtt_var, config)
+        add(mqtt_.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC]))
+    setup_mqtt_component(mqtt_, config)
 
 
-def setup_fan(fan_obj, mqtt_obj, config):
+def setup_fan(fan_obj, config):
     fan_var = Pvariable(config[CONF_ID], fan_obj, has_side_effects=False)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
-    setup_fan_core_(fan_var, mqtt_var, config)
+    CORE.add_job(setup_fan_core_, fan_var, config)
 
 
 BUILD_FLAGS = '-DUSE_FAN'
 
-
 CONF_FAN_TOGGLE = 'fan.toggle'
 FAN_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
     vol.Required(CONF_ID): cv.use_variable_id(FanState),
@@ -82,12 +81,11 @@ FAN_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_FAN_TOGGLE, FAN_TOGGLE_ACTION_SCHEMA)
-def fan_toggle_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def fan_toggle_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_toggle_action(template_arg)
-    type = ToggleAction.template(arg_type)
+    type = ToggleAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -98,12 +96,11 @@ FAN_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_FAN_TURN_OFF, FAN_TURN_OFF_ACTION_SCHEMA)
-def fan_turn_off_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def fan_turn_off_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_off_action(template_arg)
-    type = TurnOffAction.template(arg_type)
+    type = TurnOffAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -111,36 +108,25 @@ CONF_FAN_TURN_ON = 'fan.turn_on'
 FAN_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
     vol.Required(CONF_ID): cv.use_variable_id(FanState),
     vol.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
-    vol.Optional(CONF_SPEED): cv.templatable(validate_fan_speed),
+    vol.Optional(CONF_SPEED): cv.templatable(cv.one_of(*FAN_SPEEDS, upper=True)),
 })
 
 
 @ACTION_REGISTRY.register(CONF_FAN_TURN_ON, FAN_TURN_ON_ACTION_SCHEMA)
-def fan_turn_on_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def fan_turn_on_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_on_action(template_arg)
-    type = TurnOnAction.template(arg_type)
+    type = TurnOnAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
     if CONF_OSCILLATING in config:
-        for template_ in templatable(config[CONF_OSCILLATING], arg_type, bool_):
+        for template_ in templatable(config[CONF_OSCILLATING], args, bool_):
             yield None
         add(action.set_oscillating(template_))
     if CONF_SPEED in config:
-        for template_ in templatable(config[CONF_SPEED], arg_type, FanSpeed):
+        for template_ in templatable(config[CONF_SPEED], args, FanSpeed):
             yield None
+        if isinstance(template_, string_types):
+            template_ = FAN_SPEEDS[template_]
         add(action.set_speed(template_))
     yield action
-
-
-def core_to_hass_config(data, config):
-    ret = mqtt.build_hass_config(data, 'fan', config, include_state=True, include_command=True)
-    if ret is None:
-        return None
-    if CONF_OSCILLATION_OUTPUT in config:
-        default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'oscillation/state')
-        ret['oscillation_state_topic'] = config.get(CONF_OSCILLATION_STATE_TOPIC, default)
-        default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'oscillation/command')
-        ret['oscillation_command__topic'] = config.get(CONF_OSCILLATION_COMMAND_TOPIC, default)
-    return ret

esphome/components/fan/binary.py

@@ -1,9 +1,11 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan, output
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
-from esphomeyaml.helpers import App, add, get_variable, variable, setup_component
+from esphome.components import fan, output
+import esphome.config_validation as cv
+from esphome.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
+from esphome.cpp_generator import add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
@@ -24,9 +26,5 @@ def to_code(config):
             yield
         add(fan_struct.Poutput.set_oscillation(oscillation_output))
 
-    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)
+    fan.setup_fan(fan_struct.Pstate, config)
     setup_component(fan_struct.Poutput, config)
-
-
-def to_hass_config(data, config):
-    return fan.core_to_hass_config(data, config)

esphome/components/fan/speed.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan, mqtt, output
-from esphomeyaml.const import CONF_HIGH, CONF_LOW, CONF_MAKE_ID, CONF_MEDIUM, CONF_NAME, \
+from esphome.components import fan, output
+import esphome.config_validation as cv
+from esphome.const import CONF_HIGH, CONF_LOW, CONF_MAKE_ID, CONF_MEDIUM, CONF_NAME, \
     CONF_OSCILLATION_OUTPUT, CONF_OUTPUT, CONF_SPEED, CONF_SPEED_COMMAND_TOPIC, \
     CONF_SPEED_STATE_TOPIC
-from esphomeyaml.helpers import App, add, get_variable, variable
+from esphome.cpp_generator import add, get_variable, variable
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
@@ -13,7 +14,7 @@ PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_SPEED_STATE_TOPIC): cv.publish_topic,
     vol.Optional(CONF_SPEED_COMMAND_TOPIC): cv.subscribe_topic,
     vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
-    vol.Optional(CONF_SPEED): vol.Schema({
+    vol.Optional(CONF_SPEED): cv.Schema({
         vol.Required(CONF_LOW): cv.percentage,
         vol.Required(CONF_MEDIUM): cv.percentage,
         vol.Required(CONF_HIGH): cv.percentage,
@@ -40,15 +41,4 @@ def to_code(config):
             yield
         add(fan_struct.Poutput.set_oscillation(oscillation_output))
 
-    fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)
-
-
-def to_hass_config(data, config):
-    ret = fan.core_to_hass_config(data, config)
-    if ret is None:
-        return None
-    default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'speed/state')
-    ret['speed_state_topic'] = config.get(CONF_SPEED_STATE_TOPIC, default)
-    default = mqtt.get_default_topic_for(data, 'fan', config[CONF_NAME], 'speed/command')
-    ret['speed_command__topic'] = config.get(CONF_SPEED_COMMAND_TOPIC, default)
-    return ret
+    fan.setup_fan(fan_struct.Pstate, config)

esphome/components/font.py

@@ -0,0 +1,119 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import display
+import esphome.config_validation as cv
+from esphome.const import CONF_FILE, CONF_GLYPHS, CONF_ID, CONF_SIZE
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, progmem_array, safe_exp
+from esphome.cpp_types import App, uint8
+from esphome.py_compat import sort_by_cmp
+
+DEPENDENCIES = ['display']
+MULTI_CONF = True
+
+Font = display.display_ns.class_('Font')
+Glyph = display.display_ns.class_('Glyph')
+
+
+def validate_glyphs(value):
+    if isinstance(value, list):
+        value = cv.Schema([cv.string])(value)
+    value = cv.Schema([cv.string])(list(value))
+
+    def comparator(x, y):
+        x_ = x.encode('utf-8')
+        y_ = y.encode('utf-8')
+
+        for c in range(min(len(x_), len(y_))):
+            if x_[c] < y_[c]:
+                return -1
+            if x_[c] > y_[c]:
+                return 1
+
+        if len(x_) < len(y_):
+            return -1
+        if len(x_) > len(y_):
+            return 1
+        raise vol.Invalid(u"Found duplicate glyph {}".format(x))
+
+    sort_by_cmp(value, comparator)
+    return value
+
+
+def validate_pillow_installed(value):
+    try:
+        import PIL
+    except ImportError:
+        raise vol.Invalid("Please install the pillow python package to use this feature. "
+                          "(pip install pillow)")
+
+    if PIL.__version__[0] < '4':
+        raise vol.Invalid("Please update your pillow installation to at least 4.0.x. "
+                          "(pip install -U pillow)")
+
+    return value
+
+
+def validate_truetype_file(value):
+    if value.endswith('.zip'):  # for Google Fonts downloads
+        raise vol.Invalid(u"Please unzip the font archive '{}' first and then use the .ttf files "
+                          u"inside.".format(value))
+    if not value.endswith('.ttf'):
+        raise vol.Invalid(u"Only truetype (.ttf) files are supported. Please make sure you're "
+                          u"using the correct format or rename the extension to .ttf")
+    return cv.file_(value)
+
+
+DEFAULT_GLYPHS = u' !"%()+,-.:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz°'
+CONF_RAW_DATA_ID = 'raw_data_id'
+
+FONT_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Font),
+    vol.Required(CONF_FILE): validate_truetype_file,
+    vol.Optional(CONF_GLYPHS, default=DEFAULT_GLYPHS): validate_glyphs,
+    vol.Optional(CONF_SIZE, default=20): vol.All(cv.int_, vol.Range(min=1)),
+    cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(uint8),
+})
+
+CONFIG_SCHEMA = vol.All(validate_pillow_installed, FONT_SCHEMA)
+
+
+def to_code(config):
+    from PIL import ImageFont
+
+    path = CORE.relative_path(config[CONF_FILE])
+    try:
+        font = ImageFont.truetype(path, config[CONF_SIZE])
+    except Exception as e:
+        raise core.EsphomeError(u"Could not load truetype file {}: {}".format(path, e))
+
+    ascent, descent = font.getmetrics()
+
+    glyph_args = {}
+    data = []
+    for glyph in config[CONF_GLYPHS]:
+        mask = font.getmask(glyph, mode='1')
+        _, (offset_x, offset_y) = font.font.getsize(glyph)
+        width, height = mask.size
+        width8 = ((width + 7) // 8) * 8
+        glyph_data = [0 for _ in range(height * width8 // 8)]  # noqa: F812
+        for y in range(height):
+            for x in range(width):
+                if not mask.getpixel((x, y)):
+                    continue
+                pos = x + y * width8
+                glyph_data[pos // 8] |= 0x80 >> (pos % 8)
+        glyph_args[glyph] = (len(data), offset_x, offset_y, width, height)
+        data += glyph_data
+
+    rhs = safe_exp([HexInt(x) for x in data])
+    prog_arr = progmem_array(config[CONF_RAW_DATA_ID], rhs)
+
+    glyphs = []
+    for glyph in config[CONF_GLYPHS]:
+        glyphs.append(Glyph(glyph, prog_arr, *glyph_args[glyph]))
+
+    rhs = App.make_font(glyphs, ascent, ascent + descent)
+    Pvariable(config[CONF_ID], rhs)

esphome/components/globals.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import config_validation as cv
+from esphome.const import CONF_ID, CONF_INITIAL_VALUE, CONF_RESTORE_VALUE, CONF_TYPE
+from esphome.cpp_generator import Pvariable, RawExpression, TemplateArguments, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+GlobalVariableComponent = esphome_ns.class_('GlobalVariableComponent', Component)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(GlobalVariableComponent),
+    vol.Required(CONF_TYPE): cv.string_strict,
+    vol.Optional(CONF_INITIAL_VALUE): cv.string_strict,
+    vol.Optional(CONF_RESTORE_VALUE): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    type_ = RawExpression(config[CONF_TYPE])
+    template_args = TemplateArguments(type_)
+    res_type = GlobalVariableComponent.template(template_args)
+    initial_value = None
+    if CONF_INITIAL_VALUE in config:
+        initial_value = RawExpression(config[CONF_INITIAL_VALUE])
+    rhs = App.Pmake_global_variable(template_args, initial_value)
+    glob = Pvariable(config[CONF_ID], rhs, type=res_type)
+
+    if config.get(CONF_RESTORE_VALUE, False):
+        hash_ = hash(config[CONF_ID].id) % 2**32
+        add(glob.set_restore_value(hash_))
+
+    setup_component(glob, config)

esphome/components/i2c.py

@@ -1,20 +1,22 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.const import CONF_FREQUENCY, CONF_SCL, CONF_SDA, CONF_SCAN, CONF_ID, \
-    CONF_RECEIVE_TIMEOUT
-from esphomeyaml.helpers import App, add, Pvariable, esphomelib_ns, setup_component, Component
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_SCAN, CONF_SCL, \
+    CONF_SDA
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
 
-I2CComponent = esphomelib_ns.class_('I2CComponent', Component)
+I2CComponent = esphome_ns.class_('I2CComponent', Component)
 I2CDevice = pins.I2CDevice
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(I2CComponent),
-    vol.Required(CONF_SDA, default='SDA'): pins.input_output_pin,
-    vol.Required(CONF_SCL, default='SCL'): pins.input_output_pin,
+    vol.Optional(CONF_SDA, default='SDA'): pins.input_pin,
+    vol.Optional(CONF_SCL, default='SCL'): pins.input_pin,
     vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=0, min_included=False)),
-    vol.Optional(CONF_SCAN): cv.boolean,
+    vol.Optional(CONF_SCAN, default=True): cv.boolean,
 
     vol.Optional(CONF_RECEIVE_TIMEOUT): cv.invalid("The receive_timeout option has been removed "
                                                    "because timeouts are already handled by the "

esphome/components/image.py

@@ -0,0 +1,63 @@
+# coding=utf-8
+import logging
+
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import display, font
+import esphome.config_validation as cv
+from esphome.const import CONF_FILE, CONF_ID, CONF_RESIZE
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, progmem_array, safe_exp
+from esphome.cpp_types import App, uint8
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['display']
+MULTI_CONF = True
+
+Image_ = display.display_ns.class_('Image')
+
+CONF_RAW_DATA_ID = 'raw_data_id'
+
+IMAGE_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Image_),
+    vol.Required(CONF_FILE): cv.file_,
+    vol.Optional(CONF_RESIZE): cv.dimensions,
+    cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(uint8),
+})
+
+CONFIG_SCHEMA = vol.All(font.validate_pillow_installed, IMAGE_SCHEMA)
+
+
+def to_code(config):
+    from PIL import Image
+
+    path = CORE.relative_path(config[CONF_FILE])
+    try:
+        image = Image.open(path)
+    except Exception as e:
+        raise core.EsphomeError(u"Could not load image file {}: {}".format(path, e))
+
+    if CONF_RESIZE in config:
+        image.thumbnail(config[CONF_RESIZE])
+
+    image = image.convert('1', dither=Image.NONE)
+    width, height = image.size
+    if width > 500 or height > 500:
+        _LOGGER.warning("The image you requested is very big. Please consider using the resize "
+                        "parameter")
+    width8 = ((width + 7) // 8) * 8
+    data = [0 for _ in range(height * width8 // 8)]
+    for y in range(height):
+        for x in range(width):
+            if image.getpixel((x, y)):
+                continue
+            pos = x + y * width8
+            data[pos // 8] |= 0x80 >> (pos % 8)
+
+    rhs = safe_exp([HexInt(x) for x in data])
+    prog_arr = progmem_array(config[CONF_RAW_DATA_ID], rhs)
+
+    rhs = App.make_image(prog_arr, width, height)
+    Pvariable(config[CONF_ID], rhs)

esphome/components/interval.py

@@ -0,0 +1,24 @@
+import voluptuous as vol
+
+from esphome import automation
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, Trigger, esphome_ns
+
+IntervalTrigger = esphome_ns.class_('IntervalTrigger', Trigger.template(), PollingComponent)
+
+CONFIG_SCHEMA = automation.validate_automation(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(IntervalTrigger),
+    vol.Required(CONF_INTERVAL): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for conf in config:
+        rhs = App.register_component(IntervalTrigger.new(conf[CONF_INTERVAL]))
+        trigger = Pvariable(conf[CONF_ID], rhs)
+        setup_component(trigger, conf)
+
+        automation.build_automations(trigger, [], conf)

esphome/components/light/__init__.py

@@ -1,28 +1,33 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
-from esphomeyaml.components import mqtt
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, \
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, \
     CONF_COLOR_TEMPERATURE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_DURATION, CONF_EFFECT, \
     CONF_EFFECTS, CONF_EFFECT_ID, CONF_FLASH_LENGTH, CONF_GAMMA_CORRECT, CONF_GREEN, CONF_ID, \
     CONF_INTERNAL, CONF_LAMBDA, CONF_MQTT_ID, CONF_NAME, CONF_NUM_LEDS, CONF_RANDOM, CONF_RED, \
     CONF_SPEED, CONF_STATE, CONF_TRANSITION_LENGTH, CONF_UPDATE_INTERVAL, CONF_WHITE, CONF_WIDTH
-from esphomeyaml.helpers import Action, Application, ArrayInitializer, Component, Nameable, \
-    Pvariable, StructInitializer, TemplateArguments, add, add_job, esphomelib_ns, float_, \
-    get_variable, process_lambda, setup_mqtt_component, std_string, templatable, uint32
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, StructInitializer, add, get_variable, process_lambda, \
+    templatable
+from esphome.cpp_types import Action, Application, Component, Nameable, esphome_ns, float_, \
+    std_string, uint32, void
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
 # Base
-light_ns = esphomelib_ns.namespace('light')
+light_ns = esphome_ns.namespace('light')
 LightState = light_ns.class_('LightState', Nameable, Component)
+# Fake class for addressable lights
+AddressableLightState = light_ns.class_('LightState', LightState)
 MakeLight = Application.struct('MakeLight')
 LightOutput = light_ns.class_('LightOutput')
-FastLEDLightOutputComponent = light_ns.class_('FastLEDLightOutputComponent', LightOutput)
-FastLEDLightOutputComponentRef = FastLEDLightOutputComponent.operator('ref')
+AddressableLight = light_ns.class_('AddressableLight')
+AddressableLightRef = AddressableLight.operator('ref')
 
 # Actions
 ToggleAction = light_ns.class_('ToggleAction', Action)
@@ -40,28 +45,30 @@ LambdaLightEffect = light_ns.class_('LambdaLightEffect', LightEffect)
 StrobeLightEffect = light_ns.class_('StrobeLightEffect', LightEffect)
 StrobeLightEffectColor = light_ns.class_('StrobeLightEffectColor', LightEffect)
 FlickerLightEffect = light_ns.class_('FlickerLightEffect', LightEffect)
-BaseFastLEDLightEffect = light_ns.class_('BaseFastLEDLightEffect', LightEffect)
-FastLEDLambdaLightEffect = light_ns.class_('FastLEDLambdaLightEffect', BaseFastLEDLightEffect)
-FastLEDRainbowLightEffect = light_ns.class_('FastLEDRainbowLightEffect', BaseFastLEDLightEffect)
-FastLEDColorWipeEffect = light_ns.class_('FastLEDColorWipeEffect', BaseFastLEDLightEffect)
-FastLEDColorWipeEffectColor = light_ns.class_('FastLEDColorWipeEffectColor', BaseFastLEDLightEffect)
-FastLEDScanEffect = light_ns.class_('FastLEDScanEffect', BaseFastLEDLightEffect)
-FastLEDScanEffectColor = light_ns.class_('FastLEDScanEffectColor', BaseFastLEDLightEffect)
-FastLEDTwinkleEffect = light_ns.class_('FastLEDTwinkleEffect', BaseFastLEDLightEffect)
-FastLEDRandomTwinkleEffect = light_ns.class_('FastLEDRandomTwinkleEffect', BaseFastLEDLightEffect)
-FastLEDFireworksEffect = light_ns.class_('FastLEDFireworksEffect', BaseFastLEDLightEffect)
-FastLEDFlickerEffect = light_ns.class_('FastLEDFlickerEffect', BaseFastLEDLightEffect)
+AddressableLightEffect = light_ns.class_('AddressableLightEffect', LightEffect)
+AddressableLambdaLightEffect = light_ns.class_('AddressableLambdaLightEffect',
+                                               AddressableLightEffect)
+AddressableRainbowLightEffect = light_ns.class_('AddressableRainbowLightEffect',
+                                                AddressableLightEffect)
+AddressableColorWipeEffect = light_ns.class_('AddressableColorWipeEffect', AddressableLightEffect)
+AddressableColorWipeEffectColor = light_ns.struct('AddressableColorWipeEffectColor')
+AddressableScanEffect = light_ns.class_('AddressableScanEffect', AddressableLightEffect)
+AddressableTwinkleEffect = light_ns.class_('AddressableTwinkleEffect', AddressableLightEffect)
+AddressableRandomTwinkleEffect = light_ns.class_('AddressableRandomTwinkleEffect',
+                                                 AddressableLightEffect)
+AddressableFireworksEffect = light_ns.class_('AddressableFireworksEffect', AddressableLightEffect)
+AddressableFlickerEffect = light_ns.class_('AddressableFlickerEffect', AddressableLightEffect)
 
 CONF_STROBE = 'strobe'
 CONF_FLICKER = 'flicker'
-CONF_FASTLED_LAMBDA = 'fastled_lambda'
-CONF_FASTLED_RAINBOW = 'fastled_rainbow'
-CONF_FASTLED_COLOR_WIPE = 'fastled_color_wipe'
-CONF_FASTLED_SCAN = 'fastled_scan'
-CONF_FASTLED_TWINKLE = 'fastled_twinkle'
-CONF_FASTLED_RANDOM_TWINKLE = 'fastled_random_twinkle'
-CONF_FASTLED_FIREWORKS = 'fastled_fireworks'
-CONF_FASTLED_FLICKER = 'fastled_flicker'
+CONF_ADDRESSABLE_LAMBDA = 'addressable_lambda'
+CONF_ADDRESSABLE_RAINBOW = 'addressable_rainbow'
+CONF_ADDRESSABLE_COLOR_WIPE = 'addressable_color_wipe'
+CONF_ADDRESSABLE_SCAN = 'addressable_scan'
+CONF_ADDRESSABLE_TWINKLE = 'addressable_twinkle'
+CONF_ADDRESSABLE_RANDOM_TWINKLE = 'addressable_random_twinkle'
+CONF_ADDRESSABLE_FIREWORKS = 'addressable_fireworks'
+CONF_ADDRESSABLE_FLICKER = 'addressable_flicker'
 
 CONF_ADD_LED_INTERVAL = 'add_led_interval'
 CONF_REVERSE = 'reverse'
@@ -76,27 +83,27 @@ CONF_INTENSITY = 'intensity'
 BINARY_EFFECTS = [CONF_LAMBDA, CONF_STROBE]
 MONOCHROMATIC_EFFECTS = BINARY_EFFECTS + [CONF_FLICKER]
 RGB_EFFECTS = MONOCHROMATIC_EFFECTS + [CONF_RANDOM]
-FASTLED_EFFECTS = RGB_EFFECTS + [CONF_FASTLED_LAMBDA, CONF_FASTLED_RAINBOW, CONF_FASTLED_COLOR_WIPE,
-                                 CONF_FASTLED_SCAN, CONF_FASTLED_TWINKLE,
-                                 CONF_FASTLED_RANDOM_TWINKLE, CONF_FASTLED_FIREWORKS,
-                                 CONF_FASTLED_FLICKER]
+ADDRESSABLE_EFFECTS = RGB_EFFECTS + [CONF_ADDRESSABLE_LAMBDA, CONF_ADDRESSABLE_RAINBOW,
+                                     CONF_ADDRESSABLE_COLOR_WIPE, CONF_ADDRESSABLE_SCAN,
+                                     CONF_ADDRESSABLE_TWINKLE, CONF_ADDRESSABLE_RANDOM_TWINKLE,
+                                     CONF_ADDRESSABLE_FIREWORKS, CONF_ADDRESSABLE_FLICKER]
 
-EFFECTS_SCHEMA = vol.Schema({
-    vol.Optional(CONF_LAMBDA): vol.Schema({
+EFFECTS_SCHEMA = cv.Schema({
+    vol.Optional(CONF_LAMBDA): cv.Schema({
         vol.Required(CONF_NAME): cv.string,
         vol.Required(CONF_LAMBDA): cv.lambda_,
         vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_RANDOM): vol.Schema({
+    vol.Optional(CONF_RANDOM): cv.Schema({
         cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(RandomLightEffect),
         vol.Optional(CONF_NAME, default="Random"): cv.string,
         vol.Optional(CONF_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_STROBE): vol.Schema({
+    vol.Optional(CONF_STROBE): cv.Schema({
         cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(StrobeLightEffect),
         vol.Optional(CONF_NAME, default="Strobe"): cv.string,
-        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.All(vol.Schema({
+        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list(cv.Schema({
             vol.Optional(CONF_STATE, default=True): cv.boolean,
             vol.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
             vol.Optional(CONF_RED, default=1.0): cv.percentage,
@@ -105,66 +112,67 @@ EFFECTS_SCHEMA = vol.Schema({
             vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
             vol.Required(CONF_DURATION): cv.positive_time_period_milliseconds,
         }), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE,
-                                    CONF_WHITE))], vol.Length(min=2)),
+                                    CONF_WHITE)), vol.Length(min=2)),
     }),
-    vol.Optional(CONF_FLICKER): vol.Schema({
+    vol.Optional(CONF_FLICKER): cv.Schema({
         cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FlickerLightEffect),
         vol.Optional(CONF_NAME, default="Flicker"): cv.string,
         vol.Optional(CONF_ALPHA): cv.percentage,
         vol.Optional(CONF_INTENSITY): cv.percentage,
     }),
-    vol.Optional(CONF_FASTLED_LAMBDA): vol.Schema({
+    vol.Optional(CONF_ADDRESSABLE_LAMBDA): cv.Schema({
         vol.Required(CONF_NAME): cv.string,
         vol.Required(CONF_LAMBDA): cv.lambda_,
         vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_FASTLED_RAINBOW): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRainbowLightEffect),
+    vol.Optional(CONF_ADDRESSABLE_RAINBOW): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRainbowLightEffect),
         vol.Optional(CONF_NAME, default="Rainbow"): cv.string,
         vol.Optional(CONF_SPEED): cv.uint32_t,
         vol.Optional(CONF_WIDTH): cv.uint32_t,
     }),
-    vol.Optional(CONF_FASTLED_COLOR_WIPE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDColorWipeEffect),
+    vol.Optional(CONF_ADDRESSABLE_COLOR_WIPE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableColorWipeEffect),
         vol.Optional(CONF_NAME, default="Color Wipe"): cv.string,
-        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.Schema({
+        vol.Optional(CONF_COLORS): cv.ensure_list({
             vol.Optional(CONF_RED, default=1.0): cv.percentage,
             vol.Optional(CONF_GREEN, default=1.0): cv.percentage,
             vol.Optional(CONF_BLUE, default=1.0): cv.percentage,
+            vol.Optional(CONF_WHITE, default=1.0): cv.percentage,
             vol.Optional(CONF_RANDOM, default=False): cv.boolean,
             vol.Required(CONF_NUM_LEDS): vol.All(cv.uint32_t, vol.Range(min=1)),
-        })]),
+        }),
         vol.Optional(CONF_ADD_LED_INTERVAL): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_REVERSE): cv.boolean,
     }),
-    vol.Optional(CONF_FASTLED_SCAN): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDScanEffect),
+    vol.Optional(CONF_ADDRESSABLE_SCAN): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableScanEffect),
         vol.Optional(CONF_NAME, default="Scan"): cv.string,
         vol.Optional(CONF_MOVE_INTERVAL): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_FASTLED_TWINKLE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDTwinkleEffect),
+    vol.Optional(CONF_ADDRESSABLE_TWINKLE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableTwinkleEffect),
         vol.Optional(CONF_NAME, default="Twinkle"): cv.string,
         vol.Optional(CONF_TWINKLE_PROBABILITY): cv.percentage,
         vol.Optional(CONF_PROGRESS_INTERVAL): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_FASTLED_RANDOM_TWINKLE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRandomTwinkleEffect),
+    vol.Optional(CONF_ADDRESSABLE_RANDOM_TWINKLE): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRandomTwinkleEffect),
         vol.Optional(CONF_NAME, default="Random Twinkle"): cv.string,
         vol.Optional(CONF_TWINKLE_PROBABILITY): cv.percentage,
         vol.Optional(CONF_PROGRESS_INTERVAL): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_FASTLED_FIREWORKS): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDFireworksEffect),
+    vol.Optional(CONF_ADDRESSABLE_FIREWORKS): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFireworksEffect),
         vol.Optional(CONF_NAME, default="Fireworks"): cv.string,
         vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_SPARK_PROBABILITY): cv.percentage,
         vol.Optional(CONF_USE_RANDOM_COLOR): cv.boolean,
         vol.Optional(CONF_FADE_OUT_RATE): cv.uint8_t,
     }),
-    vol.Optional(CONF_FASTLED_FLICKER): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDFlickerEffect),
-        vol.Optional(CONF_NAME, default="FastLED Flicker"): cv.string,
+    vol.Optional(CONF_ADDRESSABLE_FLICKER): cv.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFlickerEffect),
+        vol.Optional(CONF_NAME, default="Addressable Flicker"): cv.string,
         vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_INTENSITY): cv.percentage,
     }),
@@ -173,28 +181,64 @@ EFFECTS_SCHEMA = vol.Schema({
 
 def validate_effects(allowed_effects):
     def validator(value):
-        value = cv.ensure_list(value)
+        is_list = isinstance(value, list)
+        if not is_list:
+            value = [value]
         names = set()
         ret = []
+        errors = []
         for i, effect in enumerate(value):
+            path = [i] if is_list else []
             if not isinstance(effect, dict):
-                raise vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)))
+                errors.append(
+                    vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)),
+                                path)
+                )
+                continue
             if len(effect) > 1:
-                raise vol.Invalid("Each entry in the 'effects:' option must be a single effect.")
+                errors.append(
+                    vol.Invalid("Each entry in the 'effects:' option must be a single effect.",
+                                path)
+                )
+                continue
             if not effect:
-                raise vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i))
+                errors.append(
+                    vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i),
+                                path)
+                )
+                continue
             key = next(iter(effect.keys()))
+            if key.startswith('fastled'):
+                errors.append(
+                    vol.Invalid("FastLED effects have been renamed to addressable effects. "
+                                "Please use '{}'".format(key.replace('fastled', 'addressable')),
+                                path)
+                )
+                continue
             if key not in allowed_effects:
-                raise vol.Invalid("The effect '{}' does not exist or is not allowed for this "
-                                  "light type".format(key))
+                errors.append(
+                    vol.Invalid("The effect '{}' does not exist or is not allowed for this "
+                                "light type".format(key), path)
+                )
+                continue
             effect[key] = effect[key] or {}
-            conf = EFFECTS_SCHEMA(effect)
+            try:
+                conf = EFFECTS_SCHEMA(effect)
+            except vol.Invalid as err:
+                err.prepend(path)
+                errors.append(err)
+                continue
             name = conf[key][CONF_NAME]
             if name in names:
-                raise vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
-                                  u"unique names".format(name))
+                errors.append(
+                    vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
+                                u"unique names".format(name), [i])
+                )
+                continue
             names.add(name)
             ret.append(conf)
+        if errors:
+            raise vol.MultipleInvalid(errors)
         return ret
 
     return validator
@@ -212,7 +256,7 @@ def build_effect(full_config):
     key, config = next(iter(full_config.items()))
     if key == CONF_LAMBDA:
         lambda_ = None
-        for lambda_ in process_lambda(config[CONF_LAMBDA], []):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [], return_type=void):
             yield None
         yield LambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
     elif key == CONF_RANDOM:
@@ -236,7 +280,7 @@ def build_effect(full_config):
                 ('duration', color[CONF_DURATION]),
             ))
         if colors:
-            add(effect.set_colors(ArrayInitializer(*colors)))
+            add(effect.set_colors(colors))
         yield effect
     elif key == CONF_FLICKER:
         rhs = FlickerLightEffect.new(config[CONF_NAME])
@@ -246,21 +290,22 @@ def build_effect(full_config):
         if CONF_INTENSITY in config:
             add(effect.set_intensity(config[CONF_INTENSITY]))
         yield effect
-    elif key == CONF_FASTLED_LAMBDA:
-        args = [(FastLEDLightOutputComponentRef, 'it')]
-        for lambda_ in process_lambda(config[CONF_LAMBDA], args):
+    elif key == CONF_ADDRESSABLE_LAMBDA:
+        args = [(AddressableLightRef, 'it')]
+        for lambda_ in process_lambda(config[CONF_LAMBDA], args, return_type=void):
             yield None
-        yield FastLEDLambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
-    elif key == CONF_FASTLED_RAINBOW:
-        rhs = FastLEDRainbowLightEffect.new(config[CONF_NAME])
+        yield AddressableLambdaLightEffect.new(config[CONF_NAME], lambda_,
+                                               config[CONF_UPDATE_INTERVAL])
+    elif key == CONF_ADDRESSABLE_RAINBOW:
+        rhs = AddressableRainbowLightEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_SPEED in config:
             add(effect.set_speed(config[CONF_SPEED]))
         if CONF_WIDTH in config:
             add(effect.set_width(config[CONF_WIDTH]))
         yield effect
-    elif key == CONF_FASTLED_COLOR_WIPE:
-        rhs = FastLEDColorWipeEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_COLOR_WIPE:
+        rhs = AddressableColorWipeEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_ADD_LED_INTERVAL in config:
             add(effect.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
@@ -269,40 +314,41 @@ def build_effect(full_config):
         colors = []
         for color in config.get(CONF_COLORS, []):
             colors.append(StructInitializer(
-                FastLEDColorWipeEffectColor,
-                ('r', color[CONF_RED]),
-                ('g', color[CONF_GREEN]),
-                ('b', color[CONF_BLUE]),
+                AddressableColorWipeEffectColor,
+                ('r', int(round(color[CONF_RED] * 255))),
+                ('g', int(round(color[CONF_GREEN] * 255))),
+                ('b', int(round(color[CONF_BLUE] * 255))),
+                ('w', int(round(color[CONF_WHITE] * 255))),
                 ('random', color[CONF_RANDOM]),
                 ('num_leds', color[CONF_NUM_LEDS]),
             ))
         if colors:
-            add(effect.set_colors(ArrayInitializer(*colors)))
+            add(effect.set_colors(colors))
         yield effect
-    elif key == CONF_FASTLED_SCAN:
-        rhs = FastLEDScanEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_SCAN:
+        rhs = AddressableScanEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_MOVE_INTERVAL in config:
             add(effect.set_move_interval(config[CONF_MOVE_INTERVAL]))
         yield effect
-    elif key == CONF_FASTLED_TWINKLE:
-        rhs = FastLEDTwinkleEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_TWINKLE:
+        rhs = AddressableTwinkleEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_TWINKLE_PROBABILITY in config:
             add(effect.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
         if CONF_PROGRESS_INTERVAL in config:
             add(effect.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
         yield effect
-    elif key == CONF_FASTLED_RANDOM_TWINKLE:
-        rhs = FastLEDRandomTwinkleEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_RANDOM_TWINKLE:
+        rhs = AddressableRandomTwinkleEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_TWINKLE_PROBABILITY in config:
             add(effect.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
         if CONF_PROGRESS_INTERVAL in config:
             add(effect.set_progress_interval(config[CONF_PROGRESS_INTERVAL]))
         yield effect
-    elif key == CONF_FASTLED_FIREWORKS:
-        rhs = FastLEDFireworksEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_FIREWORKS:
+        rhs = AddressableFireworksEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_UPDATE_INTERVAL in config:
             add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
@@ -313,8 +359,8 @@ def build_effect(full_config):
         if CONF_FADE_OUT_RATE in config:
             add(effect.set_spark_probability(config[CONF_FADE_OUT_RATE]))
         yield effect
-    elif key == CONF_FASTLED_FLICKER:
-        rhs = FastLEDFlickerEffect.new(config[CONF_NAME])
+    elif key == CONF_ADDRESSABLE_FLICKER:
+        rhs = AddressableFlickerEffect.new(config[CONF_NAME])
         effect = Pvariable(config[CONF_EFFECT_ID], rhs)
         if CONF_UPDATE_INTERVAL in config:
             add(effect.set_update_interval(config[CONF_UPDATE_INTERVAL]))
@@ -325,7 +371,7 @@ def build_effect(full_config):
         raise NotImplementedError("Effect {} not implemented".format(next(config.keys())))
 
 
-def setup_light_core_(light_var, mqtt_var, config):
+def setup_light_core_(light_var, config):
     if CONF_INTERNAL in config:
         add(light_var.set_internal(config[CONF_INTERNAL]))
     if CONF_DEFAULT_TRANSITION_LENGTH in config:
@@ -338,15 +384,14 @@ def setup_light_core_(light_var, mqtt_var, config):
             yield
         effects.append(effect)
     if effects:
-        add(light_var.add_effects(ArrayInitializer(*effects)))
+        add(light_var.add_effects(effects))
 
-    setup_mqtt_component(mqtt_var, config)
+    setup_mqtt_component(light_var.Pget_mqtt(), config)
 
 
-def setup_light(light_obj, mqtt_obj, config):
+def setup_light(light_obj, config):
     light_var = Pvariable(config[CONF_ID], light_obj, has_side_effects=False)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
-    add_job(setup_light_core_, light_var, mqtt_var, config)
+    CORE.add_job(setup_light_core_, light_var, config)
 
 
 BUILD_FLAGS = '-DUSE_LIGHT'
@@ -359,15 +404,14 @@ LIGHT_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_LIGHT_TOGGLE, LIGHT_TOGGLE_ACTION_SCHEMA)
-def light_toggle_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def light_toggle_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_toggle_action(template_arg)
     type = ToggleAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
     if CONF_TRANSITION_LENGTH in config:
-        for template_ in templatable(config[CONF_TRANSITION_LENGTH], arg_type, uint32):
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
             yield None
         add(action.set_transition_length(template_))
     yield action
@@ -381,15 +425,14 @@ LIGHT_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_LIGHT_TURN_OFF, LIGHT_TURN_OFF_ACTION_SCHEMA)
-def light_turn_off_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def light_turn_off_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_off_action(template_arg)
     type = TurnOffAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
     if CONF_TRANSITION_LENGTH in config:
-        for template_ in templatable(config[CONF_TRANSITION_LENGTH], arg_type, uint32):
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
             yield None
         add(action.set_transition_length(template_))
     yield action
@@ -413,68 +456,46 @@ LIGHT_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_LIGHT_TURN_ON, LIGHT_TURN_ON_ACTION_SCHEMA)
-def light_turn_on_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def light_turn_on_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_on_action(template_arg)
     type = TurnOnAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
     if CONF_TRANSITION_LENGTH in config:
-        for template_ in templatable(config[CONF_TRANSITION_LENGTH], arg_type, uint32):
+        for template_ in templatable(config[CONF_TRANSITION_LENGTH], args, uint32):
             yield None
         add(action.set_transition_length(template_))
     if CONF_FLASH_LENGTH in config:
-        for template_ in templatable(config[CONF_FLASH_LENGTH], arg_type, uint32):
+        for template_ in templatable(config[CONF_FLASH_LENGTH], args, uint32):
             yield None
         add(action.set_flash_length(template_))
     if CONF_BRIGHTNESS in config:
-        for template_ in templatable(config[CONF_BRIGHTNESS], arg_type, float_):
+        for template_ in templatable(config[CONF_BRIGHTNESS], args, float_):
             yield None
         add(action.set_brightness(template_))
     if CONF_RED in config:
-        for template_ in templatable(config[CONF_RED], arg_type, float_):
+        for template_ in templatable(config[CONF_RED], args, float_):
             yield None
         add(action.set_red(template_))
     if CONF_GREEN in config:
-        for template_ in templatable(config[CONF_GREEN], arg_type, float_):
+        for template_ in templatable(config[CONF_GREEN], args, float_):
             yield None
         add(action.set_green(template_))
     if CONF_BLUE in config:
-        for template_ in templatable(config[CONF_BLUE], arg_type, float_):
+        for template_ in templatable(config[CONF_BLUE], args, float_):
             yield None
         add(action.set_blue(template_))
     if CONF_WHITE in config:
-        for template_ in templatable(config[CONF_WHITE], arg_type, float_):
+        for template_ in templatable(config[CONF_WHITE], args, float_):
             yield None
         add(action.set_white(template_))
     if CONF_COLOR_TEMPERATURE in config:
-        for template_ in templatable(config[CONF_COLOR_TEMPERATURE], arg_type, float_):
+        for template_ in templatable(config[CONF_COLOR_TEMPERATURE], args, float_):
             yield None
         add(action.set_color_temperature(template_))
     if CONF_EFFECT in config:
-        for template_ in templatable(config[CONF_EFFECT], arg_type, std_string):
+        for template_ in templatable(config[CONF_EFFECT], args, std_string):
             yield None
         add(action.set_effect(template_))
     yield action
-
-
-def core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=True,
-                        white_value=True):
-    ret = mqtt.build_hass_config(data, 'light', config, include_state=True, include_command=True,
-                                 platform='mqtt_json')
-    if ret is None:
-        return None
-    if brightness:
-        ret['brightness'] = True
-    if rgb:
-        ret['rgb'] = True
-    if color_temp:
-        ret['color_temp'] = True
-    if white_value:
-        ret['white_value'] = True
-    for effect in config.get(CONF_EFFECTS, []):
-        ret["effect"] = True
-        effects = ret.setdefault("effect_list", [])
-        effects.append(next(x for x in effect.values())[CONF_NAME])
-    return ret

esphome/components/light/binary.py

@@ -1,9 +1,11 @@
 import voluptuous as vol
 
-from esphomeyaml.components import light, output
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_EFFECTS, CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, get_variable, setup_component, variable
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_EFFECTS, CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
@@ -17,10 +19,5 @@ def to_code(config):
         yield
     rhs = App.make_binary_light(config[CONF_NAME], output_)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=False, rgb=False, color_temp=False,
-                                     white_value=False)

esphome/components/light/cwww.py

@@ -1,13 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light, output
-from esphomeyaml.components.light.rgbww import validate_cold_white_colder, \
+from esphome.components import light, output
+from esphome.components.light.rgbww import validate_cold_white_colder, \
     validate_color_temperature
-from esphomeyaml.const import CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
+import esphome.config_validation as cv
+from esphome.const import CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
     CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
     CONF_NAME, CONF_WARM_WHITE, CONF_WARM_WHITE_COLOR_TEMPERATURE
-from esphomeyaml.helpers import App, get_variable, variable, setup_component
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
@@ -31,10 +33,5 @@ def to_code(config):
                               config[CONF_WARM_WHITE_COLOR_TEMPERATURE],
                               cold_white, warm_white)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=False, color_temp=True,
-                                     white_value=False)

esphome/components/light/fastled_clockless.py

@@ -1,14 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import light
-from esphomeyaml.components.power_supply import PowerSupplyComponent
-from esphomeyaml.const import CONF_CHIPSET, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, \
-    CONF_RGB_ORDER, CONF_EFFECTS, CONF_COLOR_CORRECT
-from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
-    get_variable, variable, setup_component
+from esphome import pins
+from esphome.components import light
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHIPSET, CONF_COLOR_CORRECT, CONF_DEFAULT_TRANSITION_LENGTH, \
+    CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, \
+    CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphome.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
 
 TYPES = [
     'NEOPIXEL',
@@ -56,20 +57,21 @@ def validate(value):
 MakeFastLEDLight = Application.struct('MakeFastLEDLight')
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
 
-    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*TYPES)),
+    vol.Required(CONF_CHIPSET): cv.one_of(*TYPES, upper=True),
     vol.Required(CONF_PIN): pins.output_pin,
 
     vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
     vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
-    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+    vol.Optional(CONF_RGB_ORDER): cv.one_of(*RGB_ORDERS, upper=True),
 
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=3)),
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
-    vol.Optional(CONF_EFFECTS): light.validate_effects(light.FASTLED_EFFECTS),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
 }).extend(cv.COMPONENT_SCHEMA.schema), validate)
 
 
@@ -97,13 +99,10 @@ def to_code(config):
         r, g, b = config[CONF_COLOR_CORRECT]
         add(fast_led.set_correction(r, g, b))
 
-    light.setup_light(make.Pstate, make.Pmqtt, config)
+    light.setup_light(make.Pstate, config)
     setup_component(fast_led, config)
 
 
-BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+REQUIRED_BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
 
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=False)
+LIB_DEPS = 'FastLED@3.2.0'

esphome/components/light/fastled_spi.py

@@ -1,14 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import light
-from esphomeyaml.components.power_supply import PowerSupplyComponent
-from esphomeyaml.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_DATA_PIN, \
-    CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_MAX_REFRESH_RATE, \
-    CONF_NAME, CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER, CONF_EFFECTS, CONF_COLOR_CORRECT
-from esphomeyaml.helpers import App, Application, RawExpression, TemplateArguments, add, \
-    get_variable, variable, setup_component
+from esphome import pins
+from esphome.components import light
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_COLOR_CORRECT, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
+    CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphome.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
 
 CHIPSETS = [
     'LPD8806',
@@ -33,21 +34,22 @@ RGB_ORDERS = [
 MakeFastLEDLight = Application.struct('MakeFastLEDLight')
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
 
-    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*CHIPSETS)),
+    vol.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
     vol.Required(CONF_DATA_PIN): pins.output_pin,
     vol.Required(CONF_CLOCK_PIN): pins.output_pin,
 
     vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
-    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
+    vol.Optional(CONF_RGB_ORDER): cv.one_of(*RGB_ORDERS, upper=True),
     vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
 
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=3)),
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
-    vol.Optional(CONF_EFFECTS): light.validate_effects(light.FASTLED_EFFECTS),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
 
@@ -77,13 +79,10 @@ def to_code(config):
         r, g, b = config[CONF_COLOR_CORRECT]
         add(fast_led.set_correction(r, g, b))
 
-    light.setup_light(make.Pstate, make.Pmqtt, config)
+    light.setup_light(make.Pstate, config)
     setup_component(fast_led, config)
 
 
-BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
+REQUIRED_BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
 
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=False)
+LIB_DEPS = 'FastLED@3.2.0'

esphome/components/light/monochromatic.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml.components import light, output
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, \
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, \
     CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
-from esphomeyaml.helpers import App, get_variable, setup_component, variable
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
@@ -20,10 +22,5 @@ def to_code(config):
         yield
     rhs = App.make_monochromatic_light(config[CONF_NAME], output_)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=False, color_temp=False,
-                                     white_value=False)

esphome/components/light/neopixelbus.py

@@ -0,0 +1,190 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import light
+from esphome.components.light import AddressableLight
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CLOCK_PIN, CONF_COLOR_CORRECT, CONF_DATA_PIN, \
+    CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_MAKE_ID, CONF_METHOD, \
+    CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, CONF_TYPE, CONF_VARIANT
+from esphome.core import CORE
+from esphome.cpp_generator import TemplateArguments, add, get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application, Component, global_ns
+
+NeoPixelBusLightOutputBase = light.light_ns.class_('NeoPixelBusLightOutputBase', Component,
+                                                   AddressableLight)
+ESPNeoPixelOrder = light.light_ns.namespace('ESPNeoPixelOrder')
+
+
+def validate_type(value):
+    value = cv.string(value).upper()
+    if 'R' not in value:
+        raise vol.Invalid("Must have R in type")
+    if 'G' not in value:
+        raise vol.Invalid("Must have G in type")
+    if 'B' not in value:
+        raise vol.Invalid("Must have B in type")
+    rest = set(value) - set('RGBW')
+    if rest:
+        raise vol.Invalid("Type has invalid color: {}".format(', '.join(rest)))
+    if len(set(value)) != len(value):
+        raise vol.Invalid("Type has duplicate color!")
+    return value
+
+
+def validate_variant(value):
+    value = cv.string(value).upper()
+    if value == 'WS2813':
+        value = 'WS2812X'
+    if value == 'WS2812':
+        value = '800KBPS'
+    if value == 'LC8812':
+        value = 'SK6812'
+    return cv.one_of(*VARIANTS)(value)
+
+
+def validate_method(value):
+    if value is None:
+        if CORE.is_esp32:
+            return 'ESP32_I2S_1'
+        if CORE.is_esp8266:
+            return 'ESP8266_DMA'
+        raise NotImplementedError
+
+    if CORE.is_esp32:
+        return cv.one_of(*ESP32_METHODS, upper=True, space='_')(value)
+    if CORE.is_esp8266:
+        return cv.one_of(*ESP8266_METHODS, upper=True, space='_')(value)
+    raise NotImplementedError
+
+
+def validate_method_pin(value):
+    method = value[CONF_METHOD]
+    method_pins = {
+        'ESP8266_DMA': [3],
+        'ESP8266_UART0': [1],
+        'ESP8266_ASYNC_UART0': [1],
+        'ESP8266_UART1': [2],
+        'ESP8266_ASYNC_UART1': [2],
+        'ESP32_I2S_0': list(range(0, 32)),
+        'ESP32_I2S_1': list(range(0, 32)),
+    }
+    if CORE.is_esp8266:
+        method_pins['BIT_BANG'] = list(range(0, 16))
+    elif CORE.is_esp32:
+        method_pins['BIT_BANG'] = list(range(0, 32))
+    pins_ = method_pins[method]
+    for opt in (CONF_PIN, CONF_CLOCK_PIN, CONF_DATA_PIN):
+        if opt in value and value[opt] not in pins_:
+            raise vol.Invalid("Method {} only supports pin(s) {}".format(
+                method, ', '.join('GPIO{}'.format(x) for x in pins_)
+            ), path=[CONF_METHOD])
+    return value
+
+
+VARIANTS = {
+    'WS2812X': 'Ws2812x',
+    'SK6812': 'Sk6812',
+    '800KBPS': '800Kbps',
+    '400KBPS': '400Kbps',
+}
+
+ESP8266_METHODS = {
+    'ESP8266_DMA': 'NeoEsp8266Dma{}Method',
+    'ESP8266_UART0': 'NeoEsp8266Uart0{}Method',
+    'ESP8266_UART1': 'NeoEsp8266Uart1{}Method',
+    'ESP8266_ASYNC_UART0': 'NeoEsp8266AsyncUart0{}Method',
+    'ESP8266_ASYNC_UART1': 'NeoEsp8266AsyncUart1{}Method',
+    'BIT_BANG': 'NeoEsp8266BitBang{}Method',
+}
+ESP32_METHODS = {
+    'ESP32_I2S_0': 'NeoEsp32I2s0{}Method',
+    'ESP32_I2S_1': 'NeoEsp32I2s1{}Method',
+    'BIT_BANG': 'NeoEsp32BitBang{}Method',
+}
+
+
+def format_method(config):
+    variant = VARIANTS[config[CONF_VARIANT]]
+    method = config[CONF_METHOD]
+    if CORE.is_esp8266:
+        return ESP8266_METHODS[method].format(variant)
+    if CORE.is_esp32:
+        return ESP32_METHODS[method].format(variant)
+    raise NotImplementedError
+
+
+def validate(config):
+    if CONF_PIN in config:
+        if CONF_CLOCK_PIN in config or CONF_DATA_PIN in config:
+            raise vol.Invalid("Cannot specify both 'pin' and 'clock_pin'+'data_pin'")
+        return config
+    if CONF_CLOCK_PIN in config:
+        if CONF_DATA_PIN not in config:
+            raise vol.Invalid("If you give clock_pin, you must also specify data_pin")
+        return config
+    raise vol.Invalid("Must specify at least one of 'pin' or 'clock_pin'+'data_pin'")
+
+
+MakeNeoPixelBusLight = Application.struct('MakeNeoPixelBusLight')
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeNeoPixelBusLight),
+
+    vol.Optional(CONF_TYPE, default='GRB'): validate_type,
+    vol.Optional(CONF_VARIANT, default='800KBPS'): validate_variant,
+    vol.Optional(CONF_METHOD, default=None): validate_method,
+    vol.Optional(CONF_PIN): pins.output_pin,
+    vol.Optional(CONF_CLOCK_PIN): pins.output_pin,
+    vol.Optional(CONF_DATA_PIN): pins.output_pin,
+
+    vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
+
+    vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
+    vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=4)),
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}).extend(cv.COMPONENT_SCHEMA.schema), validate, validate_method_pin)
+
+
+def to_code(config):
+    type_ = config[CONF_TYPE]
+    has_white = 'W' in type_
+    if has_white:
+        func = App.make_neo_pixel_bus_rgbw_light
+        color_feat = global_ns.NeoRgbwFeature
+    else:
+        func = App.make_neo_pixel_bus_rgb_light
+        color_feat = global_ns.NeoRgbFeature
+
+    template = TemplateArguments(getattr(global_ns, format_method(config)), color_feat)
+    rhs = func(template, config[CONF_NAME])
+    make = variable(config[CONF_MAKE_ID], rhs, type=MakeNeoPixelBusLight.template(template))
+    output = make.Poutput
+
+    if CONF_PIN in config:
+        add(output.add_leds(config[CONF_NUM_LEDS], config[CONF_PIN]))
+    else:
+        add(output.add_leds(config[CONF_NUM_LEDS], config[CONF_CLOCK_PIN], config[CONF_DATA_PIN]))
+
+    add(output.set_pixel_order(getattr(ESPNeoPixelOrder, type_)))
+
+    if CONF_POWER_SUPPLY in config:
+        for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
+            yield
+        add(output.set_power_supply(power_supply))
+
+    if CONF_COLOR_CORRECT in config:
+        add(output.set_correction(*config[CONF_COLOR_CORRECT]))
+
+    light.setup_light(make.Pstate, config)
+    setup_component(output, config)
+
+
+REQUIRED_BUILD_FLAGS = '-DUSE_NEO_PIXEL_BUS_LIGHT'
+
+LIB_DEPS = 'NeoPixelBus@2.4.1'

esphome/components/light/partition.py

@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+from esphome.components import light
+from esphome.components.light import AddressableLight
+import esphome.config_validation as cv
+from esphome.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_FROM, CONF_ID, \
+    CONF_MAKE_ID, CONF_NAME, CONF_SEGMENTS, CONF_TO
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_types import App, Application
+
+AddressableSegment = light.light_ns.class_('AddressableSegment')
+PartitionLightOutput = light.light_ns.class_('PartitionLightOutput', AddressableLight)
+MakePartitionLight = Application.struct('MakePartitionLight')
+
+
+def validate_from_to(value):
+    if value[CONF_FROM] > value[CONF_TO]:
+        raise vol.Invalid(u"From ({}) must not be larger than to ({})"
+                          u"".format(value[CONF_FROM], value[CONF_TO]))
+    return value
+
+
+PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(light.AddressableLightState),
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakePartitionLight),
+
+    vol.Required(CONF_SEGMENTS): vol.All(cv.ensure_list({
+        vol.Required(CONF_ID): cv.use_variable_id(light.AddressableLightState),
+        vol.Required(CONF_FROM): cv.positive_int,
+        vol.Required(CONF_TO): cv.positive_int,
+    }, validate_from_to), vol.Length(min=1)),
+
+    vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.ADDRESSABLE_EFFECTS),
+}))
+
+
+def to_code(config):
+    segments = []
+    for conf in config[CONF_SEGMENTS]:
+        for var in get_variable(conf[CONF_ID]):
+            yield
+        segments.append(AddressableSegment(var, conf[CONF_FROM],
+                                           conf[CONF_TO] - conf[CONF_FROM] + 1))
+
+    rhs = App.make_partition_light(config[CONF_NAME], segments)
+    make = variable(config[CONF_MAKE_ID], rhs)
+    light.setup_light(make.Pstate, config)

esphome/components/light/rgb.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light, output
-from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_EFFECTS
-from esphomeyaml.helpers import App, get_variable, variable, setup_component
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
+    CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
@@ -26,10 +28,5 @@ def to_code(config):
         yield
     rhs = App.make_rgb_light(config[CONF_NAME], red, green, blue)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=False)

esphome/components/light/rgbw.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light, output
-from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE, CONF_EFFECTS
-from esphomeyaml.helpers import App, get_variable, variable, setup_component
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
+    CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED, CONF_WHITE
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
@@ -29,10 +31,5 @@ def to_code(config):
         yield
     rhs = App.make_rgbw_light(config[CONF_NAME], red, green, blue, white)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=True)

esphome/components/light/rgbww.py

@@ -1,11 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light, output
-from esphomeyaml.const import CONF_BLUE, CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
+from esphome.components import light, output
+import esphome.config_validation as cv
+from esphome.const import CONF_BLUE, CONF_COLD_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
     CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, \
     CONF_NAME, CONF_RED, CONF_WARM_WHITE, CONF_WARM_WHITE_COLOR_TEMPERATURE
-from esphomeyaml.helpers import App, get_variable, variable, setup_component
+from esphome.cpp_generator import get_variable, variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 
 def validate_color_temperature(value):
@@ -59,10 +61,5 @@ def to_code(config):
                                config[CONF_WARM_WHITE_COLOR_TEMPERATURE],
                                red, green, blue, cold_white, warm_white)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
-    light.setup_light(light_struct.Pstate, light_struct.Pmqtt, config)
+    light.setup_light(light_struct.Pstate, config)
     setup_component(light_struct.Pstate, config)
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=True,
-                                     white_value=True)

esphome/components/logger.py

@@ -0,0 +1,184 @@
+import re
+
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY, LambdaAction
+import esphome.config_validation as cv
+from esphome.const import CONF_ARGS, CONF_BAUD_RATE, CONF_FORMAT, CONF_HARDWARE_UART, CONF_ID, \
+    CONF_LEVEL, CONF_LOGS, CONF_TAG, CONF_TX_BUFFER_SIZE
+from esphome.core import CORE, EsphomeError, Lambda
+from esphome.cpp_generator import Pvariable, RawExpression, add, process_lambda, statement
+from esphome.cpp_types import App, Component, esphome_ns, global_ns, void
+from esphome.py_compat import text_type
+
+LOG_LEVELS = {
+    'NONE': global_ns.ESPHOME_LOG_LEVEL_NONE,
+    'ERROR': global_ns.ESPHOME_LOG_LEVEL_ERROR,
+    'WARN': global_ns.ESPHOME_LOG_LEVEL_WARN,
+    'INFO': global_ns.ESPHOME_LOG_LEVEL_INFO,
+    'DEBUG': global_ns.ESPHOME_LOG_LEVEL_DEBUG,
+    'VERBOSE': global_ns.ESPHOME_LOG_LEVEL_VERBOSE,
+    'VERY_VERBOSE': global_ns.ESPHOME_LOG_LEVEL_VERY_VERBOSE,
+}
+
+LOG_LEVEL_TO_ESP_LOG = {
+    'ERROR': global_ns.ESP_LOGE,
+    'WARN': global_ns.ESP_LOGW,
+    'INFO': global_ns.ESP_LOGI,
+    'DEBUG': global_ns.ESP_LOGD,
+    'VERBOSE': global_ns.ESP_LOGV,
+    'VERY_VERBOSE': global_ns.ESP_LOGVV,
+}
+
+LOG_LEVEL_SEVERITY = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE', 'VERY_VERBOSE']
+
+UART_SELECTION_ESP32 = ['UART0', 'UART1', 'UART2']
+
+UART_SELECTION_ESP8266 = ['UART0', 'UART0_SWAP', 'UART1']
+
+HARDWARE_UART_TO_UART_SELECTION = {
+    'UART0': global_ns.UART_SELECTION_UART0,
+    'UART0_SWAP': global_ns.UART_SELECTION_UART0_SWAP,
+    'UART1': global_ns.UART_SELECTION_UART1,
+    'UART2': global_ns.UART_SELECTION_UART2,
+}
+
+HARDWARE_UART_TO_SERIAL = {
+    'UART0': 'Serial',
+    'UART0_SWAP': 'Serial',
+    'UART1': 'Serial1',
+    'UART2': 'Serial2',
+}
+
+# pylint: disable=invalid-name
+is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
+
+
+def uart_selection(value):
+    if CORE.is_esp32:
+        return cv.one_of(*UART_SELECTION_ESP32, upper=True)(value)
+    if CORE.is_esp8266:
+        return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
+    raise NotImplementedError
+
+
+def validate_local_no_higher_than_global(value):
+    global_level = value.get(CONF_LEVEL, 'DEBUG')
+    for tag, level in value.get(CONF_LOGS, {}).items():
+        if LOG_LEVEL_SEVERITY.index(level) > LOG_LEVEL_SEVERITY.index(global_level):
+            raise EsphomeError(u"The local log level {} for {} must be less severe than the "
+                               u"global log level {}.".format(level, tag, global_level))
+    return value
+
+
+LogComponent = esphome_ns.class_('LogComponent', Component)
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(LogComponent),
+    vol.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
+    vol.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
+    vol.Optional(CONF_HARDWARE_UART, default='UART0'): uart_selection,
+    vol.Optional(CONF_LEVEL): is_log_level,
+    vol.Optional(CONF_LOGS): cv.Schema({
+        cv.string: is_log_level,
+    })
+}), validate_local_no_higher_than_global)
+
+
+def to_code(config):
+    rhs = App.init_log(config.get(CONF_BAUD_RATE),
+                       config.get(CONF_TX_BUFFER_SIZE),
+                       HARDWARE_UART_TO_UART_SELECTION[config.get(CONF_HARDWARE_UART)])
+    log = Pvariable(config[CONF_ID], rhs)
+    if CONF_LEVEL in config:
+        add(log.set_global_log_level(LOG_LEVELS[config[CONF_LEVEL]]))
+    for tag, level in config.get(CONF_LOGS, {}).items():
+        add(log.set_log_level(tag, LOG_LEVELS[level]))
+
+
+def required_build_flags(config):
+    flags = []
+    if CONF_LEVEL in config:
+        flags.append(u'-DESPHOME_LOG_LEVEL={}'.format(str(LOG_LEVELS[config[CONF_LEVEL]])))
+        this_severity = LOG_LEVEL_SEVERITY.index(config[CONF_LEVEL])
+        verbose_severity = LOG_LEVEL_SEVERITY.index('VERBOSE')
+        very_verbose_severity = LOG_LEVEL_SEVERITY.index('VERY_VERBOSE')
+        is_at_least_verbose = this_severity >= verbose_severity
+        is_at_least_very_verbose = this_severity >= very_verbose_severity
+        has_serial_logging = config.get(CONF_BAUD_RATE) != 0
+        if CORE.is_esp8266 and has_serial_logging and is_at_least_verbose:
+            debug_serial_port = HARDWARE_UART_TO_SERIAL[config.get(CONF_HARDWARE_UART)]
+            flags.append(u"-DDEBUG_ESP_PORT={}".format(debug_serial_port))
+            flags.append(u"-DLWIP_DEBUG")
+            DEBUG_COMPONENTS = {
+                'HTTP_CLIENT',
+                'HTTP_SERVER',
+                'HTTP_UPDATE',
+                'OTA',
+                'SSL',
+                'TLS_MEM',
+                'UPDATER',
+                'WIFI',
+            }
+            for comp in DEBUG_COMPONENTS:
+                flags.append(u"-DDEBUG_ESP_{}".format(comp))
+        if CORE.is_esp32 and is_at_least_verbose:
+            flags.append('-DCORE_DEBUG_LEVEL=5')
+        if CORE.is_esp32 and is_at_least_very_verbose:
+            flags.append('-DENABLE_I2C_DEBUG_BUFFER')
+
+    return flags
+
+
+def maybe_simple_message(schema):
+    def validator(value):
+        if isinstance(value, dict):
+            return cv.Schema(schema)(value)
+        return cv.Schema(schema)({CONF_FORMAT: value})
+
+    return validator
+
+
+def validate_printf(value):
+    # https://stackoverflow.com/questions/30011379/how-can-i-parse-a-c-format-string-in-python
+    # pylint: disable=anomalous-backslash-in-string
+    cfmt = u"""\
+    (                                  # start of capture group 1
+    %                                  # literal "%"
+    (?:                                # first option
+    (?:[-+0 #]{0,5})                   # optional flags
+    (?:\d+|\*)?                        # width
+    (?:\.(?:\d+|\*))?                  # precision
+    (?:h|l|ll|w|I|I32|I64)?            # size
+    [cCdiouxXeEfgGaAnpsSZ]             # type
+    ) |                                # OR
+    %%)                                # literal "%%"
+    """  # noqa
+    matches = re.findall(cfmt, value[CONF_FORMAT], flags=re.X)
+    if len(matches) != len(value[CONF_ARGS]):
+        raise vol.Invalid(u"Found {} printf-patterns ({}), but {} args were given!"
+                          u"".format(len(matches), u', '.join(matches), len(value[CONF_ARGS])))
+    return value
+
+
+CONF_LOGGER_LOG = 'logger.log'
+LOGGER_LOG_ACTION_SCHEMA = vol.All(maybe_simple_message({
+    vol.Required(CONF_FORMAT): cv.string,
+    vol.Optional(CONF_ARGS, default=list): cv.ensure_list(cv.lambda_),
+    vol.Optional(CONF_LEVEL, default="DEBUG"): cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
+    vol.Optional(CONF_TAG, default="main"): cv.string,
+}), validate_printf)
+
+
+@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
+def logger_log_action_to_code(config, action_id, template_arg, args):
+    esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
+    args_ = [RawExpression(text_type(x)) for x in config[CONF_ARGS]]
+
+    text = text_type(statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args_)))
+
+    for lambda_ in process_lambda(Lambda(text), args, return_type=void):
+        yield None
+    rhs = LambdaAction.new(template_arg, lambda_)
+    type = LambdaAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/mcp23017.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, GPIOInputPin, GPIOOutputPin, io_ns, esphome_ns
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+MCP23017GPIOMode = esphome_ns.enum('MCP23017GPIOMode')
+MCP23017_GPIO_MODES = {
+    'INPUT': MCP23017GPIOMode.MCP23017_INPUT,
+    'INPUT_PULLUP': MCP23017GPIOMode.MCP23017_INPUT_PULLUP,
+    'OUTPUT': MCP23017GPIOMode.MCP23017_OUTPUT,
+}
+
+MCP23017GPIOInputPin = io_ns.class_('MCP23017GPIOInputPin', GPIOInputPin)
+MCP23017GPIOOutputPin = io_ns.class_('MCP23017GPIOOutputPin', GPIOOutputPin)
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(pins.MCP23017),
+    vol.Optional(CONF_ADDRESS, default=0x20): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_mcp23017_component(config[CONF_ADDRESS])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_MCP23017'

esphome/components/mpr121.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphome.components import i2c, binary_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+CONF_MPR121_ID = 'mpr121_id'
+MPR121Component = binary_sensor.binary_sensor_ns.class_('MPR121Component', Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MPR121Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_mpr121(config.get(CONF_ADDRESS))
+    var = Pvariable(config[CONF_ID], rhs)
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_MPR121'

esphome/components/mqtt.py

@@ -1,23 +1,22 @@
-from collections import OrderedDict
 import re
 
 import voluptuous as vol
 
-from esphomeyaml import automation
-from esphomeyaml.automation import ACTION_REGISTRY
-from esphomeyaml.components import logger
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, CONF_DISCOVERY, \
-    CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, CONF_ID, CONF_KEEPALIVE, CONF_LEVEL, \
-    CONF_LOG_TOPIC, CONF_ON_MESSAGE, CONF_PASSWORD, CONF_PAYLOAD, CONF_PORT, CONF_QOS, \
-    CONF_REBOOT_TIMEOUT, CONF_RETAIN, CONF_SHUTDOWN_MESSAGE, CONF_SSL_FINGERPRINTS, CONF_TOPIC, \
-    CONF_TOPIC_PREFIX, CONF_TRIGGER_ID, CONF_USERNAME, CONF_WILL_MESSAGE, CONF_ON_JSON_MESSAGE, \
-    CONF_STATE_TOPIC, CONF_MQTT, CONF_ESPHOMEYAML, CONF_NAME, CONF_AVAILABILITY, \
-    CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_INTERNAL
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, RawExpression, \
-    StructInitializer, TemplateArguments, add, esphomelib_ns, optional, std_string, templatable, \
-    uint8, bool_, JsonObjectRef, process_lambda, JsonObjectConstRef, Component, Action, Trigger
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition
+from esphome.components import logger
+import esphome.config_validation as cv
+from esphome.const import CONF_AVAILABILITY, CONF_BIRTH_MESSAGE, CONF_BROKER, CONF_CLIENT_ID, \
+    CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_DISCOVERY_PREFIX, CONF_DISCOVERY_RETAIN, \
+    CONF_ID, CONF_KEEPALIVE, CONF_LEVEL, CONF_LOG_TOPIC, CONF_ON_JSON_MESSAGE, CONF_ON_MESSAGE, \
+    CONF_PASSWORD, CONF_PAYLOAD, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PORT, \
+    CONF_QOS, CONF_REBOOT_TIMEOUT, CONF_RETAIN, CONF_SHUTDOWN_MESSAGE, CONF_SSL_FINGERPRINTS, \
+    CONF_STATE_TOPIC, CONF_TOPIC, CONF_TOPIC_PREFIX, CONF_TRIGGER_ID, CONF_USERNAME, \
+    CONF_WILL_MESSAGE
+from esphome.cpp_generator import Pvariable, RawExpression, StructInitializer, TemplateArguments, \
+    add, get_variable, process_lambda, templatable
+from esphome.cpp_types import Action, App, Component, JsonObjectConstRef, JsonObjectRef, \
+    Trigger, bool_, esphome_ns, optional, std_string, uint8, void
 
 
 def validate_message_just_topic(value):
@@ -25,7 +24,7 @@ def validate_message_just_topic(value):
     return MQTT_MESSAGE_BASE({CONF_TOPIC: value})
 
 
-MQTT_MESSAGE_BASE = vol.Schema({
+MQTT_MESSAGE_BASE = cv.Schema({
     vol.Required(CONF_TOPIC): cv.publish_topic,
     vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
     vol.Optional(CONF_RETAIN, default=True): cv.boolean,
@@ -37,7 +36,7 @@ MQTT_MESSAGE_SCHEMA = vol.Any(None, MQTT_MESSAGE_BASE.extend({
     vol.Required(CONF_PAYLOAD): cv.mqtt_payload,
 }))
 
-mqtt_ns = esphomelib_ns.namespace('mqtt')
+mqtt_ns = esphome_ns.namespace('mqtt')
 MQTTMessage = mqtt_ns.struct('MQTTMessage')
 MQTTClientComponent = mqtt_ns.class_('MQTTClientComponent', Component)
 MQTTPublishAction = mqtt_ns.class_('MQTTPublishAction', Action)
@@ -46,14 +45,17 @@ MQTTMessageTrigger = mqtt_ns.class_('MQTTMessageTrigger', Trigger.template(std_s
 MQTTJsonMessageTrigger = mqtt_ns.class_('MQTTJsonMessageTrigger',
                                         Trigger.template(JsonObjectConstRef))
 MQTTComponent = mqtt_ns.class_('MQTTComponent', Component)
+MQTTConnectedCondition = mqtt_ns.class_('MQTTConnectedCondition', Condition)
 
 
-def validate_broker(value):
-    value = cv.string_strict(value)
-    if u':' in value:
-        raise vol.Invalid(u"Please specify the port using the port: option")
-    if not value:
-        raise vol.Invalid(u"Broker cannot be empty")
+def validate_config(value):
+    if CONF_PORT not in value:
+        parts = value[CONF_BROKER].split(u':')
+        if len(parts) == 2:
+            value[CONF_BROKER] = parts[0]
+            value[CONF_PORT] = cv.port(parts[1])
+        else:
+            value[CONF_PORT] = 1883
     return value
 
 
@@ -64,14 +66,14 @@ def validate_fingerprint(value):
     return value
 
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = vol.All(cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(MQTTClientComponent),
-    vol.Required(CONF_BROKER): validate_broker,
-    vol.Optional(CONF_PORT, default=1883): cv.port,
+    vol.Required(CONF_BROKER): cv.string_strict,
+    vol.Optional(CONF_PORT): cv.port,
     vol.Optional(CONF_USERNAME, default=''): cv.string,
     vol.Optional(CONF_PASSWORD, default=''): cv.string,
     vol.Optional(CONF_CLIENT_ID): vol.All(cv.string, vol.Length(max=23)),
-    vol.Optional(CONF_DISCOVERY): cv.boolean,
+    vol.Optional(CONF_DISCOVERY): vol.Any(cv.boolean, cv.one_of("CLEAN", upper=True)),
     vol.Optional(CONF_DISCOVERY_RETAIN): cv.boolean,
     vol.Optional(CONF_DISCOVERY_PREFIX): cv.publish_topic,
     vol.Optional(CONF_BIRTH_MESSAGE): MQTT_MESSAGE_SCHEMA,
@@ -82,20 +84,21 @@ CONFIG_SCHEMA = vol.Schema({
         vol.Optional(CONF_LEVEL): logger.is_log_level,
     }), validate_message_just_topic),
     vol.Optional(CONF_SSL_FINGERPRINTS): vol.All(cv.only_on_esp8266,
-                                                 cv.ensure_list, [validate_fingerprint]),
+                                                 cv.ensure_list(validate_fingerprint)),
     vol.Optional(CONF_KEEPALIVE): cv.positive_time_period_seconds,
     vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_ON_MESSAGE): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTMessageTrigger),
         vol.Required(CONF_TOPIC): cv.subscribe_topic,
-        vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
+        vol.Optional(CONF_QOS): cv.mqtt_qos,
+        vol.Optional(CONF_PAYLOAD): cv.string_strict,
     }),
     vol.Optional(CONF_ON_JSON_MESSAGE): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTJsonMessageTrigger),
         vol.Required(CONF_TOPIC): cv.subscribe_topic,
         vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
     }),
-})
+}), validate_config)
 
 
 def exp_mqtt_message(config):
@@ -116,12 +119,17 @@ def to_code(config):
                         config[CONF_USERNAME], config[CONF_PASSWORD])
     mqtt = Pvariable(config[CONF_ID], rhs)
 
-    if not config.get(CONF_DISCOVERY, True):
+    discovery = config.get(CONF_DISCOVERY, True)
+    discovery_retain = config.get(CONF_DISCOVERY_RETAIN, True)
+    discovery_prefix = config.get(CONF_DISCOVERY_PREFIX, 'homeassistant')
+
+    if not discovery:
         add(mqtt.disable_discovery())
+    elif discovery == "CLEAN":
+        add(mqtt.set_discovery_info(discovery_prefix, discovery_retain, True))
     elif CONF_DISCOVERY_RETAIN in config or CONF_DISCOVERY_PREFIX in config:
-        discovery_retain = config.get(CONF_DISCOVERY_RETAIN, True)
-        discovery_prefix = config.get(CONF_DISCOVERY_PREFIX, 'homeassistant')
         add(mqtt.set_discovery_info(discovery_prefix, discovery_retain))
+
     if CONF_TOPIC_PREFIX in config:
         add(mqtt.set_topic_prefix(config[CONF_TOPIC_PREFIX]))
 
@@ -154,13 +162,13 @@ def to_code(config):
         else:
             add(mqtt.set_log_message_template(exp_mqtt_message(log_topic)))
 
-            if CONF_LEVEL in config:
-                add(mqtt.set_log_level(logger.LOG_LEVELS[config[CONF_LEVEL]]))
+            if CONF_LEVEL in log_topic:
+                add(mqtt.set_log_level(logger.LOG_LEVELS[log_topic[CONF_LEVEL]]))
 
     if CONF_SSL_FINGERPRINTS in config:
         for fingerprint in config[CONF_SSL_FINGERPRINTS]:
             arr = [RawExpression("0x{}".format(fingerprint[i:i + 2])) for i in range(0, 40, 2)]
-            add(mqtt.add_ssl_fingerprint(ArrayInitializer(*arr, multiline=False)))
+            add(mqtt.add_ssl_fingerprint(arr))
 
     if CONF_KEEPALIVE in config:
         add(mqtt.set_keep_alive(config[CONF_KEEPALIVE]))
@@ -169,18 +177,23 @@ def to_code(config):
         add(mqtt.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
 
     for conf in config.get(CONF_ON_MESSAGE, []):
-        rhs = mqtt.make_message_trigger(conf[CONF_TOPIC], conf[CONF_QOS])
+        rhs = App.register_component(mqtt.make_message_trigger(conf[CONF_TOPIC]))
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, std_string, conf)
+        if CONF_QOS in conf:
+            add(trigger.set_qos(conf[CONF_QOS]))
+        if CONF_PAYLOAD in conf:
+            add(trigger.set_payload(conf[CONF_PAYLOAD]))
+        automation.build_automations(trigger, [(std_string, 'x')], conf)
 
     for conf in config.get(CONF_ON_JSON_MESSAGE, []):
         rhs = mqtt.make_json_message_trigger(conf[CONF_TOPIC], conf[CONF_QOS])
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, JsonObjectConstRef, conf)
+        automation.build_automations(trigger, [(JsonObjectConstRef, 'x')], conf)
 
 
 CONF_MQTT_PUBLISH = 'mqtt.publish'
-MQTT_PUBLISH_ACTION_SCHEMA = vol.Schema({
+MQTT_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(MQTTClientComponent),
     vol.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
     vol.Required(CONF_PAYLOAD): cv.templatable(cv.mqtt_payload),
     vol.Optional(CONF_QOS): cv.templatable(cv.mqtt_qos),
@@ -189,31 +202,33 @@ MQTT_PUBLISH_ACTION_SCHEMA = vol.Schema({
 
 
 @ACTION_REGISTRY.register(CONF_MQTT_PUBLISH, MQTT_PUBLISH_ACTION_SCHEMA)
-def mqtt_publish_action_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
-    rhs = App.Pget_mqtt_client().Pmake_publish_action(template_arg)
+def mqtt_publish_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_publish_action(template_arg)
     type = MQTTPublishAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
-    for template_ in templatable(config[CONF_TOPIC], arg_type, std_string):
+    for template_ in templatable(config[CONF_TOPIC], args, std_string):
         yield None
     add(action.set_topic(template_))
 
-    for template_ in templatable(config[CONF_PAYLOAD], arg_type, std_string):
+    for template_ in templatable(config[CONF_PAYLOAD], args, std_string):
         yield None
     add(action.set_payload(template_))
     if CONF_QOS in config:
-        for template_ in templatable(config[CONF_QOS], arg_type, uint8):
+        for template_ in templatable(config[CONF_QOS], args, uint8):
             yield
         add(action.set_qos(template_))
     if CONF_RETAIN in config:
-        for template_ in templatable(config[CONF_RETAIN], arg_type, bool_):
+        for template_ in templatable(config[CONF_RETAIN], args, bool_):
             yield None
         add(action.set_retain(template_))
     yield action
 
 
 CONF_MQTT_PUBLISH_JSON = 'mqtt.publish_json'
-MQTT_PUBLISH_JSON_ACTION_SCHEMA = vol.Schema({
+MQTT_PUBLISH_JSON_ACTION_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.use_variable_id(MQTTClientComponent),
     vol.Required(CONF_TOPIC): cv.templatable(cv.publish_topic),
     vol.Required(CONF_PAYLOAD): cv.lambda_,
     vol.Optional(CONF_QOS): cv.mqtt_qos,
@@ -222,16 +237,18 @@ MQTT_PUBLISH_JSON_ACTION_SCHEMA = vol.Schema({
 
 
 @ACTION_REGISTRY.register(CONF_MQTT_PUBLISH_JSON, MQTT_PUBLISH_JSON_ACTION_SCHEMA)
-def mqtt_publish_json_action_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
-    rhs = App.Pget_mqtt_client().Pmake_publish_json_action(template_arg)
+def mqtt_publish_json_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_publish_json_action(template_arg)
     type = MQTTPublishJsonAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
-    for template_ in templatable(config[CONF_TOPIC], arg_type, std_string):
+    for template_ in templatable(config[CONF_TOPIC], args, std_string):
         yield None
     add(action.set_topic(template_))
 
-    for lambda_ in process_lambda(config[CONF_PAYLOAD], [(arg_type, 'x'), (JsonObjectRef, 'root')]):
+    args_ = args + [(JsonObjectRef, 'root')]
+    for lambda_ in process_lambda(config[CONF_PAYLOAD], args_, return_type=void):
         yield None
     add(action.set_payload(lambda_))
     if CONF_QOS in config:
@@ -254,57 +271,33 @@ def get_default_topic_for(data, component_type, name, suffix):
                                 sanitized_name, suffix)
 
 
-def build_hass_config(data, component_type, config, include_state=True, include_command=True,
-                      platform='mqtt'):
-    if config.get(CONF_INTERNAL, False):
-        return None
-    ret = OrderedDict()
-    ret['platform'] = platform
-    ret['name'] = config[CONF_NAME]
-    if include_state:
-        default = get_default_topic_for(data, component_type, config[CONF_NAME], 'state')
-        ret['state_topic'] = config.get(CONF_STATE_TOPIC, default)
-    if include_command:
-        default = get_default_topic_for(data, component_type, config[CONF_NAME], 'command')
-        ret['command_topic'] = config.get(CONF_STATE_TOPIC, default)
-    avail = config.get(CONF_AVAILABILITY, data.availability)
-    if avail:
-        ret['availability_topic'] = avail[CONF_TOPIC]
-        payload_available = avail[CONF_PAYLOAD_AVAILABLE]
-        if payload_available != 'online':
-            ret['payload_available'] = payload_available
-        payload_not_available = avail[CONF_PAYLOAD_NOT_AVAILABLE]
-        if payload_not_available != 'offline':
-            ret['payload_not_available'] = payload_not_available
-    return ret
-
-
-class GenerateHassConfigData(object):
-    def __init__(self, config):
-        if 'mqtt' not in config:
-            raise ESPHomeYAMLError("Cannot generate Home Assistant MQTT config if MQTT is not "
-                                   "used!")
-        mqtt = config[CONF_MQTT]
-        self.topic_prefix = mqtt.get(CONF_TOPIC_PREFIX, config[CONF_ESPHOMEYAML][CONF_NAME])
-        birth_message = mqtt.get(CONF_BIRTH_MESSAGE)
-        if CONF_BIRTH_MESSAGE not in mqtt:
-            birth_message = {
-                CONF_TOPIC: self.topic_prefix + '/status',
-                CONF_PAYLOAD: 'online',
-            }
-        will_message = mqtt.get(CONF_WILL_MESSAGE)
-        if CONF_WILL_MESSAGE not in mqtt:
-            will_message = {
-                CONF_TOPIC: self.topic_prefix + '/status',
-                CONF_PAYLOAD: 'offline'
-            }
-        if not birth_message or not will_message:
-            self.availability = None
-        elif birth_message[CONF_TOPIC] != will_message[CONF_TOPIC]:
-            self.availability = None
+def setup_mqtt_component(obj, config):
+    if CONF_RETAIN in config:
+        add(obj.set_retain(config[CONF_RETAIN]))
+    if not config.get(CONF_DISCOVERY, True):
+        add(obj.disable_discovery())
+    if CONF_STATE_TOPIC in config:
+        add(obj.set_custom_state_topic(config[CONF_STATE_TOPIC]))
+    if CONF_COMMAND_TOPIC in config:
+        add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
+    if CONF_AVAILABILITY in config:
+        availability = config[CONF_AVAILABILITY]
+        if not availability:
+            add(obj.disable_availability())
         else:
-            self.availability = {
-                CONF_TOPIC: birth_message[CONF_TOPIC],
-                CONF_PAYLOAD_AVAILABLE: birth_message[CONF_PAYLOAD],
-                CONF_PAYLOAD_NOT_AVAILABLE: will_message[CONF_PAYLOAD],
-            }
+            add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
+                                     availability[CONF_PAYLOAD_NOT_AVAILABLE]))
+
+
+LIB_DEPS = 'AsyncMqttClient@0.8.2'
+BUILD_FLAGS = '-DUSE_MQTT'
+
+CONF_MQTT_CONNECTED = 'mqtt.connected'
+MQTT_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_MQTT_CONNECTED, MQTT_CONNECTED_CONDITION_SCHEMA)
+def mqtt_connected_to_code(config, condition_id, template_arg, args):
+    rhs = MQTTConnectedCondition.new(template_arg)
+    type = MQTTConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/my9231.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import (CONF_BIT_DEPTH, CONF_CLOCK_PIN, CONF_DATA_PIN, CONF_ID,
+                           CONF_NUM_CHANNELS, CONF_NUM_CHIPS, CONF_UPDATE_ON_BOOT)
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent', Component)
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(MY9231OutputComponent),
+    vol.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_NUM_CHANNELS): vol.All(vol.Coerce(int),
+                                             vol.Range(3, 1020)),
+    vol.Optional(CONF_NUM_CHIPS): vol.All(vol.Coerce(int),
+                                          vol.Range(1, 255)),
+    vol.Optional(CONF_BIT_DEPTH): cv.one_of(8, 12, 14, 16, int=True),
+    vol.Optional(CONF_UPDATE_ON_BOOT): vol.Coerce(bool),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for di in gpio_output_pin_expression(config[CONF_DATA_PIN]):
+        yield
+    for dcki in gpio_output_pin_expression(config[CONF_CLOCK_PIN]):
+        yield
+    rhs = App.make_my9231_component(di, dcki)
+    my9231 = Pvariable(config[CONF_ID], rhs)
+    if CONF_NUM_CHANNELS in config:
+        add(my9231.set_num_channels(config[CONF_NUM_CHANNELS]))
+    if CONF_NUM_CHIPS in config:
+        add(my9231.set_num_chips(config[CONF_NUM_CHIPS]))
+    if CONF_BIT_DEPTH in config:
+        add(my9231.set_bit_depth(config[CONF_BIT_DEPTH]))
+    if CONF_UPDATE_ON_BOOT in config:
+        add(my9231.set_update(config[CONF_UPDATE_ON_BOOT]))
+    setup_component(my9231, config)
+
+
+BUILD_FLAGS = '-DUSE_MY9231_OUTPUT'

esphome/components/ota.py

@@ -2,18 +2,17 @@ import logging
 
 import voluptuous as vol
 
-from esphomeyaml import core
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE, \
-    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, Component
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_OTA, CONF_PASSWORD, CONF_PORT, CONF_SAFE_MODE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Component, esphome_ns
 
 _LOGGER = logging.getLogger(__name__)
 
-OTAComponent = esphomelib_ns.class_('OTAComponent', Component)
+OTAComponent = esphome_ns.class_('OTAComponent', Component)
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(OTAComponent),
     vol.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
     vol.Optional(CONF_PORT): cv.port,
@@ -35,11 +34,11 @@ def to_code(config):
 def get_port(config):
     if CONF_PORT in config[CONF_OTA]:
         return config[CONF_OTA][CONF_PORT]
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if CORE.is_esp32:
         return 3232
-    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    if CORE.is_esp8266:
         return 8266
-    raise ESPHomeYAMLError(u"Invalid ESP Platform for ESP OTA port.")
+    raise NotImplementedError
 
 
 def get_auth(config):
@@ -51,6 +50,8 @@ REQUIRED_BUILD_FLAGS = '-DUSE_NEW_OTA'
 
 
 def lib_deps(config):
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
-        return ['ArduinoOTA', 'Update', 'ESPmDNS']
-    return ['Hash', 'ESP8266mDNS', 'ArduinoOTA']
+    if CORE.is_esp32:
+        return ['Update']
+    if CORE.is_esp8266:
+        return ['Hash']
+    raise NotImplementedError

esphome/components/output/__init__.py

@@ -1,17 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components.power_supply import PowerSupplyComponent
-from esphomeyaml.const import CONF_INVERTED, CONF_MAX_POWER, CONF_POWER_SUPPLY, CONF_ID, CONF_LEVEL
-from esphomeyaml.helpers import add, esphomelib_ns, get_variable, TemplateArguments, Pvariable, \
-    templatable, float_, add_job, Action
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+from esphome.components.power_supply import PowerSupplyComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_LEVEL, CONF_MAX_POWER, \
+    CONF_MIN_POWER, CONF_POWER_SUPPLY
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, esphome_ns, float_
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-BINARY_OUTPUT_SCHEMA = vol.Schema({
+BINARY_OUTPUT_SCHEMA = cv.Schema({
     vol.Optional(CONF_POWER_SUPPLY): cv.use_variable_id(PowerSupplyComponent),
     vol.Optional(CONF_INVERTED): cv.boolean,
 })
@@ -20,13 +22,16 @@ BINARY_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(BINARY_OUTPUT_SCHEMA.sche
 
 FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend({
     vol.Optional(CONF_MAX_POWER): cv.percentage,
+    vol.Optional(CONF_MIN_POWER): cv.percentage,
 })
 
 FLOAT_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FLOAT_OUTPUT_SCHEMA.schema)
 
-output_ns = esphomelib_ns.namespace('output')
+output_ns = esphome_ns.namespace('output')
 BinaryOutput = output_ns.class_('BinaryOutput')
+BinaryOutputPtr = BinaryOutput.operator('ptr')
 FloatOutput = output_ns.class_('FloatOutput', BinaryOutput)
+FloatOutputPtr = FloatOutput.operator('ptr')
 
 # Actions
 TurnOffAction = output_ns.class_('TurnOffAction', Action)
@@ -44,15 +49,21 @@ def setup_output_platform_(obj, config, skip_power_supply=False):
         add(obj.set_power_supply(power_supply))
     if CONF_MAX_POWER in config:
         add(obj.set_max_power(config[CONF_MAX_POWER]))
+    if CONF_MIN_POWER in config:
+        add(obj.set_min_power(config[CONF_MIN_POWER]))
 
 
 def setup_output_platform(obj, config, skip_power_supply=False):
-    add_job(setup_output_platform_, obj, config, skip_power_supply)
+    CORE.add_job(setup_output_platform_, obj, config, skip_power_supply)
+
+
+def register_output(var, config):
+    output_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    CORE.add_job(setup_output_platform_, output_var, config)
 
 
 BUILD_FLAGS = '-DUSE_OUTPUT'
 
-
 CONF_OUTPUT_TURN_ON = 'output.turn_on'
 OUTPUT_TURN_ON_ACTION = maybe_simple_id({
     vol.Required(CONF_ID): cv.use_variable_id(BinaryOutput),
@@ -60,12 +71,11 @@ OUTPUT_TURN_ON_ACTION = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_OUTPUT_TURN_ON, OUTPUT_TURN_ON_ACTION)
-def output_turn_on_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def output_turn_on_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_on_action(template_arg)
-    type = TurnOnAction.template(arg_type)
+    type = TurnOnAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
@@ -76,31 +86,29 @@ OUTPUT_TURN_OFF_ACTION = maybe_simple_id({
 
 
 @ACTION_REGISTRY.register(CONF_OUTPUT_TURN_OFF, OUTPUT_TURN_OFF_ACTION)
-def output_turn_off_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def output_turn_off_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_off_action(template_arg)
-    type = TurnOffAction.template(arg_type)
+    type = TurnOffAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
 
 CONF_OUTPUT_SET_LEVEL = 'output.set_level'
-OUTPUT_SET_LEVEL_ACTION = vol.Schema({
+OUTPUT_SET_LEVEL_ACTION = cv.Schema({
     vol.Required(CONF_ID): cv.use_variable_id(FloatOutput),
     vol.Required(CONF_LEVEL): cv.templatable(cv.percentage),
 })
 
 
 @ACTION_REGISTRY.register(CONF_OUTPUT_SET_LEVEL, OUTPUT_SET_LEVEL_ACTION)
-def output_set_level_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def output_set_level_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_set_level_action(template_arg)
-    type = SetLevelAction.template(arg_type)
+    type = SetLevelAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
-    for template_ in templatable(config[CONF_LEVEL], arg_type, float_):
+    for template_ in templatable(config[CONF_LEVEL], args, float_):
         yield None
     add(action.set_level(template_))
     yield action

esphome/components/output/copy.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_OUTPUTS, CONF_TYPE
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+
+BinaryCopyOutput = output.output_ns.class_('BinaryCopyOutput', output.BinaryOutput)
+FloatCopyOutput = output.output_ns.class_('FloatCopyOutput', output.FloatOutput)
+
+BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(BinaryCopyOutput),
+    vol.Required(CONF_TYPE): 'binary',
+    vol.Required(CONF_OUTPUTS): cv.ensure_list(cv.use_variable_id(output.BinaryOutput)),
+})
+
+FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(FloatCopyOutput),
+    vol.Required(CONF_TYPE): 'float',
+    vol.Required(CONF_OUTPUTS): cv.ensure_list(cv.use_variable_id(output.FloatOutput)),
+})
+
+
+def validate_copy_output(value):
+    if not isinstance(value, dict):
+        raise vol.Invalid("Value must be dict")
+    type = cv.string_strict(value.get(CONF_TYPE, 'float')).lower()
+    value[CONF_TYPE] = type
+    if type == 'binary':
+        return BINARY_SCHEMA(value)
+    if type == 'float':
+        return FLOAT_SCHEMA(value)
+    raise vol.Invalid("type must either be binary or float, not {}!".format(type))
+
+
+PLATFORM_SCHEMA = validate_copy_output
+
+
+def to_code(config):
+    outputs = []
+    for out in config[CONF_OUTPUTS]:
+        for var in get_variable(out):
+            yield
+        outputs.append(var)
+
+    klass = {
+        'binary': BinaryCopyOutput,
+        'float': FloatCopyOutput,
+    }[config[CONF_TYPE]]
+    rhs = klass.new(outputs)
+    gpio = Pvariable(config[CONF_ID], rhs)
+
+    output.setup_output_platform(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_COPY_OUTPUT'

esphome/components/output/custom.py

@@ -0,0 +1,68 @@
+import voluptuous as vol
+
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_OUTPUTS, CONF_TYPE
+from esphome.cpp_generator import process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomBinaryOutputConstructor = output.output_ns.class_('CustomBinaryOutputConstructor')
+CustomFloatOutputConstructor = output.output_ns.class_('CustomFloatOutputConstructor')
+
+BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomBinaryOutputConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TYPE): 'binary',
+    vol.Required(CONF_OUTPUTS):
+        cv.ensure_list(output.BINARY_OUTPUT_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(output.BinaryOutput),
+        })),
+})
+
+FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomFloatOutputConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TYPE): 'float',
+    vol.Required(CONF_OUTPUTS):
+        cv.ensure_list(output.FLOAT_OUTPUT_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(output.FloatOutput),
+        })),
+})
+
+
+def validate_custom_output(value):
+    if not isinstance(value, dict):
+        raise vol.Invalid("Value must be dict")
+    if CONF_TYPE not in value:
+        raise vol.Invalid("type not specified!")
+    type = cv.string_strict(value[CONF_TYPE]).lower()
+    value[CONF_TYPE] = type
+    if type == 'binary':
+        return BINARY_SCHEMA(value)
+    if type == 'float':
+        return FLOAT_SCHEMA(value)
+    raise vol.Invalid("type must either be binary or float, not {}!".format(type))
+
+
+PLATFORM_SCHEMA = validate_custom_output
+
+
+def to_code(config):
+    type = config[CONF_TYPE]
+    if type == 'binary':
+        ret_type = output.BinaryOutputPtr
+        klass = CustomBinaryOutputConstructor
+    else:
+        ret_type = output.FloatOutputPtr
+        klass = CustomFloatOutputConstructor
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(ret_type)):
+        yield
+
+    rhs = klass(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_OUTPUTS]):
+        output.register_output(custom.get_output(i), conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_OUTPUT'

esphome/components/output/esp8266_pwm.py

@@ -1,18 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components import output
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_PIN, ESP_PLATFORM_ESP8266, CONF_FREQUENCY
-from esphomeyaml.helpers import App, Component, Pvariable, gpio_output_pin_expression, \
-    setup_component, add
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NUMBER, CONF_PIN, ESP_PLATFORM_ESP8266
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
 
 def valid_pwm_pin(value):
     num = value[CONF_NUMBER]
-    cv.one_of(0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16)(num)
+    cv.one_of(0, 1, 2, 3, 4, 5, 9, 10, 12, 13, 14, 15, 16)(num)
     return value
 
 

esphome/components/output/gpio.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import output
-from esphomeyaml.const import CONF_ID, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression, setup_component, \
-    Component
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
 
 GPIOBinaryOutputComponent = output.output_ns.class_('GPIOBinaryOutputComponent',
                                                     output.BinaryOutput, Component)

esphome/components/output/ledc.py

@@ -1,11 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import output
-from esphomeyaml.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
+from esphome import pins
+from esphome.components import output
+import esphome.config_validation as cv
+from esphome.const import APB_CLOCK_FREQ, CONF_BIT_DEPTH, CONF_CHANNEL, CONF_FREQUENCY, \
     CONF_ID, CONF_PIN, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Pvariable, add, setup_component, Component
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 

esphome/components/output/my9231.py

@@ -1,10 +1,11 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import output
-from esphomeyaml.components.my9231 import MY9231OutputComponent
-from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_MY9231_ID, CONF_POWER_SUPPLY
-from esphomeyaml.helpers import Pvariable, get_variable, setup_component
+from esphome.components import output
+from esphome.components.my9231 import MY9231OutputComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ID, CONF_MY9231_ID, CONF_POWER_SUPPLY
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
 
 DEPENDENCIES = ['my9231']
 

esphome/components/output/pca9685.py

@@ -1,10 +1,10 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import output
-from esphomeyaml.components.pca9685 import PCA9685OutputComponent
-from esphomeyaml.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
-from esphomeyaml.helpers import Pvariable, get_variable
+from esphome.components import output
+from esphome.components.pca9685 import PCA9685OutputComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CHANNEL, CONF_ID, CONF_PCA9685_ID, CONF_POWER_SUPPLY
+from esphome.cpp_generator import Pvariable, get_variable
 
 DEPENDENCIES = ['pca9685']
 

esphome/components/pca9685.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import i2c, output
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_FREQUENCY, CONF_ID
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['i2c']
+MULTI_CONF = True
+
+PCA9685OutputComponent = output.output_ns.class_('PCA9685OutputComponent',
+                                                 Component, i2c.I2CDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(PCA9685OutputComponent),
+    vol.Required(CONF_FREQUENCY): vol.All(cv.frequency,
+                                          vol.Range(min=23.84, max=1525.88)),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pca9685_component(config.get(CONF_FREQUENCY))
+    pca9685 = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(pca9685.set_address(config[CONF_ADDRESS]))
+    setup_component(pca9685, config)
+
+
+BUILD_FLAGS = '-DUSE_PCA9685_OUTPUT'

esphome/components/pcf8574.py

@@ -1,11 +1,14 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_PCF8575
-from esphomeyaml.helpers import App, GPIOInputPin, GPIOOutputPin, Pvariable, io_ns, setup_component
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_PCF8575
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, GPIOInputPin, GPIOOutputPin, io_ns
 
 DEPENDENCIES = ['i2c']
+MULTI_CONF = True
 
 PCF8574GPIOMode = io_ns.enum('PCF8574GPIOMode')
 PCF8675_GPIO_MODES = {
@@ -17,20 +20,17 @@ PCF8675_GPIO_MODES = {
 PCF8574GPIOInputPin = io_ns.class_('PCF8574GPIOInputPin', GPIOInputPin)
 PCF8574GPIOOutputPin = io_ns.class_('PCF8574GPIOOutputPin', GPIOOutputPin)
 
-PCF8574_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     vol.Required(CONF_ID): cv.declare_variable_id(pins.PCF8574Component),
     vol.Optional(CONF_ADDRESS, default=0x21): cv.i2c_address,
     vol.Optional(CONF_PCF8575, default=False): cv.boolean,
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
-CONFIG_SCHEMA = vol.All(cv.ensure_list, [PCF8574_SCHEMA])
-
 
 def to_code(config):
-    for conf in config:
-        rhs = App.make_pcf8574_component(conf[CONF_ADDRESS], conf[CONF_PCF8575])
-        var = Pvariable(conf[CONF_ID], rhs)
-        setup_component(var, conf)
+    rhs = App.make_pcf8574_component(config[CONF_ADDRESS], config[CONF_PCF8575])
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
 
 
 BUILD_FLAGS = '-DUSE_PCF8574'

esphome/components/pn532.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome import automation, pins
+from esphome.components import binary_sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_ON_TAG, CONF_SPI_ID, CONF_TRIGGER_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent, Trigger, std_string
+
+DEPENDENCIES = ['spi']
+MULTI_CONF = True
+
+PN532Component = binary_sensor.binary_sensor_ns.class_('PN532Component', PollingComponent,
+                                                       spi.SPIDevice)
+PN532Trigger = binary_sensor.binary_sensor_ns.class_('PN532Trigger', Trigger.template(std_string))
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(PN532Component),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_ON_TAG): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PN532Trigger),
+    }),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_pn532_component(spi_, cs, config.get(CONF_UPDATE_INTERVAL))
+    pn532 = Pvariable(config[CONF_ID], rhs)
+
+    for conf_ in config.get(CONF_ON_TAG, []):
+        trigger = Pvariable(conf_[CONF_TRIGGER_ID], pn532.make_trigger())
+        automation.build_automations(trigger, [(std_string, 'x')], conf_)
+
+    setup_component(pn532, config)
+
+
+BUILD_FLAGS = '-DUSE_PN532'

esphome/components/power_supply.py

@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+PowerSupplyComponent = esphome_ns.class_('PowerSupplyComponent', Component)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(PowerSupplyComponent),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period_milliseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+
+    rhs = App.make_power_supply(pin)
+    psu = Pvariable(config[CONF_ID], rhs)
+    if CONF_ENABLE_TIME in config:
+        add(psu.set_enable_time(config[CONF_ENABLE_TIME]))
+    if CONF_KEEP_ON_TIME in config:
+        add(psu.set_keep_on_time(config[CONF_KEEP_ON_TIME]))
+
+    setup_component(psu, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT'

esphome/components/rdm6300.py

@@ -0,0 +1,27 @@
+from esphome.components import binary_sensor, uart
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+RDM6300Component = binary_sensor.binary_sensor_ns.class_('RDM6300Component', Component,
+                                                         uart.UARTDevice)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RDM6300Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(uart.UARTComponent),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    rhs = App.make_rdm6300_component(uart_)
+    var = Pvariable(config[CONF_ID], rhs)
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_RDM6300'

esphome/components/remote_receiver.py

@@ -0,0 +1,76 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_BUFFER_SIZE, CONF_DUMP, CONF_FILTER, CONF_ID, CONF_IDLE, \
+    CONF_PIN, CONF_TOLERANCE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+from esphome.py_compat import string_types
+
+remote_ns = esphome_ns.namespace('remote')
+MULTI_CONF = True
+
+RemoteControlComponentBase = remote_ns.class_('RemoteControlComponentBase')
+RemoteReceiverComponent = remote_ns.class_('RemoteReceiverComponent',
+                                           RemoteControlComponentBase,
+                                           Component)
+
+RemoteReceiveDumper = remote_ns.class_('RemoteReceiveDumper')
+
+DUMPERS = {
+    'jvc': remote_ns.class_('JVCDumper', RemoteReceiveDumper),
+    'lg': remote_ns.class_('LGDumper', RemoteReceiveDumper),
+    'nec': remote_ns.class_('NECDumper', RemoteReceiveDumper),
+    'panasonic': remote_ns.class_('PanasonicDumper', RemoteReceiveDumper),
+    'raw': remote_ns.class_('RawDumper', RemoteReceiveDumper),
+    'samsung': remote_ns.class_('SamsungDumper', RemoteReceiveDumper),
+    'sony': remote_ns.class_('SonyDumper', RemoteReceiveDumper),
+    'rc_switch': remote_ns.class_('RCSwitchDumper', RemoteReceiveDumper),
+    'rc5': remote_ns.class_('RC5Dumper', RemoteReceiveDumper),
+}
+
+
+def validate_dumpers_all(value):
+    if not isinstance(value, string_types):
+        raise vol.Invalid("Not valid dumpers")
+    if value.upper() == "ALL":
+        return list(sorted(list(DUMPERS)))
+    raise vol.Invalid("Not valid dumpers")
+
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(RemoteReceiverComponent),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_input_pin_schema,
+                                    pins.validate_has_interrupt),
+    vol.Optional(CONF_DUMP, default=[]):
+        vol.Any(validate_dumpers_all, cv.ensure_list(cv.one_of(*DUMPERS, lower=True))),
+    vol.Optional(CONF_TOLERANCE): vol.All(cv.percentage_int, vol.Range(min=0)),
+    vol.Optional(CONF_BUFFER_SIZE): cv.validate_bytes,
+    vol.Optional(CONF_FILTER): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_IDLE): cv.positive_time_period_microseconds,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_remote_receiver_component(pin)
+    receiver = Pvariable(config[CONF_ID], rhs)
+
+    for dumper in config[CONF_DUMP]:
+        add(receiver.add_dumper(DUMPERS[dumper].new()))
+    if CONF_TOLERANCE in config:
+        add(receiver.set_tolerance(config[CONF_TOLERANCE]))
+    if CONF_BUFFER_SIZE in config:
+        add(receiver.set_buffer_size(config[CONF_BUFFER_SIZE]))
+    if CONF_FILTER in config:
+        add(receiver.set_filter_us(config[CONF_FILTER]))
+    if CONF_IDLE in config:
+        add(receiver.set_idle_us(config[CONF_IDLE]))
+
+    setup_component(receiver, config)
+
+
+BUILD_FLAGS = '-DUSE_REMOTE_RECEIVER'

esphome/components/remote_transmitter.py

@@ -1,23 +1,27 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components.remote_receiver import RemoteControlComponentBase, remote_ns
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_CARRIER_DUTY_PERCENT, CONF_CHANNEL, CONF_CODE, \
+from esphome import pins
+from esphome.components.remote_receiver import RemoteControlComponentBase, remote_ns
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CARRIER_DUTY_PERCENT, CONF_CHANNEL, CONF_CODE, \
     CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_INVERTED, CONF_ONE, CONF_PIN, \
     CONF_PROTOCOL, CONF_PULSE_LENGTH, CONF_STATE, CONF_SYNC, CONF_ZERO
-from esphomeyaml.core import HexInt
-from esphomeyaml.helpers import App, Component, Pvariable, add, gpio_output_pin_expression, \
-    setup_component
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+from esphome.py_compat import text_type
 
 RemoteTransmitterComponent = remote_ns.class_('RemoteTransmitterComponent',
                                               RemoteControlComponentBase, Component)
 RCSwitchProtocol = remote_ns.class_('RCSwitchProtocol')
 rc_switch_protocols = remote_ns.rc_switch_protocols
 
+MULTI_CONF = True
+
 
 def validate_rc_switch_code(value):
-    if not isinstance(value, (str, unicode)):
+    if not isinstance(value, (str, text_type)):
         raise vol.Invalid("All RCSwitch codes must be in quotes ('')")
     for c in value:
         if c not in ('0', '1'):
@@ -35,7 +39,7 @@ RC_SWITCH_TIMING_SCHEMA = vol.All([cv.uint8_t], vol.Length(min=2, max=2))
 
 RC_SWITCH_PROTOCOL_SCHEMA = vol.Any(
     vol.All(vol.Coerce(int), vol.Range(min=1, max=7)),
-    vol.Schema({
+    cv.Schema({
         vol.Required(CONF_PULSE_LENGTH): cv.uint32_t,
         vol.Optional(CONF_SYNC, default=[1, 31]): RC_SWITCH_TIMING_SCHEMA,
         vol.Optional(CONF_ZERO, default=[1, 3]): RC_SWITCH_TIMING_SCHEMA,
@@ -44,45 +48,43 @@ RC_SWITCH_PROTOCOL_SCHEMA = vol.Any(
     })
 )
 
-RC_SWITCH_RAW_SCHEMA = vol.Schema({
+RC_SWITCH_RAW_SCHEMA = cv.Schema({
     vol.Required(CONF_CODE): validate_rc_switch_code,
     vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
 })
-RC_SWITCH_TYPE_A_SCHEMA = vol.Schema({
+RC_SWITCH_TYPE_A_SCHEMA = cv.Schema({
     vol.Required(CONF_GROUP): vol.All(validate_rc_switch_code, vol.Length(min=5, max=5)),
     vol.Required(CONF_DEVICE): vol.All(validate_rc_switch_code, vol.Length(min=5, max=5)),
     vol.Required(CONF_STATE): cv.boolean,
     vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
 })
-RC_SWITCH_TYPE_B_SCHEMA = vol.Schema({
+RC_SWITCH_TYPE_B_SCHEMA = cv.Schema({
     vol.Required(CONF_ADDRESS): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
     vol.Required(CONF_CHANNEL): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
     vol.Required(CONF_STATE): cv.boolean,
     vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
 })
-RC_SWITCH_TYPE_C_SCHEMA = vol.Schema({
-    vol.Required(CONF_FAMILY): vol.All(
-        cv.string, vol.Lower,
-        cv.one_of('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-                  'p')),
+RC_SWITCH_TYPE_C_SCHEMA = cv.Schema({
+    vol.Required(CONF_FAMILY): cv.one_of('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+                                         'l', 'm', 'n', 'o', 'p', lower=True),
     vol.Required(CONF_GROUP): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
     vol.Required(CONF_DEVICE): vol.All(cv.uint8_t, vol.Range(min=1, max=4)),
     vol.Required(CONF_STATE): cv.boolean,
     vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
 })
-RC_SWITCH_TYPE_D_SCHEMA = vol.Schema({
-    vol.Required(CONF_GROUP): vol.All(cv.string, vol.Lower, cv.one_of('a', 'b', 'c', 'd')),
+RC_SWITCH_TYPE_D_SCHEMA = cv.Schema({
+    vol.Required(CONF_GROUP): cv.one_of('a', 'b', 'c', 'd', lower=True),
     vol.Required(CONF_DEVICE): vol.All(cv.uint8_t, vol.Range(min=1, max=3)),
     vol.Required(CONF_STATE): cv.boolean,
     vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA,
 })
 
-CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(RemoteTransmitterComponent),
     vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(cv.percentage_int,
                                                      vol.Range(min=1, max=100)),
-}).extend(cv.COMPONENT_SCHEMA.schema)])
+}).extend(cv.COMPONENT_SCHEMA.schema)
 
 
 def build_rc_switch_protocol(config):
@@ -104,16 +106,15 @@ def binary_code(value):
 
 
 def to_code(config):
-    for conf in config:
-        for pin in gpio_output_pin_expression(conf[CONF_PIN]):
-            yield
-        rhs = App.make_remote_transmitter_component(pin)
-        transmitter = Pvariable(conf[CONF_ID], rhs)
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_remote_transmitter_component(pin)
+    transmitter = Pvariable(config[CONF_ID], rhs)
 
-        if CONF_CARRIER_DUTY_PERCENT in conf:
-            add(transmitter.set_carrier_duty_percent(conf[CONF_CARRIER_DUTY_PERCENT]))
+    if CONF_CARRIER_DUTY_PERCENT in config:
+        add(transmitter.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))
 
-        setup_component(transmitter, conf)
+    setup_component(transmitter, config)
 
 
 BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'

esphome/components/script.py

@@ -0,0 +1,52 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, maybe_simple_id
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_types import Action, Trigger, esphome_ns
+
+Script = esphome_ns.class_('Script', Trigger.template())
+ScriptExecuteAction = esphome_ns.class_('ScriptExecuteAction', Action)
+ScriptStopAction = esphome_ns.class_('ScriptStopAction', Action)
+
+CONFIG_SCHEMA = automation.validate_automation({
+    vol.Required(CONF_ID): cv.declare_variable_id(Script),
+})
+
+
+def to_code(config):
+    for conf in config:
+        trigger = Pvariable(conf[CONF_ID], Script.new())
+        automation.build_automations(trigger, [], conf)
+
+
+CONF_SCRIPT_EXECUTE = 'script.execute'
+SCRIPT_EXECUTE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Script),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SCRIPT_EXECUTE, SCRIPT_EXECUTE_ACTION_SCHEMA)
+def script_execute_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_execute_action(template_arg)
+    type = ScriptExecuteAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SCRIPT_STOP = 'script.stop'
+SCRIPT_STOP_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Script),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SCRIPT_STOP, SCRIPT_STOP_ACTION_SCHEMA)
+def script_stop_action_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_stop_action(template_arg)
+    type = ScriptStopAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)

esphome/components/sensor/__init__.py

@@ -1,18 +1,24 @@
+import math
+
 import voluptuous as vol
 
-from esphomeyaml import automation
-from esphomeyaml.components import mqtt
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
-    CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, \
-    CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_INTERNAL, \
-    CONF_LAMBDA, CONF_MQTT_ID, CONF_MULTIPLY, CONF_OFFSET, CONF_ON_RAW_VALUE, CONF_ON_VALUE, \
-    CONF_ON_VALUE_RANGE, CONF_OR, CONF_SEND_EVERY, CONF_SEND_FIRST_AT, \
-    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_THROTTLE, CONF_TRIGGER_ID, CONF_UNIQUE, \
-    CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
-from esphomeyaml.helpers import App, ArrayInitializer, Component, Nameable, PollingComponent, \
-    Pvariable, Trigger, add, add_job, esphomelib_ns, float_, process_lambda, setup_mqtt_component, \
-    templatable
+from esphome import automation
+from esphome.automation import CONDITION_REGISTRY
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_CALIBRATE_LINEAR, CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, \
+    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_OUT, CONF_FROM, \
+    CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_LAMBDA, CONF_MQTT_ID, \
+    CONF_MULTIPLY, CONF_OFFSET, CONF_ON_RAW_VALUE, CONF_ON_VALUE, CONF_ON_VALUE_RANGE, CONF_OR, \
+    CONF_SEND_EVERY, CONF_SEND_FIRST_AT, CONF_SLIDING_WINDOW_MOVING_AVERAGE, \
+    CONF_THROTTLE, CONF_TO, CONF_TRIGGER_ID, CONF_UNIQUE, CONF_UNIT_OF_MEASUREMENT, \
+    CONF_WINDOW_SIZE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_types import App, Component, Nameable, PollingComponent, Trigger, \
+    esphome_ns, float_, optional
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
@@ -32,36 +38,60 @@ def validate_send_first_at(value):
     return value
 
 
-FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT, CONF_FILTER_NAN,
+FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT,
                CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
-               CONF_THROTTLE, CONF_DELTA, CONF_UNIQUE, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR]
+               CONF_THROTTLE, CONF_DELTA, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR,
+               CONF_CALIBRATE_LINEAR]
 
-FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
-    vol.Optional(CONF_OFFSET): vol.Coerce(float),
-    vol.Optional(CONF_MULTIPLY): vol.Coerce(float),
-    vol.Optional(CONF_FILTER_OUT): vol.Coerce(float),
-    vol.Optional(CONF_FILTER_NAN): None,
-    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.All(vol.Schema({
-        vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
-        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+
+def validate_datapoint(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            vol.Required(CONF_FROM): cv.float_,
+            vol.Required(CONF_TO): cv.float_,
+        })(value)
+    value = cv.string(value)
+    if '->' not in value:
+        raise vol.Invalid("Datapoint mapping must contain '->'")
+    a, b = value.split('->', 1)
+    a, b = a.strip(), b.strip()
+    return validate_datapoint({
+        CONF_FROM: cv.float_(a),
+        CONF_TO: cv.float_(b)
+    })
+
+
+FILTERS_SCHEMA = cv.ensure_list({
+    vol.Optional(CONF_OFFSET): cv.float_,
+    vol.Optional(CONF_MULTIPLY): cv.float_,
+    vol.Optional(CONF_FILTER_OUT): cv.float_,
+    vol.Optional('filter_nan'): cv.invalid("The filter_nan filter has been removed. Please use "
+                                           "'filter_out: nan' instead"),
+    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.All(cv.Schema({
+        vol.Optional(CONF_WINDOW_SIZE, default=15): cv.positive_not_null_int,
+        vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
         vol.Optional(CONF_SEND_FIRST_AT): cv.positive_not_null_int,
     }), validate_send_first_at),
-    vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
-        vol.Required(CONF_ALPHA): cv.positive_float,
-        vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+    vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): cv.Schema({
+        vol.Optional(CONF_ALPHA, default=0.1): cv.positive_float,
+        vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
     }),
+    vol.Optional(CONF_CALIBRATE_LINEAR): vol.All(
+        cv.ensure_list(validate_datapoint), vol.Length(min=2)),
     vol.Optional(CONF_LAMBDA): cv.lambda_,
     vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
-    vol.Optional(CONF_DELTA): vol.Coerce(float),
-    vol.Optional(CONF_UNIQUE): None,
+    vol.Optional(CONF_DELTA): cv.float_,
+    vol.Optional(CONF_UNIQUE): cv.invalid("The unique filter has been removed in 1.12, please "
+                                          "replace with a delta filter with small value."),
     vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_DEBOUNCE): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_OR): validate_recursive_filter,
-}, cv.has_exactly_one_key(*FILTER_KEYS))])
+}, cv.has_exactly_one_key(*FILTER_KEYS))
 
 # Base
-sensor_ns = esphomelib_ns.namespace('sensor')
+sensor_ns = esphome_ns.namespace('sensor')
 Sensor = sensor_ns.class_('Sensor', Nameable)
+SensorPtr = Sensor.operator('ptr')
 MQTTSensorComponent = sensor_ns.class_('MQTTSensorComponent', mqtt.MQTTComponent)
 
 PollingSensorComponent = sensor_ns.class_('PollingSensorComponent', PollingComponent, Sensor)
@@ -71,7 +101,7 @@ EmptyPollingParentSensor = sensor_ns.class_('EmptyPollingParentSensor', EmptySen
 # Triggers
 SensorStateTrigger = sensor_ns.class_('SensorStateTrigger', Trigger.template(float_))
 SensorRawStateTrigger = sensor_ns.class_('SensorRawStateTrigger', Trigger.template(float_))
-ValueRangeTrigger = sensor_ns.class_('ValueRangeTrigger', Trigger.template(float_))
+ValueRangeTrigger = sensor_ns.class_('ValueRangeTrigger', Trigger.template(float_), Component)
 
 # Filters
 Filter = sensor_ns.class_('Filter')
@@ -81,20 +111,21 @@ LambdaFilter = sensor_ns.class_('LambdaFilter', Filter)
 OffsetFilter = sensor_ns.class_('OffsetFilter', Filter)
 MultiplyFilter = sensor_ns.class_('MultiplyFilter', Filter)
 FilterOutValueFilter = sensor_ns.class_('FilterOutValueFilter', Filter)
-FilterOutNANFilter = sensor_ns.class_('FilterOutNANFilter', Filter)
 ThrottleFilter = sensor_ns.class_('ThrottleFilter', Filter)
 DebounceFilter = sensor_ns.class_('DebounceFilter', Filter, Component)
 HeartbeatFilter = sensor_ns.class_('HeartbeatFilter', Filter, Component)
 DeltaFilter = sensor_ns.class_('DeltaFilter', Filter)
 OrFilter = sensor_ns.class_('OrFilter', Filter)
-UniqueFilter = sensor_ns.class_('UniqueFilter', Filter)
+CalibrateLinearFilter = sensor_ns.class_('CalibrateLinearFilter', Filter)
+SensorInRangeCondition = sensor_ns.class_('SensorInRangeCondition', Filter)
 
 SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
     cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSensorComponent),
     vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string_strict,
     vol.Optional(CONF_ICON): cv.icon,
     vol.Optional(CONF_ACCURACY_DECIMALS): vol.Coerce(int),
-    vol.Optional(CONF_EXPIRE_AFTER): vol.Any(None, cv.positive_time_period_milliseconds),
+    vol.Optional(CONF_EXPIRE_AFTER): vol.All(cv.requires_component('mqtt'),
+                                             vol.Any(None, cv.positive_time_period_milliseconds)),
     vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
     vol.Optional(CONF_ON_VALUE): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SensorStateTrigger),
@@ -104,8 +135,8 @@ SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
     }),
     vol.Optional(CONF_ON_VALUE_RANGE): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ValueRangeTrigger),
-        vol.Optional(CONF_ABOVE): vol.Coerce(float),
-        vol.Optional(CONF_BELOW): vol.Coerce(float),
+        vol.Optional(CONF_ABOVE): cv.float_,
+        vol.Optional(CONF_BELOW): cv.float_,
     }, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
 })
 
@@ -119,8 +150,6 @@ def setup_filter(config):
         yield MultiplyFilter.new(config[CONF_MULTIPLY])
     elif CONF_FILTER_OUT in config:
         yield FilterOutValueFilter.new(config[CONF_FILTER_OUT])
-    elif CONF_FILTER_NAN in config:
-        yield FilterOutNANFilter.new()
     elif CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
         conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
         yield SlidingWindowMovingAverageFilter.new(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY],
@@ -129,8 +158,8 @@ def setup_filter(config):
         conf = config[CONF_EXPONENTIAL_MOVING_AVERAGE]
         yield ExponentialMovingAverageFilter.new(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
     elif CONF_LAMBDA in config:
-        lambda_ = None
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(float_, 'x')]):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(float_, 'x')],
+                                      return_type=optional.template(float_)):
             yield None
         yield LambdaFilter.new(lambda_)
     elif CONF_THROTTLE in config:
@@ -138,7 +167,6 @@ def setup_filter(config):
     elif CONF_DELTA in config:
         yield DeltaFilter.new(config[CONF_DELTA])
     elif CONF_OR in config:
-        filters = None
         for filters in setup_filters(config[CONF_OR]):
             yield None
         yield OrFilter.new(filters)
@@ -146,21 +174,23 @@ def setup_filter(config):
         yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
     elif CONF_DEBOUNCE in config:
         yield App.register_component(DebounceFilter.new(config[CONF_DEBOUNCE]))
-    elif CONF_UNIQUE in config:
-        yield UniqueFilter.new()
+    elif CONF_CALIBRATE_LINEAR in config:
+        x = [conf[CONF_FROM] for conf in config[CONF_CALIBRATE_LINEAR]]
+        y = [conf[CONF_TO] for conf in config[CONF_CALIBRATE_LINEAR]]
+        k, b = fit_linear(x, y)
+        yield CalibrateLinearFilter.new(k, b)
 
 
 def setup_filters(config):
     filters = []
     for conf in config:
-        filter = None
         for filter in setup_filter(conf):
             yield None
         filters.append(filter)
-    yield ArrayInitializer(*filters)
+    yield filters
 
 
-def setup_sensor_core_(sensor_var, mqtt_var, config):
+def setup_sensor_core_(sensor_var, config):
     if CONF_INTERNAL in config:
         add(sensor_var.set_internal(config[CONF_INTERNAL]))
     if CONF_UNIT_OF_MEASUREMENT in config:
@@ -170,7 +200,6 @@ def setup_sensor_core_(sensor_var, mqtt_var, config):
     if CONF_ACCURACY_DECIMALS in config:
         add(sensor_var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
     if CONF_FILTERS in config:
-        filters = None
         for filters in setup_filters(config[CONF_FILTERS]):
             yield
         add(sensor_var.set_filters(filters))
@@ -178,60 +207,92 @@ def setup_sensor_core_(sensor_var, mqtt_var, config):
     for conf in config.get(CONF_ON_VALUE, []):
         rhs = sensor_var.make_state_trigger()
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, float_, conf)
+        automation.build_automations(trigger, [(float_, 'x')], conf)
     for conf in config.get(CONF_ON_RAW_VALUE, []):
         rhs = sensor_var.make_raw_state_trigger()
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, float_, conf)
+        automation.build_automations(trigger, [(float_, 'x')], conf)
     for conf in config.get(CONF_ON_VALUE_RANGE, []):
         rhs = sensor_var.make_value_range_trigger()
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        add(App.register_component(trigger))
         if CONF_ABOVE in conf:
-            template_ = None
             for template_ in templatable(conf[CONF_ABOVE], float_, float_):
                 yield
             add(trigger.set_min(template_))
         if CONF_BELOW in conf:
-            template_ = None
             for template_ in templatable(conf[CONF_BELOW], float_, float_):
                 yield
             add(trigger.set_max(template_))
-        automation.build_automation(trigger, float_, conf)
+        automation.build_automations(trigger, [(float_, 'x')], conf)
 
+    mqtt_ = sensor_var.Pget_mqtt()
     if CONF_EXPIRE_AFTER in config:
         if config[CONF_EXPIRE_AFTER] is None:
-            add(mqtt_var.disable_expire_after())
+            add(mqtt_.disable_expire_after())
         else:
-            add(mqtt_var.set_expire_after(config[CONF_EXPIRE_AFTER]))
-    setup_mqtt_component(mqtt_var, config)
+            add(mqtt_.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    setup_mqtt_component(mqtt_, config)
 
 
-def setup_sensor(sensor_obj, mqtt_obj, config):
-    sensor_var = Pvariable(config[CONF_ID], sensor_obj, has_side_effects=False)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj, has_side_effects=False)
-    add_job(setup_sensor_core_, sensor_var, mqtt_var, config)
+def setup_sensor(sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        sensor_obj = Pvariable(config[CONF_ID], sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_sensor_core_, sensor_obj, config)
 
 
 def register_sensor(var, config):
     sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
-    rhs = App.register_sensor(sensor_var)
-    mqtt_var = Pvariable(config[CONF_MQTT_ID], rhs, has_side_effects=True)
-    add_job(setup_sensor_core_, sensor_var, mqtt_var, config)
+    add(App.register_sensor(sensor_var))
+    CORE.add_job(setup_sensor_core_, sensor_var, config)
 
 
 BUILD_FLAGS = '-DUSE_SENSOR'
 
+CONF_SENSOR_IN_RANGE = 'sensor.in_range'
+SENSOR_IN_RANGE_CONDITION_SCHEMA = vol.All({
+    vol.Required(CONF_ID): cv.use_variable_id(Sensor),
+    vol.Optional(CONF_ABOVE): cv.float_,
+    vol.Optional(CONF_BELOW): cv.float_,
+}, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
 
-def core_to_hass_config(data, config):
-    ret = mqtt.build_hass_config(data, 'sensor', config, include_state=True, include_command=False)
-    if ret is None:
-        return None
-    if CONF_UNIT_OF_MEASUREMENT in config:
-        ret['unit_of_measurement'] = config[CONF_UNIT_OF_MEASUREMENT]
-    if CONF_EXPIRE_AFTER in config:
-        expire = config[CONF_EXPIRE_AFTER]
-        if expire is not None:
-            ret['expire_after'] = expire.total_seconds
-    if CONF_ICON in config:
-        ret['icon'] = config[CONF_ICON]
-    return ret
+
+@CONDITION_REGISTRY.register(CONF_SENSOR_IN_RANGE, SENSOR_IN_RANGE_CONDITION_SCHEMA)
+def sensor_in_range_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_in_range_condition(template_arg)
+    type = SensorInRangeCondition.template(template_arg)
+    cond = Pvariable(condition_id, rhs, type=type)
+
+    if CONF_ABOVE in config:
+        add(cond.set_min(config[CONF_ABOVE]))
+    if CONF_BELOW in config:
+        add(cond.set_max(config[CONF_BELOW]))
+
+    yield cond
+
+
+def _mean(xs):
+    return sum(xs) / len(xs)
+
+
+def _std(x):
+    return math.sqrt(sum((x_ - _mean(x))**2 for x_ in x) / (len(x) - 1))
+
+
+def _correlation_coeff(x, y):
+    m_x, m_y = _mean(x), _mean(y)
+    s_xy = sum((x_ - m_x) * (y_ - m_y) for x_, y_ in zip(x, y))
+    s_sq_x = sum((x_ - m_x)**2 for x_ in x)
+    s_sq_y = sum((y_ - m_y)**2 for y_ in y)
+    return s_xy / math.sqrt(s_sq_x * s_sq_y)
+
+
+def fit_linear(x, y):
+    assert len(x) == len(y)
+    m_x, m_y = _mean(x), _mean(y)
+    r = _correlation_coeff(x, y)
+    k = r * (_std(y) / _std(x))
+    b = m_y - k * m_x
+    return k, b

esphome/components/sensor/adc.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ATTENUATION, CONF_MAKE_ID, CONF_NAME, CONF_PIN, \
-    CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, add, global_ns, variable, setup_component
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, global_ns
 
 ATTENUATION_MODES = {
     '0db': global_ns.ADC_0db,
@@ -22,14 +23,13 @@ def validate_adc_pin(value):
     return pins.analog_pin(value)
 
 
-MakeADCSensor = Application.struct('MakeADCSensor')
 ADCSensorComponent = sensor.sensor_ns.class_('ADCSensorComponent', sensor.PollingSensorComponent)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(ADCSensorComponent),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeADCSensor),
     vol.Required(CONF_PIN): validate_adc_pin,
-    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES)),
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES,
+                                                                        lower=True)),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
@@ -40,11 +40,10 @@ def to_code(config):
         pin = 0
     rhs = App.make_adc_sensor(config[CONF_NAME], pin,
                               config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    adc = make.Padc
+    adc = Pvariable(config[CONF_ID], rhs)
     if CONF_ATTENUATION in config:
         add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
-    sensor.setup_sensor(adc, make.Pmqtt, config)
+    sensor.setup_sensor(adc, config)
     setup_component(adc, config)
 
 
@@ -57,5 +56,7 @@ def required_build_flags(config):
     return None
 
 
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)
+def includes(config):
+    if config[CONF_PIN] == 'VCC':
+        return 'ADC_MODE(ADC_VCC);'
+    return None

esphome/components/sensor/ads1115.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.components.ads1115 import ADS1115Component
-from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+from esphome.components import sensor
+from esphome.components.ads1115 import ADS1115Component
+import esphome.config_validation as cv
+from esphome.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import get_variable
+from esphome.cpp_generator import get_variable
+from esphome.py_compat import string_types
 
 DEPENDENCIES = ['ads1115']
 
@@ -24,7 +25,7 @@ MUX = {
 ADS1115Gain = sensor.sensor_ns.enum('ADS1115Gain')
 GAIN = {
     '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
-    '4.096': ADS1115Gain.ADS1115_GAIN_6P096,
+    '4.096': ADS1115Gain.ADS1115_GAIN_4P096,
     '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
     '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
     '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
@@ -35,7 +36,7 @@ GAIN = {
 def validate_gain(value):
     if isinstance(value, float):
         value = u'{:0.03f}'.format(value)
-    elif not isinstance(value, (str, unicode)):
+    elif not isinstance(value, string_types):
         raise vol.Invalid('invalid gain "{}"'.format(value))
 
     return cv.one_of(*GAIN)(value)
@@ -59,7 +60,6 @@ PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    hub = None
     for hub in get_variable(config[CONF_ADS1115_ID]):
         yield
 
@@ -70,7 +70,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/apds9960.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.apds9960 import APDS9960, CONF_APDS9960_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_TYPE
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['apds9960']
+
+TYPES = {
+    'CLEAR': 'make_clear_channel',
+    'RED': 'make_red_channel',
+    'GREEN': 'make_green_channel',
+    'BLUE': 'make_blue_channel',
+    'PROXIMITY': 'make_proximity',
+}
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    vol.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+    cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_APDS9960_ID]):
+        yield
+    func = getattr(hub, TYPES[config[CONF_TYPE]])
+    rhs = func(config[CONF_NAME])
+    sensor.register_sensor(rhs, config)

esphome/components/sensor/bh1750.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor, i2c
-from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_RESOLUTION, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RESOLUTION, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, add, variable, setup_component
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 DEPENDENCIES = ['i2c']
 
@@ -15,13 +17,11 @@ BH1750_RESOLUTIONS = {
     0.5: BH1750Resolution.BH1750_RESOLUTION_0P5_LX,
 }
 
-MakeBH1750Sensor = Application.struct('MakeBH1750Sensor')
 BH1750Sensor = sensor.sensor_ns.class_('BH1750Sensor', sensor.PollingSensorComponent,
                                        i2c.I2CDevice)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(BH1750Sensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBH1750Sensor),
     vol.Optional(CONF_ADDRESS, default=0x23): cv.i2c_address,
     vol.Optional(CONF_RESOLUTION): vol.All(cv.positive_float, cv.one_of(*BH1750_RESOLUTIONS)),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
@@ -31,16 +31,11 @@ PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
 def to_code(config):
     rhs = App.make_bh1750_sensor(config[CONF_NAME], config[CONF_ADDRESS],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make_bh1750 = variable(config[CONF_MAKE_ID], rhs)
-    bh1750 = make_bh1750.Pbh1750
+    bh1750 = Pvariable(config[CONF_ID], rhs)
     if CONF_RESOLUTION in config:
         add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
-    sensor.setup_sensor(bh1750, make_bh1750.Pmqtt, config)
+    sensor.setup_sensor(bh1750, config)
     setup_component(bh1750, config)
 
 
 BUILD_FLAGS = '-DUSE_BH1750'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/ble_rssi.py

@@ -1,15 +1,16 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+from esphome.components import sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
     make_address_array
-from esphomeyaml.const import CONF_MAC_ADDRESS, CONF_NAME
-from esphomeyaml.helpers import get_variable, esphomelib_ns
+import esphome.config_validation as cv
+from esphome.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import esphome_ns
 
 DEPENDENCIES = ['esp32_ble_tracker']
 
-ESP32BLERSSISensor = esphomelib_ns.class_('ESP32BLERSSISensor', sensor.Sensor)
+ESP32BLERSSISensor = esphome_ns.class_('ESP32BLERSSISensor', sensor.Sensor)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(ESP32BLERSSISensor),
@@ -23,7 +24,3 @@ def to_code(config):
         yield
     rhs = hub.make_rssi_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
     sensor.register_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/bme280.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_IIR_FILTER, CONF_MAKE_ID, \
-    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, add, variable, setup_component
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -28,10 +30,10 @@ IIR_FILTER_OPTIONS = {
 }
 
 BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
-    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
 })
 
-MakeBME280Sensor = Application.struct('MakeBME280Sensor')
+BME280Component = sensor.sensor_ns.class_('BME280Component', PollingComponent, i2c.I2CDevice)
 BME280TemperatureSensor = sensor.sensor_ns.class_('BME280TemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
 BME280PressureSensor = sensor.sensor_ns.class_('BME280PressureSensor',
@@ -40,7 +42,7 @@ BME280HumiditySensor = sensor.sensor_ns.class_('BME280HumiditySensor',
                                                sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBME280Sensor),
+    cv.GenerateID(): cv.declare_variable_id(BME280Component),
     vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
     vol.Required(CONF_TEMPERATURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BME280TemperatureSensor),
@@ -51,7 +53,7 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HUMIDITY): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BME280HumiditySensor),
     })),
-    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
@@ -62,8 +64,7 @@ def to_code(config):
                                  config[CONF_HUMIDITY][CONF_NAME],
                                  config[CONF_ADDRESS],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    bme280 = make.Pbme280
+    bme280 = Pvariable(config[CONF_ID], rhs)
     if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
         constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
         add(bme280.set_temperature_oversampling(constant))
@@ -77,19 +78,10 @@ def to_code(config):
         constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
         add(bme280.set_iir_filter(constant))
 
-    sensor.setup_sensor(bme280.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(bme280.Pget_pressure_sensor(), make.Pmqtt_pressure,
-                        config[CONF_PRESSURE])
-    sensor.setup_sensor(bme280.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme280.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme280.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme280.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(bme280, config)
 
 
 BUILD_FLAGS = '-DUSE_BME280'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/bme680.py

@@ -1,12 +1,14 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import core
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADDRESS, CONF_GAS_RESISTANCE, CONF_HUMIDITY, CONF_IIR_FILTER, \
-    CONF_MAKE_ID, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL, CONF_HEATER, CONF_DURATION
-from esphomeyaml.helpers import App, Application, add, variable, setup_component
+from esphome import core
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DURATION, CONF_GAS_RESISTANCE, CONF_HEATER, \
+    CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -33,10 +35,10 @@ IIR_FILTER_OPTIONS = {
 }
 
 BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
-    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
 })
 
-MakeBME680Sensor = Application.struct('MakeBME680Sensor')
+BME680Component = sensor.sensor_ns.class_('BME680Component', PollingComponent, i2c.I2CDevice)
 BME680TemperatureSensor = sensor.sensor_ns.class_('BME680TemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
 BME680PressureSensor = sensor.sensor_ns.class_('BME680PressureSensor',
@@ -47,7 +49,7 @@ BME680GasResistanceSensor = sensor.sensor_ns.class_('BME680GasResistanceSensor',
                                                     sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBME680Sensor),
+    cv.GenerateID(): cv.declare_variable_id(BME680Component),
     vol.Optional(CONF_ADDRESS, default=0x76): cv.i2c_address,
     vol.Required(CONF_TEMPERATURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BME680TemperatureSensor),
@@ -61,8 +63,8 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_GAS_RESISTANCE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BME680GasResistanceSensor),
     })),
-    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
-    vol.Optional(CONF_HEATER): vol.Any(None, vol.All(vol.Schema({
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_HEATER): vol.Any(None, vol.All(cv.Schema({
         vol.Optional(CONF_TEMPERATURE, default=320): vol.All(vol.Coerce(int), vol.Range(200, 400)),
         vol.Optional(CONF_DURATION, default='150ms'): vol.All(
             cv.positive_time_period_milliseconds, vol.Range(max=core.TimePeriod(milliseconds=4032)))
@@ -78,8 +80,7 @@ def to_code(config):
                                  config[CONF_GAS_RESISTANCE][CONF_NAME],
                                  config[CONF_ADDRESS],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    bme680 = make.Pbme680
+    bme680 = Pvariable(config[CONF_ID], rhs)
     if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
         constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
         add(bme680.set_temperature_oversampling(constant))
@@ -99,22 +100,11 @@ def to_code(config):
         else:
             add(bme680.set_heater(conf[CONF_TEMPERATURE], conf[CONF_DURATION]))
 
-    sensor.setup_sensor(bme680.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(bme680.Pget_pressure_sensor(), make.Pmqtt_pressure,
-                        config[CONF_PRESSURE])
-    sensor.setup_sensor(bme680.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
-    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), make.Pmqtt_gas_resistance,
-                        config[CONF_GAS_RESISTANCE])
+    sensor.setup_sensor(bme680.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme680.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme680.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), config[CONF_GAS_RESISTANCE])
     setup_component(bme680, config)
 
 
 BUILD_FLAGS = '-DUSE_BME680'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY]),
-            sensor.core_to_hass_config(data, config[CONF_GAS_RESISTANCE])]

esphome/components/sensor/bmp085.py

@@ -1,21 +1,23 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADDRESS, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \
-    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, HexIntLiteral, add, variable, setup_component
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import HexIntLiteral, Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
-MakeBMP085Sensor = Application.struct('MakeBMP085Sensor')
+BMP085Component = sensor.sensor_ns.class_('BMP085Component', PollingComponent, i2c.I2CDevice)
 BMP085TemperatureSensor = sensor.sensor_ns.class_('BMP085TemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
 BMP085PressureSensor = sensor.sensor_ns.class_('BMP085PressureSensor',
                                                sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBMP085Sensor),
+    cv.GenerateID(): cv.declare_variable_id(BMP085Component),
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BMP085TemperatureSensor),
     })),
@@ -31,20 +33,13 @@ def to_code(config):
     rhs = App.make_bmp085_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                                  config[CONF_PRESSURE][CONF_NAME],
                                  config.get(CONF_UPDATE_INTERVAL))
-    bmp = variable(config[CONF_MAKE_ID], rhs)
+    bmp = Pvariable(config[CONF_ID], rhs)
     if CONF_ADDRESS in config:
-        add(bmp.Pbmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
+        add(bmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
 
-    sensor.setup_sensor(bmp.Pbmp.Pget_temperature_sensor(), bmp.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(bmp.Pbmp.Pget_pressure_sensor(), bmp.Pmqtt_pressure,
-                        config[CONF_PRESSURE])
-    setup_component(bmp.Pbmp, config)
+    sensor.setup_sensor(bmp.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(bmp, config)
 
 
 BUILD_FLAGS = '-DUSE_BMP085_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphome/components/sensor/bmp280.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_ADDRESS, CONF_IIR_FILTER, CONF_MAKE_ID, \
-    CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, add, variable, setup_component
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -28,17 +30,17 @@ IIR_FILTER_OPTIONS = {
 }
 
 BMP280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
-    vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
 })
 
-MakeBMP280Sensor = Application.struct('MakeBMP280Sensor')
+BMP280Component = sensor.sensor_ns.class_('BMP280Component', PollingComponent, i2c.I2CDevice)
 BMP280TemperatureSensor = sensor.sensor_ns.class_('BMP280TemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
 BMP280PressureSensor = sensor.sensor_ns.class_('BMP280PressureSensor',
                                                sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBMP280Sensor),
+    cv.GenerateID(): cv.declare_variable_id(BMP280Component),
     vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
     vol.Required(CONF_TEMPERATURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BMP280TemperatureSensor),
@@ -46,7 +48,7 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_PRESSURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(BMP280PressureSensor),
     })),
-    vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
@@ -56,8 +58,7 @@ def to_code(config):
                                  config[CONF_PRESSURE][CONF_NAME],
                                  config[CONF_ADDRESS],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    bmp280 = make.Pbmp280
+    bmp280 = Pvariable(config[CONF_ID], rhs)
     if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
         constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
         add(bmp280.set_temperature_oversampling(constant))
@@ -68,16 +69,9 @@ def to_code(config):
         constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
         add(bmp280.set_iir_filter(constant))
 
-    sensor.setup_sensor(bmp280.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(bmp280.Pget_pressure_sensor(), make.Pmqtt_pressure,
-                        config[CONF_PRESSURE])
+    sensor.setup_sensor(bmp280.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp280.Pget_pressure_sensor(), config[CONF_PRESSURE])
     setup_component(bmp280, config)
 
 
 BUILD_FLAGS = '-DUSE_BMP280'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphome/components/sensor/cse7766.py

@@ -1,15 +1,17 @@
 import voluptuous as vol
 
-from esphomeyaml.components import sensor, uart
-from esphomeyaml.components.uart import UARTComponent
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_CURRENT, CONF_ID, CONF_NAME, CONF_POWER, CONF_UART_ID, \
-    CONF_VOLTAGE
-from esphomeyaml.helpers import App, Pvariable, get_variable, setup_component, Component
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CURRENT, CONF_ID, CONF_NAME, CONF_POWER, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL, CONF_VOLTAGE
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['uart']
 
-CSE7766Component = sensor.sensor_ns.class_('CSE7766Component', Component, uart.UARTDevice)
+CSE7766Component = sensor.sensor_ns.class_('CSE7766Component', PollingComponent, uart.UARTDevice)
 CSE7766VoltageSensor = sensor.sensor_ns.class_('CSE7766VoltageSensor',
                                                sensor.EmptySensor)
 CSE7766CurrentSensor = sensor.sensor_ns.class_('CSE7766CurrentSensor',
@@ -30,6 +32,7 @@ PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(CSE7766PowerSensor),
     })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
                                                                CONF_POWER))
 
@@ -38,7 +41,7 @@ def to_code(config):
     for uart_ in get_variable(config[CONF_UART_ID]):
         yield
 
-    rhs = App.make_cse7766(uart_)
+    rhs = App.make_cse7766(uart_, config.get(CONF_UPDATE_INTERVAL))
     cse = Pvariable(config[CONF_ID], rhs)
 
     if CONF_VOLTAGE in config:
@@ -54,11 +57,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_CSE7766'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/custom.py

@@ -0,0 +1,33 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SENSORS
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomSensorConstructor = sensor.sensor_ns.class_('CustomSensorConstructor')
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomSensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(sensor.SensorPtr)):
+        yield
+
+    rhs = CustomSensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_SENSORS]):
+        rhs = custom.Pget_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        sensor.register_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_SENSOR'

esphome/components/sensor/dallas.py

@@ -1,11 +1,11 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.components.dallas import DallasComponent
-from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
+from esphome.components import sensor
+from esphome.components.dallas import DallasComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
     CONF_RESOLUTION
-from esphomeyaml.helpers import HexIntLiteral, get_variable
+from esphome.cpp_generator import HexIntLiteral, get_variable
 
 DallasTemperatureSensor = sensor.sensor_ns.class_('DallasTemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
@@ -32,7 +32,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/dht.py

@@ -1,12 +1,13 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
-    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, add, gpio_output_pin_expression, variable, \
-    setup_component, PollingComponent, Pvariable
-from esphomeyaml.pins import gpio_output_pin_schema
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, \
+    CONF_PIN, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
+from esphome.pins import gpio_input_pullup_pin_schema
 
 DHTModel = sensor.sensor_ns.enum('DHTModel')
 DHT_MODELS = {
@@ -15,9 +16,9 @@ DHT_MODELS = {
     'DHT22': DHTModel.DHT_MODEL_DHT22,
     'AM2302': DHTModel.DHT_MODEL_AM2302,
     'RHT03': DHTModel.DHT_MODEL_RHT03,
+    'SI7021': DHTModel.DHT_MODEL_SI7021,
 }
 
-MakeDHTSensor = Application.struct('MakeDHTSensor')
 DHTComponent = sensor.sensor_ns.class_('DHTComponent', PollingComponent)
 DHTTemperatureSensor = sensor.sensor_ns.class_('DHTTemperatureSensor',
                                                sensor.EmptyPollingParentSensor)
@@ -25,16 +26,15 @@ DHTHumiditySensor = sensor.sensor_ns.class_('DHTHumiditySensor',
                                             sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDHTSensor),
     cv.GenerateID(): cv.declare_variable_id(DHTComponent),
-    vol.Required(CONF_PIN): gpio_output_pin_schema,
+    vol.Required(CONF_PIN): gpio_input_pullup_pin_schema,
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(DHTTemperatureSensor),
     })),
     vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(DHTHumiditySensor),
     })),
-    vol.Optional(CONF_MODEL): vol.All(vol.Upper, cv.one_of(*DHT_MODELS)),
+    vol.Optional(CONF_MODEL): cv.one_of(*DHT_MODELS, upper=True),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
@@ -45,24 +45,15 @@ def to_code(config):
     rhs = App.make_dht_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                               config[CONF_HUMIDITY][CONF_NAME],
                               pin, config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    dht = make.Pdht
-    Pvariable(config[CONF_ID], dht)
+    dht = Pvariable(config[CONF_ID], rhs)
 
     if CONF_MODEL in config:
         constant = DHT_MODELS[config[CONF_MODEL]]
         add(dht.set_dht_model(constant))
 
-    sensor.setup_sensor(dht.Pget_temperature_sensor(),
-                        make.Pmqtt_temperature, config[CONF_TEMPERATURE])
-    sensor.setup_sensor(dht.Pget_humidity_sensor(),
-                        make.Pmqtt_humidity, config[CONF_HUMIDITY])
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(dht, config)
 
 
 BUILD_FLAGS = '-DUSE_DHT_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/dht12.py

@@ -1,15 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor, i2c
-from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, variable, setup_component, PollingComponent, \
-    Pvariable
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
-MakeDHT12Sensor = Application.struct('MakeDHT12Sensor')
 DHT12Component = sensor.sensor_ns.class_('DHT12Component', PollingComponent, i2c.I2CDevice)
 DHT12TemperatureSensor = sensor.sensor_ns.class_('DHT12TemperatureSensor',
                                                  sensor.EmptyPollingParentSensor)
@@ -17,7 +17,6 @@ DHT12HumiditySensor = sensor.sensor_ns.class_('DHT12HumiditySensor',
                                               sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDHT12Sensor),
     cv.GenerateID(): cv.declare_variable_id(DHT12Component),
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(DHT12TemperatureSensor),
@@ -33,20 +32,11 @@ def to_code(config):
     rhs = App.make_dht12_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                                 config[CONF_HUMIDITY][CONF_NAME],
                                 config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    dht = make.Pdht12
-    Pvariable(config[CONF_ID], dht)
+    dht = Pvariable(config[CONF_ID], rhs)
 
-    sensor.setup_sensor(dht.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(dht.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(dht, config)
 
 
 BUILD_FLAGS = '-DUSE_DHT12_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/duty_cycle.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
+
+DutyCycleSensor = sensor.sensor_ns.class_('DutyCycleSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DutyCycleSensor),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_input_pin_schema,
+                                    pins.validate_has_interrupt),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_duty_cycle_sensor(config[CONF_NAME], pin,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    duty = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(duty, config)
+    setup_component(duty, config)
+
+
+BUILD_FLAGS = '-DUSE_DUTY_CYCLE_SENSOR'

esphome/components/sensor/esp32_hall.py

@@ -1,9 +1,11 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Application, variable, setup_component
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -12,20 +14,15 @@ ESP32HallSensor = sensor.sensor_ns.class_('ESP32HallSensor', sensor.PollingSenso
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(ESP32HallSensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeESP32HallSensor),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
 
 def to_code(config):
     rhs = App.make_esp32_hall_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    sensor.setup_sensor(make.Phall, make.Pmqtt, config)
-    setup_component(make.Phall, config)
+    hall = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(hall, config)
+    setup_component(hall, config)
 
 
 BUILD_FLAGS = '-DUSE_ESP32_HALL_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/hdc1080.py

@@ -1,15 +1,15 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor, i2c
-from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, variable, setup_component, PollingComponent, \
-    Pvariable
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
-MakeHDC1080Sensor = Application.struct('MakeHDC1080Sensor')
 HDC1080Component = sensor.sensor_ns.class_('HDC1080Component', PollingComponent, i2c.I2CDevice)
 HDC1080TemperatureSensor = sensor.sensor_ns.class_('HDC1080TemperatureSensor',
                                                    sensor.EmptyPollingParentSensor)
@@ -17,7 +17,6 @@ HDC1080HumiditySensor = sensor.sensor_ns.class_('HDC1080HumiditySensor',
                                                 sensor.EmptyPollingParentSensor)
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHDC1080Sensor),
     cv.GenerateID(): cv.declare_variable_id(HDC1080Component),
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(HDC1080TemperatureSensor),
@@ -33,21 +32,11 @@ def to_code(config):
     rhs = App.make_hdc1080_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                                   config[CONF_HUMIDITY][CONF_NAME],
                                   config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    hdc1080 = make.Phdc1080
-    Pvariable(config[CONF_ID], hdc1080)
+    hdc1080 = Pvariable(config[CONF_ID], rhs)
 
-    sensor.setup_sensor(hdc1080.Pget_temperature_sensor(),
-                        make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(hdc1080.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(hdc1080.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(hdc1080.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(hdc1080, config)
 
 
 BUILD_FLAGS = '-DUSE_HDC1080_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/hlw8012.py

@@ -1,13 +1,14 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components import sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_CF1_PIN, CONF_CF_PIN, CONF_CHANGE_MODE_EVERY, CONF_CURRENT, \
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CF1_PIN, CONF_CF_PIN, CONF_CHANGE_MODE_EVERY, CONF_CURRENT, \
     CONF_CURRENT_RESISTOR, CONF_ID, CONF_NAME, CONF_POWER, CONF_SEL_PIN, CONF_UPDATE_INTERVAL, \
     CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, gpio_output_pin_expression, \
-    setup_component
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
 
 HLW8012Component = sensor.sensor_ns.class_('HLW8012Component', PollingComponent)
 HLW8012VoltageSensor = sensor.sensor_ns.class_('HLW8012VoltageSensor', sensor.EmptySensor)
@@ -65,11 +66,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_HLW8012'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/hmc5883l.py

@@ -1,10 +1,12 @@
 # coding=utf-8
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor, i2c
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, CONF_RANGE
-from esphomeyaml.helpers import App, Pvariable, add, setup_component, PollingComponent
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RANGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -19,7 +21,6 @@ HMC5883LFieldStrengthSensor = sensor.sensor_ns.class_('HMC5883LFieldStrengthSens
 HMC5883LHeadingSensor = sensor.sensor_ns.class_('HMC5883LHeadingSensor',
                                                 sensor.EmptyPollingParentSensor)
 
-
 HMC5883LRange = sensor.sensor_ns.enum('HMC5883LRange')
 HMC5883L_RANGES = {
     88: HMC5883LRange.HMC5883L_RANGE_88_UT,
@@ -37,7 +38,7 @@ def validate_range(value):
     value = cv.string(value)
     if value.endswith(u'µT') or value.endswith('uT'):
         value = value[:-2]
-    return cv.one_of(*HMC5883L_RANGES)(int(value))
+    return cv.one_of(*HMC5883L_RANGES, int=True)(value)
 
 
 SENSOR_KEYS = [CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z,
@@ -86,11 +87,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_HMC5883L'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z, CONF_HEADING):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/homeassistant.py

@@ -0,0 +1,25 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeassistantSensor = sensor.sensor_ns.class_('HomeassistantSensor', sensor.Sensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantSensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    subs = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_SENSOR'

esphome/components/sensor/htu21d.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, \
-    CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, PollingComponent, setup_component, variable, \
-    Pvariable
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -18,7 +19,6 @@ HTU21DHumiditySensor = sensor.sensor_ns.class_('HTU21DHumiditySensor',
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(HTU21DComponent),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHTU21DSensor),
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(HTU21DTemperatureSensor),
     })),
@@ -33,20 +33,11 @@ def to_code(config):
     rhs = App.make_htu21d_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                                  config[CONF_HUMIDITY][CONF_NAME],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    htu21d = make.Phtu21d
-    Pvariable(config[CONF_ID], htu21d)
+    htu21d = Pvariable(config[CONF_ID], rhs)
 
-    sensor.setup_sensor(htu21d.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(htu21d.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(htu21d.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(htu21d.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(htu21d, config)
 
 
 BUILD_FLAGS = '-DUSE_HTU21D_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/hx711.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_GAIN, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL, CONF_CLK_PIN
-from esphomeyaml.helpers import App, Application, add, gpio_input_pin_expression, variable, \
-    setup_component
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CLK_PIN, CONF_GAIN, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Application
 
 MakeHX711Sensor = Application.struct('MakeHX711Sensor')
 HX711Sensor = sensor.sensor_ns.class_('HX711Sensor', sensor.PollingSensorComponent)
@@ -21,10 +22,9 @@ GAINS = {
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(HX711Sensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeHX711Sensor),
     vol.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
     vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
-    vol.Optional(CONF_GAIN): vol.All(cv.int_, cv.one_of(*GAINS)),
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, int=True),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
@@ -37,18 +37,13 @@ def to_code(config):
 
     rhs = App.make_hx711_sensor(config[CONF_NAME], dout_pin, sck_pin,
                                 config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    hx711 = make.Phx711
+    hx711 = Pvariable(config[CONF_ID], rhs)
 
     if CONF_GAIN in config:
         add(hx711.set_gain(GAINS[config[CONF_GAIN]]))
 
-    sensor.setup_sensor(hx711, make.Pmqtt, config)
+    sensor.setup_sensor(hx711, config)
     setup_component(hx711, config)
 
 
 BUILD_FLAGS = '-DUSE_HX711'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/ina219.py

@@ -1,12 +1,14 @@
 # coding=utf-8
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, \
     CONF_MAX_CURRENT, CONF_MAX_VOLTAGE, CONF_NAME, CONF_POWER, CONF_SHUNT_RESISTANCE, \
     CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, setup_component
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -64,11 +66,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_INA219'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/ina3221.py

@@ -1,11 +1,13 @@
 # coding=utf-8
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, CONF_NAME, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, CONF_NAME, \
     CONF_POWER, CONF_SHUNT_RESISTANCE, CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, setup_component
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -22,7 +24,7 @@ INA3221PowerSensor = sensor.sensor_ns.class_('INA3221PowerSensor', sensor.EmptyP
 
 SENSOR_KEYS = [CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER]
 
-INA3221_CHANNEL_SCHEMA = vol.All(vol.Schema({
+INA3221_CHANNEL_SCHEMA = vol.All(cv.Schema({
     vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(INA3221VoltageSensor),
     })),
@@ -75,15 +77,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_INA3221'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for channel in (CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3):
-        if channel not in config:
-            continue
-        conf = config[channel]
-        for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
-            if key in conf:
-                ret.append(sensor.core_to_hass_config(data, conf[key]))
-    return ret

esphome/components/sensor/max31855.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
+
+MAX31855Sensor = sensor.sensor_ns.class_('MAX31855Sensor', sensor.PollingSensorComponent,
+                                         spi.SPIDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX31855Sensor),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max31855_sensor(config[CONF_NAME], spi_, cs,
+                                   config.get(CONF_UPDATE_INTERVAL))
+    max31855 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max31855, config)
+    setup_component(max31855, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX31855_SENSOR'

esphome/components/sensor/max6675.py

@@ -1,21 +1,20 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import pins
-from esphomeyaml.components import sensor, spi
-from esphomeyaml.components.spi import SPIComponent
-from esphomeyaml.const import CONF_CS_PIN, CONF_MAKE_ID, CONF_NAME, CONF_SPI_ID, \
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, get_variable, gpio_output_pin_expression, \
-    variable, setup_component
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
 
-MakeMAX6675Sensor = Application.struct('MakeMAX6675Sensor')
 MAX6675Sensor = sensor.sensor_ns.class_('MAX6675Sensor', sensor.PollingSensorComponent,
                                         spi.SPIDevice)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(MAX6675Sensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMAX6675Sensor),
     cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
     vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
@@ -29,14 +28,9 @@ def to_code(config):
         yield
     rhs = App.make_max6675_sensor(config[CONF_NAME], spi_, cs,
                                   config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    max6675 = make.Pmax6675
-    sensor.setup_sensor(max6675, make.Pmqtt, config)
+    max6675 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max6675, config)
     setup_component(max6675, config)
 
 
 BUILD_FLAGS = '-DUSE_MAX6675_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/mhz19.py

@@ -1,16 +1,16 @@
 import voluptuous as vol
 
-from esphomeyaml.components import sensor, uart
-from esphomeyaml.components.uart import UARTComponent
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_CO2, CONF_MAKE_ID, CONF_NAME, CONF_TEMPERATURE, CONF_UART_ID, \
-    CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, PollingComponent, get_variable, setup_component, \
-    variable, Pvariable
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CO2, CONF_ID, CONF_NAME, CONF_TEMPERATURE, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['uart']
 
-MakeMHZ19Sensor = Application.struct('MakeMHZ19Sensor')
 MHZ19Component = sensor.sensor_ns.class_('MHZ19Component', PollingComponent, uart.UARTDevice)
 MHZ19TemperatureSensor = sensor.sensor_ns.class_('MHZ19TemperatureSensor',
                                                  sensor.EmptyPollingParentSensor)
@@ -18,7 +18,6 @@ MHZ19CO2Sensor = sensor.sensor_ns.class_('MHZ19CO2Sensor', sensor.EmptyPollingPa
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(MHZ19Component),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMHZ19Sensor),
     cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
     vol.Required(CONF_CO2): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(MHZ19CO2Sensor),
@@ -35,10 +34,8 @@ def to_code(config):
         yield
     rhs = App.make_mhz19_sensor(uart_, config[CONF_CO2][CONF_NAME],
                                 config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    mhz19 = make.Pmhz19
-    Pvariable(config[CONF_ID], mhz19)
-    sensor.setup_sensor(mhz19.Pget_co2_sensor(), make.Pmqtt, config[CONF_CO2])
+    mhz19 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(mhz19.Pget_co2_sensor(), config[CONF_CO2])
 
     if CONF_TEMPERATURE in config:
         sensor.register_sensor(mhz19.Pmake_temperature_sensor(config[CONF_TEMPERATURE][CONF_NAME]),
@@ -48,11 +45,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_MHZ19'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_CO2, CONF_TEMPERATURE):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/mpu6050.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
     CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, setup_component
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -88,12 +90,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_MPU6050'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z, CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z,
-                CONF_TEMPERATURE):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/mqtt_subscribe.py

@@ -1,18 +1,18 @@
 import voluptuous as vol
 
-from esphomeyaml.components import sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
-from esphomeyaml.helpers import App, Application, add, variable, setup_component, Component
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 DEPENDENCIES = ['mqtt']
 
-MakeMQTTSubscribeSensor = Application.struct('MakeMQTTSubscribeSensor')
 MQTTSubscribeSensor = sensor.sensor_ns.class_('MQTTSubscribeSensor', sensor.Sensor, Component)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeSensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMQTTSubscribeSensor),
     vol.Required(CONF_TOPIC): cv.subscribe_topic,
     vol.Optional(CONF_QOS): cv.mqtt_qos,
 }).extend(cv.COMPONENT_SCHEMA.schema))
@@ -20,18 +20,13 @@ PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
 
 def to_code(config):
     rhs = App.make_mqtt_subscribe_sensor(config[CONF_NAME], config[CONF_TOPIC])
-    make = variable(config[CONF_MAKE_ID], rhs)
-    subs = make.Psensor
+    subs = Pvariable(config[CONF_ID], rhs)
 
     if CONF_QOS in config:
         add(subs.set_qos(config[CONF_QOS]))
 
-    sensor.setup_sensor(subs, make.Pmqtt, config)
+    sensor.setup_sensor(subs, config)
     setup_component(subs, config)
 
 
 BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/ms5611.py

@@ -1,16 +1,15 @@
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_MAKE_ID, CONF_NAME, CONF_PRESSURE, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, \
     CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, PollingComponent, Pvariable, add, \
-    setup_component, \
-    variable
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
-MakeMS5611Sensor = Application.struct('MakeMS5611Sensor')
 MS5611Component = sensor.sensor_ns.class_('MS5611Component', PollingComponent, i2c.I2CDevice)
 MS5611TemperatureSensor = sensor.sensor_ns.class_('MS5611TemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
@@ -19,7 +18,6 @@ MS5611PressureSensor = sensor.sensor_ns.class_('MS5611PressureSensor',
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(MS5611Component),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMS5611Sensor),
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(MS5611TemperatureSensor),
@@ -35,23 +33,14 @@ def to_code(config):
     rhs = App.make_ms5611_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                                  config[CONF_PRESSURE][CONF_NAME],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    ms5611 = make.Pms5611
-    Pvariable(config[CONF_ID], ms5611)
+    ms5611 = Pvariable(config[CONF_ID], rhs)
 
     if CONF_ADDRESS in config:
         add(ms5611.set_address(config[CONF_ADDRESS]))
 
-    sensor.setup_sensor(ms5611.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(ms5611.Pget_pressure_sensor(), make.Pmqtt_pressure,
-                        config[CONF_PRESSURE])
+    sensor.setup_sensor(ms5611.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(ms5611.Pget_pressure_sensor(), config[CONF_PRESSURE])
     setup_component(ms5611, config)
 
 
 BUILD_FLAGS = '-DUSE_MS5611'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]

esphome/components/sensor/pmsx003.py

@@ -1,11 +1,13 @@
 import voluptuous as vol
 
-from esphomeyaml.components import sensor, uart
-from esphomeyaml.components.uart import UARTComponent
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_FORMALDEHYDE, CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_PM_10_0, \
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_FORMALDEHYDE, CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_PM_10_0, \
     CONF_PM_1_0, CONF_PM_2_5, CONF_TEMPERATURE, CONF_TYPE, CONF_UART_ID
-from esphomeyaml.helpers import App, Pvariable, get_variable, setup_component, Component
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 DEPENDENCIES = ['uart']
 
@@ -34,7 +36,7 @@ SENSORS_TO_TYPE = {
 
 
 def validate_pmsx003_sensors(value):
-    for key, types in SENSORS_TO_TYPE.iteritems():
+    for key, types in SENSORS_TO_TYPE.items():
         if key in value and value[CONF_TYPE] not in types:
             raise vol.Invalid(u"{} does not have {} sensor!".format(value[CONF_TYPE], key))
     return value
@@ -44,11 +46,10 @@ PMSX003_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(PMSX003Sensor),
 })
 
-
 PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(PMSX003Component),
     cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
-    vol.Required(CONF_TYPE): vol.All(vol.Upper, cv.one_of(*PMSX003_TYPES)),
+    vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True),
 
     vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA),
     vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA),
@@ -94,12 +95,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_PMSX003'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_PM_1_0, CONF_PM_2_5, CONF_PM_10_0, CONF_TEMPERATURE, CONF_HUMIDITY,
-                CONF_FORMALDEHYDE):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/pulse_counter.py

@@ -1,13 +1,14 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import core, pins
-from esphomeyaml.components import sensor
-from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_INTERNAL_FILTER, \
-    CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
-    ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Application, add, variable, gpio_input_pin_expression, \
-    setup_component
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, CONF_NUMBER
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
 
 PulseCounterCountMode = sensor.sensor_ns.enum('PulseCounterCountMode')
 COUNT_MODES = {
@@ -16,17 +17,16 @@ COUNT_MODES = {
     'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
 }
 
-COUNT_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*COUNT_MODES))
+COUNT_MODE_SCHEMA = cv.one_of(*COUNT_MODES, upper=True)
 
 PulseCounterBase = sensor.sensor_ns.class_('PulseCounterBase')
-MakePulseCounterSensor = Application.struct('MakePulseCounterSensor')
 PulseCounterSensorComponent = sensor.sensor_ns.class_('PulseCounterSensorComponent',
                                                       sensor.PollingSensorComponent,
                                                       PulseCounterBase)
 
 
 def validate_internal_filter(value):
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if CORE.is_esp32:
         if isinstance(value, int):
             raise vol.Invalid("Please specify the internal filter in microseconds now "
                               "(since 1.7.0). For example '17ms'")
@@ -34,23 +34,26 @@ def validate_internal_filter(value):
         if value.total_microseconds > 13:
             raise vol.Invalid("Maximum internal filter value for ESP32 is 13us")
         return value
-    else:
-        return cv.positive_time_period_microseconds(value)
+
+    return cv.positive_time_period_microseconds(value)
+
+
+def validate_pulse_counter_pin(value):
+    value = pins.internal_gpio_input_pin_schema(value)
+    if CORE.is_esp8266 and value[CONF_NUMBER] >= 16:
+        raise vol.Invalid("Pins GPIO16 and GPIO17 cannot be used as pulse counters on ESP8266.")
+    return value
 
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(PulseCounterSensorComponent),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakePulseCounterSensor),
-    vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
-    vol.Optional(CONF_COUNT_MODE): vol.Schema({
+    vol.Required(CONF_PIN): validate_pulse_counter_pin,
+    vol.Optional(CONF_COUNT_MODE): cv.Schema({
         vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
         vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
     }),
     vol.Optional(CONF_INTERNAL_FILTER): validate_internal_filter,
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
-
-    vol.Optional(CONF_PULL_MODE): cv.invalid("The pull_mode option has been removed in 1.7.0, "
-                                             "please use the pin mode schema now.")
 }).extend(cv.COMPONENT_SCHEMA.schema))
 
 
@@ -59,8 +62,7 @@ def to_code(config):
         yield
     rhs = App.make_pulse_counter_sensor(config[CONF_NAME], pin,
                                         config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    pcnt = make.Ppcnt
+    pcnt = Pvariable(config[CONF_ID], rhs)
 
     if CONF_COUNT_MODE in config:
         rising_edge = COUNT_MODES[config[CONF_COUNT_MODE][CONF_RISING_EDGE]]
@@ -69,12 +71,8 @@ def to_code(config):
     if CONF_INTERNAL_FILTER in config:
         add(pcnt.set_filter_us(config[CONF_INTERNAL_FILTER]))
 
-    sensor.setup_sensor(pcnt, make.Pmqtt, config)
+    sensor.setup_sensor(pcnt, config)
     setup_component(pcnt, config)
 
 
 BUILD_FLAGS = '-DUSE_PULSE_COUNTER_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/rotary_encoder.py

@@ -0,0 +1,72 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_RESOLUTION, CONF_MIN_VALUE, CONF_MAX_VALUE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+RotaryEncoderResolution = sensor.sensor_ns.enum('RotaryEncoderResolution')
+RESOLUTIONS = {
+    1: RotaryEncoderResolution.ROTARY_ENCODER_1_PULSE_PER_CYCLE,
+    2: RotaryEncoderResolution.ROTARY_ENCODER_2_PULSES_PER_CYCLE,
+    4: RotaryEncoderResolution.ROTARY_ENCODER_4_PULSES_PER_CYCLE,
+}
+
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_RESET = 'pin_reset'
+
+RotaryEncoderSensor = sensor.sensor_ns.class_('RotaryEncoderSensor', sensor.Sensor, Component)
+
+
+def validate_min_max_value(config):
+    if CONF_MIN_VALUE in config and CONF_MAX_VALUE in config:
+        min_val = config[CONF_MIN_VALUE]
+        max_val = config[CONF_MAX_VALUE]
+        if min_val >= max_val:
+            raise vol.Invalid("Max value {} must be smaller than min value {}"
+                              "".format(max_val, min_val))
+    return config
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RotaryEncoderSensor),
+    vol.Required(CONF_PIN_A): vol.All(pins.internal_gpio_input_pin_schema,
+                                      pins.validate_has_interrupt),
+    vol.Required(CONF_PIN_B): vol.All(pins.internal_gpio_input_pin_schema,
+                                      pins.validate_has_interrupt),
+    vol.Optional(CONF_PIN_RESET): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_RESOLUTION): cv.one_of(*RESOLUTIONS, int=True),
+    vol.Optional(CONF_MIN_VALUE): cv.int_,
+    vol.Optional(CONF_MAX_VALUE): cv.int_,
+}).extend(cv.COMPONENT_SCHEMA.schema), validate_min_max_value)
+
+
+def to_code(config):
+    for pin_a in gpio_input_pin_expression(config[CONF_PIN_A]):
+        yield
+    for pin_b in gpio_input_pin_expression(config[CONF_PIN_B]):
+        yield
+    rhs = App.make_rotary_encoder_sensor(config[CONF_NAME], pin_a, pin_b)
+    encoder = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_PIN_RESET in config:
+        for pin_i in gpio_input_pin_expression(config[CONF_PIN_RESET]):
+            yield
+        add(encoder.set_reset_pin(pin_i))
+    if CONF_RESOLUTION in config:
+        resolution = RESOLUTIONS[config[CONF_RESOLUTION]]
+        add(encoder.set_resolution(resolution))
+    if CONF_MIN_VALUE in config:
+        add(encoder.set_min_value(config[CONF_MIN_VALUE]))
+    if CONF_MAX_VALUE in config:
+        add(encoder.set_max_value(config[CONF_MAX_VALUE]))
+
+    sensor.setup_sensor(encoder, config)
+    setup_component(encoder, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'

esphome/components/sensor/sds011.py

@@ -0,0 +1,70 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import (CONF_ID, CONF_NAME, CONF_PM_10_0, CONF_PM_2_5, CONF_RX_ONLY,
+                           CONF_UART_ID, CONF_UPDATE_INTERVAL)
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+SDS011Component = sensor.sensor_ns.class_('SDS011Component', uart.UARTDevice, Component)
+SDS011Sensor = sensor.sensor_ns.class_('SDS011Sensor', sensor.EmptySensor)
+
+
+def validate_sds011_rx_mode(value):
+    if CONF_UPDATE_INTERVAL in value and not value.get(CONF_RX_ONLY):
+        update_interval = value[CONF_UPDATE_INTERVAL]
+        if update_interval.total_minutes > 30:
+            raise vol.Invalid("Maximum update interval is 30min")
+    elif value.get(CONF_RX_ONLY) and CONF_UPDATE_INTERVAL in value:
+        # update_interval does not affect anything in rx-only mode, let's warn user about
+        # that
+        raise vol.Invalid("update_interval has no effect in rx_only mode. Please remove it.",
+                          path=['update_interval'])
+    return value
+
+
+SDS011_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SDS011Sensor),
+})
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SDS011Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+
+    vol.Optional(CONF_RX_ONLY): cv.boolean,
+
+    vol.Optional(CONF_PM_2_5): cv.nameable(SDS011_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_10_0): cv.nameable(SDS011_SENSOR_SCHEMA),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_minutes,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_PM_2_5, CONF_PM_10_0),
+                          validate_sds011_rx_mode)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_sds011(uart_)
+    sds011 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_UPDATE_INTERVAL in config:
+        add(sds011.set_update_interval_min(config.get(CONF_UPDATE_INTERVAL)))
+    if CONF_RX_ONLY in config:
+        add(sds011.set_rx_mode_only(config[CONF_RX_ONLY]))
+
+    if CONF_PM_2_5 in config:
+        conf = config[CONF_PM_2_5]
+        sensor.register_sensor(sds011.make_pm_2_5_sensor(conf[CONF_NAME]), conf)
+    if CONF_PM_10_0 in config:
+        conf = config[CONF_PM_10_0]
+        sensor.register_sensor(sds011.make_pm_10_0_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(sds011, config)
+
+
+BUILD_FLAGS = '-DUSE_SDS011'

esphome/components/sensor/sht3xd.py

@@ -1,15 +1,15 @@
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_MAKE_ID, CONF_NAME, \
-    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ID
-from esphomeyaml.helpers import App, Application, PollingComponent, setup_component, variable, \
-    Pvariable
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_NAME, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
-MakeSHT3XDSensor = Application.struct('MakeSHT3XDSensor')
 SHT3XDComponent = sensor.sensor_ns.class_('SHT3XDComponent', PollingComponent, i2c.I2CDevice)
 SHT3XDTemperatureSensor = sensor.sensor_ns.class_('SHT3XDTemperatureSensor',
                                                   sensor.EmptyPollingParentSensor)
@@ -18,7 +18,6 @@ SHT3XDHumiditySensor = sensor.sensor_ns.class_('SHT3XDHumiditySensor',
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(SHT3XDComponent),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeSHT3XDSensor),
     vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(SHT3XDTemperatureSensor),
     })),
@@ -35,20 +34,11 @@ def to_code(config):
                                  config[CONF_HUMIDITY][CONF_NAME],
                                  config[CONF_ADDRESS],
                                  config.get(CONF_UPDATE_INTERVAL))
-    make = variable(config[CONF_MAKE_ID], rhs)
-    sht3xd = make.Psht3xd
-    Pvariable(config[CONF_ID], sht3xd)
+    sht3xd = Pvariable(config[CONF_ID], rhs)
 
-    sensor.setup_sensor(sht3xd.Pget_temperature_sensor(), make.Pmqtt_temperature,
-                        config[CONF_TEMPERATURE])
-    sensor.setup_sensor(sht3xd.Pget_humidity_sensor(), make.Pmqtt_humidity,
-                        config[CONF_HUMIDITY])
+    sensor.setup_sensor(sht3xd.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(sht3xd.Pget_humidity_sensor(), config[CONF_HUMIDITY])
     setup_component(sht3xd, config)
 
 
 BUILD_FLAGS = '-DUSE_SHT3XD'
-
-
-def to_hass_config(data, config):
-    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
-            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]

esphome/components/sensor/tcs34725.py

@@ -1,11 +1,13 @@
 # coding=utf-8
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_COLOR_TEMPERATURE, CONF_GAIN, CONF_ID, \
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_COLOR_TEMPERATURE, CONF_GAIN, CONF_ID, \
     CONF_ILLUMINANCE, CONF_INTEGRATION_TIME, CONF_NAME, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, PollingComponent, Pvariable, add, setup_component
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
 
 DEPENDENCIES = ['i2c']
 
@@ -62,8 +64,8 @@ PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_COLOR_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
         cv.GenerateID(): cv.declare_variable_id(TCS35725ColorTemperatureSensor),
     })),
-    vol.Optional(CONF_INTEGRATION_TIME): cv.one_of(*TCS34725_INTEGRATION_TIMES),
-    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS)),
+    vol.Optional(CONF_INTEGRATION_TIME): cv.one_of(*TCS34725_INTEGRATION_TIMES, lower=True),
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS), upper=True),
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
 
@@ -100,12 +102,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_TCS34725'
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL, CONF_CLEAR_CHANNEL,
-                CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/template.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, float_, optional
+
+TemplateSensor = sensor.sensor_ns.class_('TemplateSensor', sensor.PollingSensorComponent)
+SensorPublishAction = sensor.sensor_ns.class_('SensorPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    template = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(template, config)
+    setup_component(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(float_)):
+            yield
+        add(template.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SENSOR'
+
+CONF_SENSOR_TEMPLATE_PUBLISH = 'sensor.template.publish'
+SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(sensor.Sensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.float_),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SENSOR_TEMPLATE_PUBLISH, SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_publish_action(template_arg)
+    type = SensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, float_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/sensor/total_daily_energy.py

@@ -1,19 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml.components import sensor, time
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_TIME_ID
-from esphomeyaml.helpers import App, Application, Component, get_variable, setup_component, variable
+from esphome.components import sensor, time
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_TIME_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 DEPENDENCIES = ['time']
 
 CONF_POWER_ID = 'power_id'
-MakeTotalDailyEnergySensor = Application.struct('MakeTotalDailyEnergySensor')
 TotalDailyEnergy = sensor.sensor_ns.class_('TotalDailyEnergy', sensor.Sensor, Component)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(TotalDailyEnergy),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTotalDailyEnergySensor),
     cv.GenerateID(CONF_TIME_ID): cv.use_variable_id(time.RealTimeClockComponent),
     vol.Required(CONF_POWER_ID): cv.use_variable_id(sensor.Sensor),
 }).extend(cv.COMPONENT_SCHEMA.schema))
@@ -25,15 +25,10 @@ def to_code(config):
     for sens in get_variable(config[CONF_POWER_ID]):
         yield
     rhs = App.make_total_daily_energy_sensor(config[CONF_NAME], time_, sens)
-    make = variable(config[CONF_MAKE_ID], rhs)
-    total_energy = make.Ptotal_energy
+    total_energy = Pvariable(config[CONF_ID], rhs)
 
-    sensor.setup_sensor(total_energy, make.Pmqtt, config)
+    sensor.setup_sensor(total_energy, config)
     setup_component(total_energy, config)
 
 
 BUILD_FLAGS = '-DUSE_TOTAL_DAILY_ENERGY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/tsl2561.py

@@ -1,10 +1,12 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import sensor, i2c
-from esphomeyaml.const import CONF_ADDRESS, CONF_GAIN, CONF_INTEGRATION_TIME, CONF_MAKE_ID, \
-    CONF_NAME, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, Application, add, variable, setup_component
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_GAIN, CONF_ID, CONF_INTEGRATION_TIME, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 DEPENDENCIES = ['i2c']
 
@@ -31,16 +33,14 @@ def validate_integration_time(value):
     return value
 
 
-MakeTSL2561Sensor = Application.struct('MakeTSL2561Sensor')
 TSL2561Sensor = sensor.sensor_ns.class_('TSL2561Sensor', sensor.PollingSensorComponent,
                                         i2c.I2CDevice)
 
 PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(TSL2561Sensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTSL2561Sensor),
     vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
     vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
-    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*GAINS)),
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, upper=True),
     vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
     vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
 }).extend(cv.COMPONENT_SCHEMA.schema))
@@ -49,8 +49,7 @@ PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
 def to_code(config):
     rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
                                   config.get(CONF_UPDATE_INTERVAL))
-    make_tsl = variable(config[CONF_MAKE_ID], rhs)
-    tsl2561 = make_tsl.Ptsl2561
+    tsl2561 = Pvariable(config[CONF_ID], rhs)
 
     if CONF_INTEGRATION_TIME in config:
         add(tsl2561.set_integration_time(INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
@@ -59,12 +58,8 @@ def to_code(config):
     if CONF_IS_CS_PACKAGE in config:
         add(tsl2561.set_is_cs_package(config[CONF_IS_CS_PACKAGE]))
 
-    sensor.setup_sensor(tsl2561, make_tsl.Pmqtt, config)
+    sensor.setup_sensor(tsl2561, config)
     setup_component(tsl2561, config)
 
 
 BUILD_FLAGS = '-DUSE_TSL2561'
-
-
-def to_hass_config(data, config):
-    return sensor.core_to_hass_config(data, config)

esphome/components/sensor/ultrasonic.py

@@ -0,0 +1,54 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, CONF_TRIGGER_PIN, \
+    CONF_UPDATE_INTERVAL, CONF_TIMEOUT
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App
+
+CONF_PULSE_TIME = 'pulse_time'
+
+UltrasonicSensorComponent = sensor.sensor_ns.class_('UltrasonicSensorComponent',
+                                                    sensor.PollingSensorComponent)
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UltrasonicSensorComponent),
+    vol.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
+
+    vol.Optional(CONF_TIMEOUT): cv.distance,
+    vol.Optional(CONF_PULSE_TIME): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+
+    vol.Optional('timeout_meter'): cv.invalid("The timeout_meter option has been renamed "
+                                              "to 'timeout'."),
+    vol.Optional('timeout_time'): cv.invalid("The timeout_time option has been removed. Please "
+                                             "use 'timeout'."),
+}))
+
+
+def to_code(config):
+    for trigger in gpio_output_pin_expression(config[CONF_TRIGGER_PIN]):
+        yield
+    for echo in gpio_input_pin_expression(config[CONF_ECHO_PIN]):
+        yield
+    rhs = App.make_ultrasonic_sensor(config[CONF_NAME], trigger, echo,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    ultrasonic = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_TIMEOUT in config:
+        add(ultrasonic.set_timeout_us(config[CONF_TIMEOUT] / (0.000343 / 2)))
+
+    if CONF_PULSE_TIME in config:
+        add(ultrasonic.set_pulse_time_us(config[CONF_PULSE_TIME]))
+
+    sensor.setup_sensor(ultrasonic, config)
+    setup_component(ultrasonic, config)
+
+
+BUILD_FLAGS = '-DUSE_ULTRASONIC_SENSOR'

esphome/components/sensor/uptime.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+UptimeSensor = sensor.sensor_ns.class_('UptimeSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UptimeSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_uptime_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    uptime = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(uptime, config)
+    setup_component(uptime, config)
+
+
+BUILD_FLAGS = '-DUSE_UPTIME_SENSOR'

esphome/components/sensor/wifi_signal.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+WiFiSignalSensor = sensor.sensor_ns.class_('WiFiSignalSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(WiFiSignalSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_wifi_signal_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    wifi = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(wifi, config)
+    setup_component(wifi, config)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_SIGNAL_SENSOR'

esphome/components/sensor/xiaomi_miflora.py

@@ -1,12 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml.components import esp32_ble_tracker, sensor
-from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
     make_address_array
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BATTERY_LEVEL, CONF_CONDUCTIVITY, CONF_ID, CONF_ILLUMINANCE, \
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_CONDUCTIVITY, CONF_ID, CONF_ILLUMINANCE, \
     CONF_MAC_ADDRESS, CONF_MOISTURE, CONF_NAME, CONF_TEMPERATURE
-from esphomeyaml.helpers import Pvariable, get_variable
+from esphome.cpp_generator import Pvariable, get_variable
 
 DEPENDENCIES = ['esp32_ble_tracker']
 
@@ -42,12 +42,3 @@ def to_code(config):
     if CONF_BATTERY_LEVEL in config:
         conf = config[CONF_BATTERY_LEVEL]
         sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_TEMPERATURE, CONF_MOISTURE, CONF_ILLUMINANCE, CONF_CONDUCTIVITY,
-                CONF_BATTERY_LEVEL):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/sensor/xiaomi_mijia.py

@@ -1,12 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml.components import esp32_ble_tracker, sensor
-from esphomeyaml.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
     make_address_array
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \
     CONF_NAME, CONF_TEMPERATURE
-from esphomeyaml.helpers import Pvariable, get_variable
+from esphome.cpp_generator import Pvariable, get_variable
 
 DEPENDENCIES = ['esp32_ble_tracker']
 
@@ -34,11 +34,3 @@ def to_code(config):
     if CONF_BATTERY_LEVEL in config:
         conf = config[CONF_BATTERY_LEVEL]
         sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)
-
-
-def to_hass_config(data, config):
-    ret = []
-    for key in (CONF_TEMPERATURE, CONF_HUMIDITY, CONF_BATTERY_LEVEL):
-        if key in config:
-            ret.append(sensor.core_to_hass_config(data, config[key]))
-    return ret

esphome/components/servo.py

@@ -0,0 +1,59 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components.output import FloatOutput
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_IDLE_LEVEL, CONF_MAX_LEVEL, CONF_MIN_LEVEL, CONF_OUTPUT, \
+    CONF_LEVEL
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns, Action, float_
+
+Servo = esphome_ns.class_('Servo', Component)
+ServoWriteAction = esphome_ns.class_('ServoWriteAction', Action)
+
+MULTI_CONF = True
+
+CONFIG_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.declare_variable_id(Servo),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(FloatOutput),
+    vol.Optional(CONF_MIN_LEVEL, default='3%'): cv.percentage,
+    vol.Optional(CONF_IDLE_LEVEL, default='7.5%'): cv.percentage,
+    vol.Optional(CONF_MAX_LEVEL, default='12%'): cv.percentage,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for out in get_variable(config[CONF_OUTPUT]):
+        yield
+
+    rhs = App.register_component(Servo.new(out))
+    servo = Pvariable(config[CONF_ID], rhs)
+
+    add(servo.set_min_level(config[CONF_MIN_LEVEL]))
+    add(servo.set_idle_level(config[CONF_IDLE_LEVEL]))
+    add(servo.set_max_level(config[CONF_MAX_LEVEL]))
+
+    setup_component(servo, config)
+
+
+BUILD_FLAGS = '-DUSE_SERVO'
+
+CONF_SERVO_WRITE = 'servo.write'
+SERVO_WRITE_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(Servo),
+    vol.Required(CONF_LEVEL): cv.templatable(cv.possibly_negative_percentage),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SERVO_WRITE, SERVO_WRITE_ACTION_SCHEMA)
+def servo_write_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = ServoWriteAction.new(template_arg, var)
+    type = ServoWriteAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_LEVEL], args, float_):
+        yield None
+    add(action.set_value(template_))
+    yield action

esphome/components/spi.py

@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+SPIComponent = esphome_ns.class_('SPIComponent', Component)
+SPIDevice = esphome_ns.class_('SPIDevice')
+MULTI_CONF = True
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(SPIComponent),
+    vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema,
+    vol.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema,
+}), cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN))
+
+
+def to_code(config):
+    for clk in gpio_output_pin_expression(config[CONF_CLK_PIN]):
+        yield
+    rhs = App.init_spi(clk)
+    spi = Pvariable(config[CONF_ID], rhs)
+    if CONF_MISO_PIN in config:
+        for miso in gpio_input_pin_expression(config[CONF_MISO_PIN]):
+            yield
+        add(spi.set_miso(miso))
+    if CONF_MOSI_PIN in config:
+        for mosi in gpio_input_pin_expression(config[CONF_MOSI_PIN]):
+            yield
+        add(spi.set_mosi(mosi))
+
+    setup_component(spi, config)
+
+
+BUILD_FLAGS = '-DUSE_SPI'

esphome/components/status_led.py

@@ -1,13 +1,14 @@
 import voluptuous as vol
 
-from esphomeyaml import config_validation as cv, pins
-from esphomeyaml.const import CONF_ID, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, esphomelib_ns, gpio_output_pin_expression, \
-    setup_component, Component
+from esphome import config_validation as cv, pins
+from esphome.const import CONF_ID, CONF_PIN
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component, esphome_ns
 
-StatusLEDComponent = esphomelib_ns.class_('StatusLEDComponent', Component)
+StatusLEDComponent = esphome_ns.class_('StatusLEDComponent', Component)
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(StatusLEDComponent),
     vol.Optional(CONF_PIN): pins.gpio_output_pin_schema,
 }).extend(cv.COMPONENT_SCHEMA.schema)

esphome/components/stepper/__init__.py

@@ -1,18 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import ACTION_REGISTRY
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ACCELERATION, CONF_DECELERATION, CONF_ID, CONF_MAX_SPEED, \
+from esphome.automation import ACTION_REGISTRY
+import esphome.config_validation as cv
+from esphome.const import CONF_ACCELERATION, CONF_DECELERATION, CONF_ID, CONF_MAX_SPEED, \
     CONF_POSITION, CONF_TARGET
-from esphomeyaml.helpers import Pvariable, TemplateArguments, add, add_job, esphomelib_ns, \
-    get_variable, int32, templatable, Action
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, templatable
+from esphome.cpp_types import Action, esphome_ns, int32
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
 # pylint: disable=invalid-name
-stepper_ns = esphomelib_ns.namespace('stepper')
+stepper_ns = esphome_ns.namespace('stepper')
 Stepper = stepper_ns.class_('Stepper')
 
 SetTargetAction = stepper_ns.class_('SetTargetAction', Action)
@@ -59,7 +60,7 @@ def validate_speed(value):
     return value
 
 
-STEPPER_SCHEMA = vol.Schema({
+STEPPER_SCHEMA = cv.Schema({
     vol.Required(CONF_MAX_SPEED): validate_speed,
     vol.Optional(CONF_ACCELERATION): validate_acceleration,
     vol.Optional(CONF_DECELERATION): validate_acceleration,
@@ -78,48 +79,46 @@ def setup_stepper_core_(stepper_var, config):
 
 
 def setup_stepper(stepper_var, config):
-    add_job(setup_stepper_core_, stepper_var, config)
+    CORE.add_job(setup_stepper_core_, stepper_var, config)
 
 
 BUILD_FLAGS = '-DUSE_STEPPER'
 
 CONF_STEPPER_SET_TARGET = 'stepper.set_target'
-STEPPER_SET_TARGET_ACTION_SCHEMA = vol.Schema({
+STEPPER_SET_TARGET_ACTION_SCHEMA = cv.Schema({
     vol.Required(CONF_ID): cv.use_variable_id(Stepper),
     vol.Required(CONF_TARGET): cv.templatable(cv.int_),
 })
 
 
 @ACTION_REGISTRY.register(CONF_STEPPER_SET_TARGET, STEPPER_SET_TARGET_ACTION_SCHEMA)
-def stepper_set_target_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def stepper_set_target_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_set_target_action(template_arg)
-    type = SetTargetAction.template(arg_type)
+    type = SetTargetAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
-    for template_ in templatable(config[CONF_TARGET], arg_type, int32):
+    for template_ in templatable(config[CONF_TARGET], args, int32):
         yield None
     add(action.set_target(template_))
     yield action
 
 
 CONF_STEPPER_REPORT_POSITION = 'stepper.report_position'
-STEPPER_REPORT_POSITION_ACTION_SCHEMA = vol.Schema({
+STEPPER_REPORT_POSITION_ACTION_SCHEMA = cv.Schema({
     vol.Required(CONF_ID): cv.use_variable_id(Stepper),
     vol.Required(CONF_POSITION): cv.templatable(cv.int_),
 })
 
 
 @ACTION_REGISTRY.register(CONF_STEPPER_REPORT_POSITION, STEPPER_REPORT_POSITION_ACTION_SCHEMA)
-def stepper_report_position_to_code(config, action_id, arg_type):
-    template_arg = TemplateArguments(arg_type)
+def stepper_report_position_to_code(config, action_id, template_arg, args):
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_report_position_action(template_arg)
-    type = ReportPositionAction.template(arg_type)
+    type = ReportPositionAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
-    for template_ in templatable(config[CONF_POSITION], arg_type, int32):
+    for template_ in templatable(config[CONF_POSITION], args, int32):
         yield None
-    add(action.set_target(template_))
+    add(action.set_position(template_))
     yield action

esphome/components/stepper/a4988.py

@@ -1,11 +1,12 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components import stepper
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN
-from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression, setup_component, \
-    Component
+from esphome import pins
+from esphome.components import stepper
+import esphome.config_validation as cv
+from esphome.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
 
 A4988 = stepper.stepper_ns.class_('A4988', stepper.Stepper, Component)
 

esphome/components/stepper/uln2003.py

@@ -0,0 +1,55 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import stepper
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_PIN_A, CONF_PIN_B, CONF_PIN_C, CONF_PIN_D, \
+    CONF_SLEEP_WHEN_DONE, CONF_STEP_MODE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+ULN2003StepMode = stepper.stepper_ns.enum('ULN2003StepMode')
+
+STEP_MODES = {
+    'FULL_STEP': ULN2003StepMode.ULN2003_STEP_MODE_FULL_STEP,
+    'HALF_STEP': ULN2003StepMode.ULN2003_STEP_MODE_HALF_STEP,
+    'WAVE_DRIVE': ULN2003StepMode.ULN2003_STEP_MODE_WAVE_DRIVE,
+}
+
+ULN2003 = stepper.stepper_ns.class_('ULN2003', stepper.Stepper, Component)
+
+PLATFORM_SCHEMA = stepper.STEPPER_PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ID): cv.declare_variable_id(ULN2003),
+    vol.Required(CONF_PIN_A): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_B): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_C): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_D): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_SLEEP_WHEN_DONE): cv.boolean,
+    vol.Optional(CONF_STEP_MODE): cv.one_of(*STEP_MODES, upper=True, space='_')
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin_a in gpio_output_pin_expression(config[CONF_PIN_A]):
+        yield
+    for pin_b in gpio_output_pin_expression(config[CONF_PIN_B]):
+        yield
+    for pin_c in gpio_output_pin_expression(config[CONF_PIN_C]):
+        yield
+    for pin_d in gpio_output_pin_expression(config[CONF_PIN_D]):
+        yield
+    rhs = App.make_uln2003(pin_a, pin_b, pin_c, pin_d)
+    uln = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_SLEEP_WHEN_DONE in config:
+        add(uln.set_sleep_when_done(config[CONF_SLEEP_WHEN_DONE]))
+
+    if CONF_STEP_MODE in config:
+        add(uln.set_step_mode(STEP_MODES[config[CONF_STEP_MODE]]))
+
+    stepper.setup_stepper(uln, config)
+    setup_component(uln, config)
+
+
+BUILD_FLAGS = '-DUSE_ULN2003'

esphome/components/substitutions.py

@@ -0,0 +1,136 @@
+import logging
+import re
+
+import voluptuous as vol
+
+from esphome import core
+import esphome.config_validation as cv
+from esphome.core import EsphomeError
+from esphome.py_compat import string_types
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_SUBSTITUTIONS = 'substitutions'
+
+VALID_SUBSTITUTIONS_CHARACTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' \
+                                 '0123456789_'
+
+
+def validate_substitution_key(value):
+    value = cv.string(value)
+    if not value:
+        raise vol.Invalid("Substitution key must not be empty")
+    if value[0] == '$':
+        value = value[1:]
+    if value[0].isdigit():
+        raise vol.Invalid("First character in substitutions cannot be a digit.")
+    for char in value:
+        if char not in VALID_SUBSTITUTIONS_CHARACTERS:
+            raise vol.Invalid(
+                u"Substitution must only consist of upper/lowercase characters, the underscore "
+                u"and numbers. The character '{}' cannot be used".format(char))
+    return value
+
+
+CONFIG_SCHEMA = cv.Schema({
+    validate_substitution_key: cv.string_strict,
+})
+
+
+def to_code(config):
+    pass
+
+
+VARIABLE_PROG = re.compile('\\$([{0}]+|\\{{[{0}]*\\}})'.format(VALID_SUBSTITUTIONS_CHARACTERS))
+
+
+def _expand_substitutions(substitutions, value, path):
+    if u'$' not in value:
+        return value
+
+    orig_value = value
+
+    i = 0
+    while True:
+        m = VARIABLE_PROG.search(value, i)
+        if not m:
+            # Nothing more to match. Done
+            break
+
+        i, j = m.span(0)
+        name = m.group(1)
+        if name.startswith(u'{') and name.endswith(u'}'):
+            name = name[1:-1]
+        if name not in substitutions:
+            _LOGGER.warning(u"Found '%s' (see %s) which looks like a substitution, but '%s' was "
+                            u"not declared", orig_value, u'->'.join(str(x) for x in path), name)
+            i = j
+            continue
+
+        sub = substitutions[name]
+        tail = value[j:]
+        value = value[:i] + sub
+        i = len(value)
+        value += tail
+    return value
+
+
+def _substitute_item(substitutions, item, path):
+    if isinstance(item, list):
+        for i, it in enumerate(item):
+            sub = _substitute_item(substitutions, it, path + [i])
+            if sub is not None:
+                item[i] = sub
+    elif isinstance(item, dict):
+        replace_keys = []
+        for k, v in item.items():
+            if path or k != CONF_SUBSTITUTIONS:
+                sub = _substitute_item(substitutions, k, path + [k])
+                if sub is not None:
+                    replace_keys.append((k, sub))
+            sub = _substitute_item(substitutions, v, path + [k])
+            if sub is not None:
+                item[k] = sub
+        for old, new in replace_keys:
+            item[new] = item[old]
+            del item[old]
+    elif isinstance(item, string_types):
+        sub = _expand_substitutions(substitutions, item, path)
+        if sub != item:
+            return sub
+    elif isinstance(item, core.Lambda):
+        sub = _expand_substitutions(substitutions, item.value, path)
+        if sub != item:
+            item.value = sub
+    return None
+
+
+def do_substitution_pass(config):
+    if CONF_SUBSTITUTIONS not in config:
+        return config
+
+    substitutions = config[CONF_SUBSTITUTIONS]
+    if not isinstance(substitutions, dict):
+        raise EsphomeError(u"Substitutions must be a key to value mapping, got {}"
+                           u"".format(type(substitutions)))
+
+    key = ''
+    try:
+        replace_keys = []
+        for key, value in substitutions.items():
+            sub = validate_substitution_key(key)
+            if sub != key:
+                replace_keys.append((key, sub))
+            substitutions[key] = cv.string_strict(value)
+        for old, new in replace_keys:
+            substitutions[new] = substitutions[old]
+            del substitutions[old]
+    except vol.Invalid as err:
+        err.path.append(key)
+
+        raise EsphomeError(u"Error while parsing substitutions: {}".format(err))
+
+    config[CONF_SUBSTITUTIONS] = substitutions
+    _substitute_item(substitutions, config, [])
+
+    return config

esphome/components/switch/__init__.py

@@ -0,0 +1,151 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY, CONDITION_REGISTRY, Condition, maybe_simple_id
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_INVERTED, CONF_MQTT_ID, \
+    CONF_ON_TURN_OFF, CONF_ON_TURN_ON, CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_types import Action, App, Nameable, Trigger, esphome_ns
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+switch_ns = esphome_ns.namespace('switch_')
+Switch = switch_ns.class_('Switch', Nameable)
+SwitchPtr = Switch.operator('ptr')
+MQTTSwitchComponent = switch_ns.class_('MQTTSwitchComponent', mqtt.MQTTComponent)
+
+ToggleAction = switch_ns.class_('ToggleAction', Action)
+TurnOffAction = switch_ns.class_('TurnOffAction', Action)
+TurnOnAction = switch_ns.class_('TurnOnAction', Action)
+
+SwitchCondition = switch_ns.class_('SwitchCondition', Condition)
+SwitchTurnOnTrigger = switch_ns.class_('SwitchTurnOnTrigger', Trigger.template())
+SwitchTurnOffTrigger = switch_ns.class_('SwitchTurnOffTrigger', Trigger.template())
+
+SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSwitchComponent),
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+    vol.Optional(CONF_ON_TURN_ON): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SwitchTurnOnTrigger),
+    }),
+    vol.Optional(CONF_ON_TURN_OFF): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SwitchTurnOffTrigger),
+    }),
+})
+
+SWITCH_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SWITCH_SCHEMA.schema)
+
+
+def setup_switch_core_(switch_var, config):
+    if CONF_INTERNAL in config:
+        add(switch_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_ICON in config:
+        add(switch_var.set_icon(config[CONF_ICON]))
+    if CONF_INVERTED in config:
+        add(switch_var.set_inverted(config[CONF_INVERTED]))
+    for conf in config.get(CONF_ON_TURN_ON, []):
+        rhs = switch_var.make_switch_turn_on_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+    for conf in config.get(CONF_ON_TURN_OFF, []):
+        rhs = switch_var.make_switch_turn_off_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [], conf)
+
+    setup_mqtt_component(switch_var.Pget_mqtt(), config)
+
+
+def setup_switch(switch_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        switch_obj = Pvariable(config[CONF_ID], switch_obj, has_side_effects=True)
+    CORE.add_job(setup_switch_core_, switch_obj, config)
+
+
+def register_switch(var, config):
+    switch_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_switch(switch_var))
+    CORE.add_job(setup_switch_core_, switch_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SWITCH'
+
+CONF_SWITCH_TOGGLE = 'switch.toggle'
+SWITCH_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TOGGLE, SWITCH_TOGGLE_ACTION_SCHEMA)
+def switch_toggle_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_toggle_action(template_arg)
+    type = ToggleAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_TURN_OFF = 'switch.turn_off'
+SWITCH_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TURN_OFF, SWITCH_TURN_OFF_ACTION_SCHEMA)
+def switch_turn_off_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_off_action(template_arg)
+    type = TurnOffAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_TURN_ON = 'switch.turn_on'
+SWITCH_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TURN_ON, SWITCH_TURN_ON_ACTION_SCHEMA)
+def switch_turn_on_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_turn_on_action(template_arg)
+    type = TurnOnAction.template(template_arg)
+    yield Pvariable(action_id, rhs, type=type)
+
+
+CONF_SWITCH_IS_ON = 'switch.is_on'
+SWITCH_IS_ON_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@CONDITION_REGISTRY.register(CONF_SWITCH_IS_ON, SWITCH_IS_ON_CONDITION_SCHEMA)
+def switch_is_on_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_is_on_condition(template_arg)
+    type = SwitchCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)
+
+
+CONF_SWITCH_IS_OFF = 'switch.is_off'
+SWITCH_IS_OFF_CONDITION_SCHEMA = maybe_simple_id({
+    vol.Required(CONF_ID): cv.use_variable_id(Switch),
+})
+
+
+@CONDITION_REGISTRY.register(CONF_SWITCH_IS_OFF, SWITCH_IS_OFF_CONDITION_SCHEMA)
+def switch_is_off_to_code(config, condition_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_is_off_condition(template_arg)
+    type = SwitchCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/components/switch/custom.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SWITCHES
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomSwitchConstructor = switch.switch_ns.class_('CustomSwitchConstructor')
+
+PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomSwitchConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_SWITCHES):
+        cv.ensure_list(switch.SWITCH_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(switch.Switch),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(switch.SwitchPtr)):
+        yield
+
+    rhs = CustomSwitchConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_SWITCHES]):
+        rhs = custom.Pget_switch(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        switch.register_switch(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_SWITCH'

esphome/components/switch/gpio.py

@@ -0,0 +1,50 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERLOCK, CONF_NAME, CONF_PIN, CONF_RESTORE_MODE
+from esphome.cpp_generator import Pvariable, add, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+GPIOSwitch = switch.switch_ns.class_('GPIOSwitch', switch.Switch, Component)
+GPIOSwitchRestoreMode = switch.switch_ns.enum('GPIOSwitchRestoreMode')
+
+RESTORE_MODES = {
+    'RESTORE_DEFAULT_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_OFF,
+    'RESTORE_DEFAULT_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_ON,
+    'ALWAYS_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_OFF,
+    'ALWAYS_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_ON,
+}
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(GPIOSwitch),
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_RESTORE_MODE): cv.one_of(*RESTORE_MODES, upper=True, space='_'),
+    vol.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_variable_id(switch.Switch)),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_gpio_switch(config[CONF_NAME], pin)
+    gpio = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_RESTORE_MODE in config:
+        add(gpio.set_restore_mode(RESTORE_MODES[config[CONF_RESTORE_MODE]]))
+
+    if CONF_INTERLOCK in config:
+        interlock = []
+        for it in config[CONF_INTERLOCK]:
+            for lock in get_variable(it):
+                yield
+            interlock.append(lock)
+        add(gpio.set_interlock(interlock))
+
+    switch.setup_switch(gpio, config)
+    setup_component(gpio, config)
+
+
+BUILD_FLAGS = '-DUSE_GPIO_SWITCH'

esphome/components/switch/output.py

@@ -0,0 +1,28 @@
+import voluptuous as vol
+
+from esphome.components import output, switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_OUTPUT
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+OutputSwitch = switch.switch_ns.class_('OutputSwitch', switch.Switch, Component)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(OutputSwitch),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for output_ in get_variable(config[CONF_OUTPUT]):
+        yield
+    rhs = App.make_output_switch(config[CONF_NAME], output_)
+    switch_ = Pvariable(config[CONF_ID], rhs)
+
+    switch.setup_switch(switch_, config)
+    setup_component(switch, config)
+
+
+BUILD_FLAGS = '-DUSE_OUTPUT_SWITCH'

esphome/components/switch/remote_transmitter.py

@@ -1,33 +1,37 @@
 import voluptuous as vol
 
-from esphomeyaml.components import switch
-from esphomeyaml.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
+from esphome.components import switch
+from esphome.components.remote_transmitter import RC_SWITCH_RAW_SCHEMA, \
     RC_SWITCH_TYPE_A_SCHEMA, RC_SWITCH_TYPE_B_SCHEMA, RC_SWITCH_TYPE_C_SCHEMA, \
     RC_SWITCH_TYPE_D_SCHEMA, RemoteTransmitterComponent, binary_code, build_rc_switch_protocol, \
     remote_ns
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_CHANNEL, CONF_CODE, \
-    CONF_COMMAND, CONF_DATA, CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_INVERTED, CONF_LG, \
-    CONF_NAME, CONF_NBITS, CONF_NEC, CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, CONF_RC_SWITCH_RAW, \
-    CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B, CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, \
-    CONF_REPEAT, CONF_SAMSUNG, CONF_SONY, CONF_STATE, CONF_TIMES, \
-    CONF_WAIT_TIME
-from esphomeyaml.helpers import ArrayInitializer, Pvariable, add, get_variable
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_CHANNEL, CONF_CODE, \
+    CONF_COMMAND, CONF_DATA, CONF_DEVICE, CONF_FAMILY, CONF_GROUP, CONF_ID, CONF_INVERTED, \
+    CONF_JVC, \
+    CONF_LG, CONF_NAME, CONF_NBITS, CONF_NEC, CONF_PANASONIC, CONF_PROTOCOL, CONF_RAW, \
+    CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B, CONF_RC_SWITCH_TYPE_C, \
+    CONF_RC_SWITCH_TYPE_D, CONF_REPEAT, CONF_SAMSUNG, CONF_SONY, CONF_STATE, CONF_TIMES, \
+    CONF_WAIT_TIME, CONF_RC5
+from esphome.cpp_generator import Pvariable, add, get_variable, progmem_array
+from esphome.cpp_types import int32
 
 DEPENDENCIES = ['remote_transmitter']
 
-REMOTE_KEYS = [CONF_NEC, CONF_LG, CONF_SAMSUNG, CONF_SONY, CONF_PANASONIC, CONF_RAW,
+REMOTE_KEYS = [CONF_JVC, CONF_NEC, CONF_LG, CONF_SAMSUNG, CONF_SONY, CONF_PANASONIC, CONF_RAW,
                CONF_RC_SWITCH_RAW, CONF_RC_SWITCH_TYPE_A, CONF_RC_SWITCH_TYPE_B,
-               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D]
+               CONF_RC_SWITCH_TYPE_C, CONF_RC_SWITCH_TYPE_D, CONF_RC5]
 
 CONF_REMOTE_TRANSMITTER_ID = 'remote_transmitter_id'
 CONF_TRANSMITTER_ID = 'transmitter_id'
 
 RemoteTransmitter = remote_ns.class_('RemoteTransmitter', switch.Switch)
+JVCTransmitter = remote_ns.class_('JVCTransmitter', RemoteTransmitter)
 LGTransmitter = remote_ns.class_('LGTransmitter', RemoteTransmitter)
 NECTransmitter = remote_ns.class_('NECTransmitter', RemoteTransmitter)
 PanasonicTransmitter = remote_ns.class_('PanasonicTransmitter', RemoteTransmitter)
 RawTransmitter = remote_ns.class_('RawTransmitter', RemoteTransmitter)
+RC5Transmitter = remote_ns.class_('RC5Transmitter', RemoteTransmitter)
 SamsungTransmitter = remote_ns.class_('SamsungTransmitter', RemoteTransmitter)
 SonyTransmitter = remote_ns.class_('SonyTransmitter', RemoteTransmitter)
 RCSwitchRawTransmitter = remote_ns.class_('RCSwitchRawTransmitter', RemoteTransmitter)
@@ -36,40 +40,55 @@ RCSwitchTypeBTransmitter = remote_ns.class_('RCSwitchTypeBTransmitter', RCSwitch
 RCSwitchTypeCTransmitter = remote_ns.class_('RCSwitchTypeCTransmitter', RCSwitchRawTransmitter)
 RCSwitchTypeDTransmitter = remote_ns.class_('RCSwitchTypeDTransmitter', RCSwitchRawTransmitter)
 
-validate_raw_data = [vol.Any(vol.Coerce(int), cv.time_period_microseconds)]
+
+def validate_raw(value):
+    if isinstance(value, dict):
+        return cv.Schema({
+            cv.GenerateID(): cv.declare_variable_id(int32),
+            vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
+            vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
+        })(value)
+    return validate_raw({
+        CONF_DATA: value
+    })
+
 
 PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(RemoteTransmitter),
-    vol.Optional(CONF_LG): vol.Schema({
+    vol.Optional(CONF_JVC): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), cv.one_of(28, 32)),
     }),
-    vol.Optional(CONF_NEC): vol.Schema({
+    vol.Optional(CONF_LG): cv.Schema({
+        vol.Required(CONF_DATA): cv.hex_uint32_t,
+        vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
+    }),
+    vol.Optional(CONF_NEC): cv.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
         vol.Required(CONF_COMMAND): cv.hex_uint16_t,
     }),
-    vol.Optional(CONF_SAMSUNG): vol.Schema({
+    vol.Optional(CONF_SAMSUNG): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
     }),
-    vol.Optional(CONF_SONY): vol.Schema({
+    vol.Optional(CONF_SONY): cv.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), cv.one_of(12, 15, 20)),
+        vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
     }),
-    vol.Optional(CONF_PANASONIC): vol.Schema({
+    vol.Optional(CONF_PANASONIC): cv.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
         vol.Required(CONF_COMMAND): cv.hex_uint32_t,
     }),
-    vol.Optional(CONF_RAW): vol.Any(validate_raw_data, vol.Schema({
-        vol.Required(CONF_DATA): validate_raw_data,
-        vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
-    })),
+    vol.Optional(CONF_RC5): cv.Schema({
+        vol.Required(CONF_ADDRESS): vol.All(cv.hex_int, vol.Range(min=0, max=0x1F)),
+        vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)),
+    }),
+    vol.Optional(CONF_RAW): validate_raw,
     vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA,
     vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA,
 
-    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, vol.Schema({
+    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, cv.Schema({
         vol.Required(CONF_TIMES): cv.positive_not_null_int,
         vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
     })),
@@ -83,48 +102,47 @@ def transmitter_base(full_config):
     name = full_config[CONF_NAME]
     key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
 
+    if key == CONF_JVC:
+        return JVCTransmitter.new(name, config[CONF_DATA])
     if key == CONF_LG:
         return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
-    elif key == CONF_NEC:
+    if key == CONF_NEC:
         return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    elif key == CONF_PANASONIC:
+    if key == CONF_PANASONIC:
         return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    elif key == CONF_SAMSUNG:
+    if key == CONF_SAMSUNG:
         return SamsungTransmitter.new(name, config[CONF_DATA])
-    elif key == CONF_SONY:
+    if key == CONF_SONY:
         return SonyTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
-    elif key == CONF_RAW:
-        if isinstance(config, dict):
-            data = config[CONF_DATA]
-            carrier_frequency = config.get(CONF_CARRIER_FREQUENCY)
-        else:
-            data = config
-            carrier_frequency = None
-        return RawTransmitter.new(name, ArrayInitializer(*data, multiline=False),
-                                  carrier_frequency)
-    elif key == CONF_RC_SWITCH_RAW:
+    if key == CONF_RC5:
+        return RC5Transmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
+    if key == CONF_RAW:
+        arr = progmem_array(config[CONF_ID], config[CONF_DATA])
+        return RawTransmitter.new(name, arr, len(config[CONF_DATA]),
+                                  config.get(CONF_CARRIER_FREQUENCY))
+    if key == CONF_RC_SWITCH_RAW:
         return RCSwitchRawTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                           binary_code(config[CONF_CODE]), len(config[CONF_CODE]))
-    elif key == CONF_RC_SWITCH_TYPE_A:
+    if key == CONF_RC_SWITCH_TYPE_A:
         return RCSwitchTypeATransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                             binary_code(config[CONF_GROUP]),
                                             binary_code(config[CONF_DEVICE]),
                                             config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_B:
+    if key == CONF_RC_SWITCH_TYPE_B:
         return RCSwitchTypeBTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                             config[CONF_ADDRESS], config[CONF_CHANNEL],
                                             config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_C:
+    if key == CONF_RC_SWITCH_TYPE_C:
         return RCSwitchTypeCTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                             ord(config[CONF_FAMILY][0]) - ord('a'),
                                             config[CONF_GROUP], config[CONF_DEVICE],
                                             config[CONF_STATE])
-    elif key == CONF_RC_SWITCH_TYPE_D:
+    if key == CONF_RC_SWITCH_TYPE_D:
         return RCSwitchTypeDTransmitter.new(name, build_rc_switch_protocol(config[CONF_PROTOCOL]),
                                             ord(config[CONF_GROUP][0]) - ord('a'),
                                             config[CONF_DEVICE], config[CONF_STATE])
-    else:
-        raise NotImplementedError("Unknown transmitter type {}".format(config))
+
+    raise NotImplementedError("Unknown transmitter type {}".format(config))
 
 
 def to_code(config):
@@ -146,7 +164,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_REMOTE_TRANSMITTER'
-
-
-def to_hass_config(data, config):
-    return switch.core_to_hass_config(data, config)

esphome/components/switch/restart.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+RestartSwitch = switch.switch_ns.class_('RestartSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RestartSwitch),
+    vol.Optional(CONF_INVERTED): cv.invalid("Restart switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    rhs = App.make_restart_switch(config[CONF_NAME])
+    restart = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(restart, config)
+
+
+BUILD_FLAGS = '-DUSE_RESTART_SWITCH'

esphome/components/switch/shutdown.py

@@ -0,0 +1,23 @@
+import voluptuous as vol
+
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+ShutdownSwitch = switch.switch_ns.class_('ShutdownSwitch', switch.Switch)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ShutdownSwitch),
+    vol.Optional(CONF_INVERTED): cv.invalid("Shutdown switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    rhs = App.make_shutdown_switch(config[CONF_NAME])
+    shutdown = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(shutdown, config)
+
+
+BUILD_FLAGS = '-DUSE_SHUTDOWN_SWITCH'

esphome/components/switch/template.py

@@ -0,0 +1,74 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import CONF_ASSUMED_STATE, CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_OPTIMISTIC, \
+    CONF_RESTORE_STATE, CONF_STATE, CONF_TURN_OFF_ACTION, CONF_TURN_ON_ACTION
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, Component, bool_, optional
+
+TemplateSwitch = switch.switch_ns.class_('TemplateSwitch', switch.Switch, Component)
+SwitchPublishAction = switch.switch_ns.class_('SwitchPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSwitch),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_OPTIMISTIC): cv.boolean,
+    vol.Optional(CONF_ASSUMED_STATE): cv.boolean,
+    vol.Optional(CONF_TURN_OFF_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_TURN_ON_ACTION): automation.validate_automation(single=True),
+    vol.Optional(CONF_RESTORE_STATE): cv.boolean,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_switch(config[CONF_NAME])
+    template = Pvariable(config[CONF_ID], rhs)
+
+    switch.setup_switch(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(bool_)):
+            yield
+        add(template.set_state_lambda(template_))
+    if CONF_TURN_OFF_ACTION in config:
+        automation.build_automations(template.get_turn_off_trigger(), [],
+                                     config[CONF_TURN_OFF_ACTION])
+    if CONF_TURN_ON_ACTION in config:
+        automation.build_automations(template.get_turn_on_trigger(), [],
+                                     config[CONF_TURN_ON_ACTION])
+    if CONF_OPTIMISTIC in config:
+        add(template.set_optimistic(config[CONF_OPTIMISTIC]))
+    if CONF_ASSUMED_STATE in config:
+        add(template.set_assumed_state(config[CONF_ASSUMED_STATE]))
+
+    if CONF_RESTORE_STATE in config:
+        add(template.set_restore_state(config[CONF_RESTORE_STATE]))
+
+    setup_component(template, config)
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SWITCH'
+
+CONF_SWITCH_TEMPLATE_PUBLISH = 'switch.template.publish'
+SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(switch.Switch),
+    vol.Required(CONF_STATE): cv.templatable(cv.boolean),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SWITCH_TEMPLATE_PUBLISH, SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def switch_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_switch_publish_action(template_arg)
+    type = SwitchPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, bool_):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/switch/uart.py

@@ -0,0 +1,46 @@
+import voluptuous as vol
+
+from esphome.components import switch, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_ID, CONF_INVERTED, CONF_NAME, CONF_UART_ID
+from esphome.core import HexInt
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_types import App
+from esphome.py_compat import text_type
+
+DEPENDENCIES = ['uart']
+
+UARTSwitch = switch.switch_ns.class_('UARTSwitch', switch.Switch, uart.UARTDevice)
+
+
+def validate_data(value):
+    if isinstance(value, text_type):
+        return value.encode('utf-8')
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise vol.Invalid("data must either be a string wrapped in quotes or a list of bytes")
+
+
+PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UARTSwitch),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_DATA): validate_data,
+    vol.Optional(CONF_INVERTED): cv.invalid("UART switches do not support inverted mode!"),
+}))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    data = config[CONF_DATA]
+    if isinstance(data, str):
+        data = [HexInt(ord(x)) for x in data]
+    rhs = App.make_uart_switch(uart_, config[CONF_NAME], data)
+    var = Pvariable(config[CONF_ID], rhs)
+    switch.setup_switch(var, config)
+
+
+BUILD_FLAGS = '-DUSE_UART_SWITCH'

esphome/components/text_sensor/__init__.py

@@ -0,0 +1,65 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ICON, CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_ON_VALUE, \
+    CONF_TRIGGER_ID
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Nameable, Trigger, esphome_ns, std_string, Action
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+# pylint: disable=invalid-name
+text_sensor_ns = esphome_ns.namespace('text_sensor')
+TextSensor = text_sensor_ns.class_('TextSensor', Nameable)
+TextSensorPtr = TextSensor.operator('ptr')
+MQTTTextSensor = text_sensor_ns.class_('MQTTTextSensor', mqtt.MQTTComponent)
+
+TextSensorStateTrigger = text_sensor_ns.class_('TextSensorStateTrigger',
+                                               Trigger.template(std_string))
+TextSensorPublishAction = text_sensor_ns.class_('TextSensorPublishAction', Action)
+
+TEXT_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTTextSensor),
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_ON_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(TextSensorStateTrigger),
+    }),
+})
+
+TEXT_SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(TEXT_SENSOR_SCHEMA.schema)
+
+
+def setup_text_sensor_core_(text_sensor_var, config):
+    if CONF_INTERNAL in config:
+        add(text_sensor_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_ICON in config:
+        add(text_sensor_var.set_icon(config[CONF_ICON]))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        rhs = text_sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automations(trigger, [(std_string, 'x')], conf)
+
+    setup_mqtt_component(text_sensor_var.get_mqtt(), config)
+
+
+def setup_text_sensor(text_sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        text_sensor_obj = Pvariable(config[CONF_ID], text_sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_text_sensor_core_, text_sensor_obj, config)
+
+
+def register_text_sensor(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_text_sensor(var))
+    CORE.add_job(setup_text_sensor_core_, var, config)
+
+
+BUILD_FLAGS = '-DUSE_TEXT_SENSOR'

esphome/components/text_sensor/custom.py

@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_TEXT_SENSORS
+from esphome.cpp_generator import add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomTextSensorConstructor = text_sensor.text_sensor_ns.class_('CustomTextSensorConstructor')
+
+PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomTextSensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_TEXT_SENSORS):
+        cv.ensure_list(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+            cv.GenerateID(): cv.declare_variable_id(text_sensor.TextSensor),
+        })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(text_sensor.TextSensorPtr)):
+        yield
+
+    rhs = CustomTextSensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_TEXT_SENSORS]):
+        rhs = custom.Pget_text_sensor(i)
+        add(rhs.set_name(conf[CONF_NAME]))
+        text_sensor.register_text_sensor(rhs, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_TEXT_SENSOR'

esphome/components/text_sensor/homeassistant.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['api']
+
+HomeassistantTextSensor = text_sensor.text_sensor_ns.class_('HomeassistantTextSensor',
+                                                            text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantTextSensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_text_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    sensor_ = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(sensor_, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_TEXT_SENSOR'

esphome/components/text_sensor/mqtt_subscribe.py

@@ -1,19 +1,19 @@
 import voluptuous as vol
 
-from esphomeyaml.components import text_sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
-from esphomeyaml.helpers import App, Application, add, variable, setup_component, Component
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
 
 DEPENDENCIES = ['mqtt']
 
-MakeMQTTSubscribeTextSensor = Application.struct('MakeMQTTSubscribeTextSensor')
 MQTTSubscribeTextSensor = text_sensor.text_sensor_ns.class_('MQTTSubscribeTextSensor',
                                                             text_sensor.TextSensor, Component)
 
 PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeTextSensor),
-    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMQTTSubscribeTextSensor),
     vol.Required(CONF_TOPIC): cv.subscribe_topic,
     vol.Optional(CONF_QOS): cv.mqtt_qos,
 }).extend(cv.COMPONENT_SCHEMA.schema))
@@ -21,18 +21,13 @@ PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
 
 def to_code(config):
     rhs = App.make_mqtt_subscribe_text_sensor(config[CONF_NAME], config[CONF_TOPIC])
-    make = variable(config[CONF_MAKE_ID], rhs)
-    sensor_ = make.Psensor
+    sensor_ = Pvariable(config[CONF_ID], rhs)
 
     if CONF_QOS in config:
         add(sensor_.set_qos(config[CONF_QOS]))
 
-    text_sensor.setup_text_sensor(sensor_, make.Pmqtt, config)
+    text_sensor.setup_text_sensor(sensor_, config)
     setup_component(sensor_, config)
 
 
 BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_TEXT_SENSOR'
-
-
-def to_hass_config(data, config):
-    return text_sensor.core_to_hass_config(data, config)

esphome/components/text_sensor/template.py

@@ -0,0 +1,55 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import text_sensor
+from esphome.components.text_sensor import TextSensorPublishAction
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent, optional, std_string
+
+TemplateTextSensor = text_sensor.text_sensor_ns.class_('TemplateTextSensor',
+                                                       text_sensor.TextSensor, PollingComponent)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateTextSensor),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_text_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    template = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(template, config)
+    setup_component(template, config)
+
+    if CONF_LAMBDA in config:
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(std_string)):
+            yield
+        add(template.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_TEXT_SENSOR'
+
+CONF_TEXT_SENSOR_TEMPLATE_PUBLISH = 'text_sensor.template.publish'
+TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(text_sensor.TextSensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.string_strict),
+})
+
+
+@ACTION_REGISTRY.register(CONF_TEXT_SENSOR_TEMPLATE_PUBLISH,
+                          TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def text_sensor_template_publish_to_code(config, action_id, template_arg, args):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_text_sensor_publish_action(template_arg)
+    type = TextSensorPublishAction.template(template_arg)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], args, std_string):
+        yield None
+    add(action.set_state(template_))
+    yield action

esphome/components/text_sensor/version.py

@@ -0,0 +1,23 @@
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+VersionTextSensor = text_sensor.text_sensor_ns.class_('VersionTextSensor',
+                                                      text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(VersionTextSensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_version_text_sensor(config[CONF_NAME])
+    sens = Pvariable(config[CONF_ID], rhs)
+    text_sensor.setup_text_sensor(sens, config)
+    setup_component(sens, config)
+
+
+BUILD_FLAGS = '-DUSE_VERSION_TEXT_SENSOR'

esphome/components/text_sensor/wifi_info.py

@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_BSSID, CONF_ID, CONF_IP_ADDRESS, CONF_NAME, CONF_SSID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['wifi']
+
+IPAddressWiFiInfo = text_sensor.text_sensor_ns.class_('IPAddressWiFiInfo',
+                                                      text_sensor.TextSensor, Component)
+SSIDWiFiInfo = text_sensor.text_sensor_ns.class_('SSIDWiFiInfo',
+                                                 text_sensor.TextSensor, Component)
+BSSIDWiFiInfo = text_sensor.text_sensor_ns.class_('BSSIDWiFiInfo',
+                                                  text_sensor.TextSensor, Component)
+
+PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_IP_ADDRESS): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(IPAddressWiFiInfo),
+    })),
+    vol.Optional(CONF_SSID): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SSIDWiFiInfo),
+    })),
+    vol.Optional(CONF_BSSID): cv.nameable(text_sensor.TEXT_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BSSIDWiFiInfo),
+    })),
+})
+
+
+def setup_conf(config, key, klass):
+    if key in config:
+        conf = config[key]
+        rhs = App.register_component(klass.new(conf[CONF_NAME]))
+        sensor_ = Pvariable(conf[CONF_ID], rhs)
+        text_sensor.register_text_sensor(sensor_, conf)
+
+
+def to_code(config):
+    setup_conf(config, CONF_IP_ADDRESS, IPAddressWiFiInfo)
+    setup_conf(config, CONF_SSID, SSIDWiFiInfo)
+    setup_conf(config, CONF_BSSID, BSSIDWiFiInfo)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_INFO_TEXT_SENSOR'

esphome/components/time/__init__.py

@@ -4,12 +4,14 @@ import math
 
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml import automation
-from esphomeyaml.const import CONF_CRON, CONF_DAYS_OF_MONTH, CONF_DAYS_OF_WEEK, CONF_HOURS, \
+from esphome import automation
+import esphome.config_validation as cv
+from esphome.const import CONF_CRON, CONF_DAYS_OF_MONTH, CONF_DAYS_OF_WEEK, CONF_HOURS, \
     CONF_MINUTES, CONF_MONTHS, CONF_ON_TIME, CONF_SECONDS, CONF_TIMEZONE, CONF_TRIGGER_ID
-from esphomeyaml.helpers import App, NoArg, Pvariable, add, add_job, esphomelib_ns, \
-    ArrayInitializer, Component, Trigger
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_types import App, Component, Trigger, esphome_ns
+from esphome.py_compat import string_types
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -17,10 +19,10 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-time_ns = esphomelib_ns.namespace('time')
+time_ns = esphome_ns.namespace('time')
 RealTimeClockComponent = time_ns.class_('RealTimeClockComponent', Component)
-CronTrigger = time_ns.class_('CronTrigger', Trigger.template(NoArg), Component)
-EsphomelibTime = time_ns.struct('EsphomelibTime')
+CronTrigger = time_ns.class_('CronTrigger', Trigger.template(), Component)
+ESPTime = time_ns.struct('ESPTime')
 
 
 def _tz_timedelta(td):
@@ -29,9 +31,9 @@ def _tz_timedelta(td):
     offset_second = int(abs(td.total_seconds())) % 60
     if offset_hour == 0 and offset_minute == 0 and offset_second == 0:
         return '0'
-    elif offset_minute == 0 and offset_second == 0:
+    if offset_minute == 0 and offset_second == 0:
         return '{}'.format(offset_hour)
-    elif offset_second == 0:
+    if offset_second == 0:
         return '{}:{}'.format(offset_hour, offset_minute)
     return '{}:{}:{}'.format(offset_hour, offset_minute, offset_second)
 
@@ -118,7 +120,7 @@ def detect_tz():
         import pytz
     except ImportError:
         raise vol.Invalid("No timezone specified and 'tzlocal' not installed. To automatically "
-                          "detect the timezone please install tzlocal (pip2 install tzlocal)")
+                          "detect the timezone please install tzlocal (pip install tzlocal)")
     try:
         tz = tzlocal.get_localzone()
     except pytz.exceptions.UnknownTimeZoneError:
@@ -130,7 +132,7 @@ def detect_tz():
 
 def _parse_cron_int(value, special_mapping, message):
     special_mapping = special_mapping or {}
-    if isinstance(value, (str, unicode)) and value in special_mapping:
+    if isinstance(value, string_types) and value in special_mapping:
         return special_mapping[value]
     try:
         return int(value)
@@ -139,7 +141,7 @@ def _parse_cron_int(value, special_mapping, message):
 
 
 def _parse_cron_part(part, min_value, max_value, special_mapping):
-    if part == '*' or part == '?':
+    if part in ('*', '?'):
         return set(x for x in range(min_value, max_value + 1))
     if '/' in part:
         data = part.split('/')
@@ -276,28 +278,28 @@ def setup_time_core_(time_var, config):
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
 
         seconds = conf.get(CONF_SECONDS, [x for x in range(0, 61)])
-        add(trigger.add_seconds(ArrayInitializer(*seconds, multiline=False)))
+        add(trigger.add_seconds(seconds))
 
         minutes = conf.get(CONF_MINUTES, [x for x in range(0, 60)])
-        add(trigger.add_minutes(ArrayInitializer(*minutes, multiline=False)))
+        add(trigger.add_minutes(minutes))
 
         hours = conf.get(CONF_HOURS, [x for x in range(0, 24)])
-        add(trigger.add_hours(ArrayInitializer(*hours, multiline=False)))
+        add(trigger.add_hours(hours))
 
         days_of_month = conf.get(CONF_DAYS_OF_MONTH, [x for x in range(1, 32)])
-        add(trigger.add_days_of_month(ArrayInitializer(*days_of_month, multiline=False)))
+        add(trigger.add_days_of_month(days_of_month))
 
         months = conf.get(CONF_MONTHS, [x for x in range(1, 13)])
-        add(trigger.add_months(ArrayInitializer(*months, multiline=False)))
+        add(trigger.add_months(months))
 
         days_of_week = conf.get(CONF_DAYS_OF_WEEK, [x for x in range(1, 8)])
-        add(trigger.add_days_of_week(ArrayInitializer(*days_of_week, multiline=False)))
+        add(trigger.add_days_of_week(days_of_week))
 
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
 
 def setup_time(time_var, config):
-    add_job(setup_time_core_, time_var, config)
+    CORE.add_job(setup_time_core_, time_var, config)
 
 
 BUILD_FLAGS = '-DUSE_TIME'

esphome/components/time/homeassistant.py

@@ -0,0 +1,24 @@
+from esphome.components import time as time_
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeAssistantTime = time_.time_ns.class_('HomeAssistantTime', time_.RealTimeClockComponent)
+
+PLATFORM_SCHEMA = time_.TIME_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeAssistantTime),
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_time_component()
+    ha_time = Pvariable(config[CONF_ID], rhs)
+    time_.setup_time(ha_time, config)
+    setup_component(ha_time, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_TIME'

esphome/components/time/sntp.py

@@ -1,16 +1,17 @@
 import voluptuous as vol
 
-import esphomeyaml.config_validation as cv
-from esphomeyaml.components import time as time_
-from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_SERVERS
-from esphomeyaml.helpers import App, Pvariable, add, setup_component
+from esphome.components import time as time_
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_SERVERS
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
 
 SNTPComponent = time_.time_ns.class_('SNTPComponent', time_.RealTimeClockComponent)
 
 PLATFORM_SCHEMA = time_.TIME_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(SNTPComponent),
-    vol.Optional(CONF_SERVERS): vol.All(cv.ensure_list, [cv.string], vol.Length(min=1, max=3)),
-    vol.Optional(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_SERVERS): vol.All(cv.ensure_list(cv.domain), vol.Length(min=1, max=3)),
 }).extend(cv.COMPONENT_SCHEMA.schema)
 
 

esphome/components/uart.py

@@ -0,0 +1,43 @@
+import voluptuous as vol
+
+from esphome import pins
+import esphome.config_validation as cv
+from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_RX_PIN, CONF_TX_PIN
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, esphome_ns
+
+UARTComponent = esphome_ns.class_('UARTComponent', Component)
+UARTDevice = esphome_ns.class_('UARTDevice')
+MULTI_CONF = True
+
+
+def validate_rx_pin(value):
+    value = pins.input_pin(value)
+    if CORE.is_esp8266 and value >= 16:
+        raise vol.Invalid("Pins GPIO16 and GPIO17 cannot be used as RX pins on ESP8266.")
+    return value
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(UARTComponent),
+    vol.Optional(CONF_TX_PIN): pins.output_pin,
+    vol.Optional(CONF_RX_PIN): validate_rx_pin,
+    vol.Required(CONF_BAUD_RATE): cv.positive_int,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN))
+
+
+def to_code(config):
+    rhs = App.init_uart(config[CONF_BAUD_RATE])
+    var = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_TX_PIN in config:
+        add(var.set_tx_pin(config[CONF_TX_PIN]))
+    if CONF_RX_PIN in config:
+        add(var.set_rx_pin(config[CONF_RX_PIN]))
+
+    setup_component(var, config)
+
+
+BUILD_FLAGS = '-DUSE_UART'

esphome/components/web_server.py

@@ -1,14 +1,15 @@
 import voluptuous as vol
 
-from esphomeyaml import core
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_CSS_URL, CONF_ID, CONF_JS_URL, CONF_PORT, ESP_PLATFORM_ESP32
-from esphomeyaml.helpers import App, Component, Pvariable, StoringController, add, esphomelib_ns, \
-    setup_component
+import esphome.config_validation as cv
+from esphome.const import CONF_CSS_URL, CONF_ID, CONF_JS_URL, CONF_PORT
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component, StoringController, esphome_ns
 
-WebServer = esphomelib_ns.class_('WebServer', Component, StoringController)
+WebServer = esphome_ns.class_('WebServer', Component, StoringController)
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     cv.GenerateID(): cv.declare_variable_id(WebServer),
     vol.Optional(CONF_PORT): cv.port,
     vol.Optional(CONF_CSS_URL): cv.string,
@@ -27,10 +28,12 @@ def to_code(config):
     setup_component(web_server, config)
 
 
-BUILD_FLAGS = '-DUSE_WEB_SERVER'
+REQUIRED_BUILD_FLAGS = '-DUSE_WEB_SERVER'
 
 
 def lib_deps(config):
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
-        return 'FS'
-    return ''
+    deps = []
+    if CORE.is_esp32:
+        deps.append('FS')
+    deps.append('ESP Async WebServer@1.1.1')
+    return deps

esphome/components/wifi.py

@@ -0,0 +1,203 @@
+import voluptuous as vol
+
+from esphome.automation import CONDITION_REGISTRY, Condition
+import esphome.config_validation as cv
+from esphome.const import CONF_AP, CONF_BSSID, CONF_CHANNEL, CONF_DNS1, CONF_DNS2, CONF_DOMAIN, \
+    CONF_FAST_CONNECT, CONF_GATEWAY, CONF_HIDDEN, CONF_ID, CONF_MANUAL_IP, CONF_NETWORKS, \
+    CONF_PASSWORD, CONF_POWER_SAVE_MODE, CONF_REBOOT_TIMEOUT, CONF_SSID, CONF_STATIC_IP, \
+    CONF_SUBNET, CONF_USE_ADDRESS
+from esphome.core import CORE, HexInt
+from esphome.cpp_generator import Pvariable, StructInitializer, add, variable
+from esphome.cpp_types import App, Component, esphome_ns, global_ns
+
+IPAddress = global_ns.class_('IPAddress')
+ManualIP = esphome_ns.struct('ManualIP')
+WiFiComponent = esphome_ns.class_('WiFiComponent', Component)
+WiFiAP = esphome_ns.struct('WiFiAP')
+
+WiFiPowerSaveMode = esphome_ns.enum('WiFiPowerSaveMode')
+WIFI_POWER_SAVE_MODES = {
+    'NONE': WiFiPowerSaveMode.WIFI_POWER_SAVE_NONE,
+    'LIGHT': WiFiPowerSaveMode.WIFI_POWER_SAVE_LIGHT,
+    'HIGH': WiFiPowerSaveMode.WIFI_POWER_SAVE_HIGH,
+}
+WiFiConnectedCondition = esphome_ns.class_('WiFiConnectedCondition', Condition)
+
+
+def validate_password(value):
+    value = cv.string_strict(value)
+    if not value:
+        return value
+    if len(value) < 8:
+        raise vol.Invalid(u"WPA password must be at least 8 characters long")
+    if len(value) > 64:
+        raise vol.Invalid(u"WPA password must be at most 64 characters long")
+    return value
+
+
+def validate_channel(value):
+    value = cv.positive_int(value)
+    if value < 1:
+        raise vol.Invalid("Minimum WiFi channel is 1")
+    if value > 14:
+        raise vol.Invalid("Maximum WiFi channel is 14")
+    return value
+
+
+AP_MANUAL_IP_SCHEMA = cv.Schema({
+    vol.Required(CONF_STATIC_IP): cv.ipv4,
+    vol.Required(CONF_GATEWAY): cv.ipv4,
+    vol.Required(CONF_SUBNET): cv.ipv4,
+})
+
+STA_MANUAL_IP_SCHEMA = AP_MANUAL_IP_SCHEMA.extend({
+    vol.Optional(CONF_DNS1, default="1.1.1.1"): cv.ipv4,
+    vol.Optional(CONF_DNS2, default="1.0.0.1"): cv.ipv4,
+})
+
+WIFI_NETWORK_BASE = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WiFiAP),
+    vol.Optional(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): validate_password,
+    vol.Optional(CONF_CHANNEL): validate_channel,
+    vol.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
+})
+
+WIFI_NETWORK_AP = WIFI_NETWORK_BASE.extend({
+
+})
+
+WIFI_NETWORK_STA = WIFI_NETWORK_BASE.extend({
+    vol.Optional(CONF_BSSID): cv.mac_address,
+    vol.Optional(CONF_HIDDEN): cv.boolean,
+})
+
+
+def validate(config):
+    if CONF_PASSWORD in config and CONF_SSID not in config:
+        raise vol.Invalid("Cannot have WiFi password without SSID!")
+
+    if CONF_SSID in config:
+        network = {CONF_SSID: config.pop(CONF_SSID)}
+        if CONF_PASSWORD in config:
+            network[CONF_PASSWORD] = config.pop(CONF_PASSWORD)
+        if CONF_NETWORKS in config:
+            raise vol.Invalid("You cannot use the 'ssid:' option together with 'networks:'. Please "
+                              "copy your network into the 'networks:' key")
+        config[CONF_NETWORKS] = cv.ensure_list(WIFI_NETWORK_STA)(network)
+
+    if (CONF_NETWORKS not in config) and (CONF_AP not in config):
+        raise vol.Invalid("Please specify at least an SSID or an Access Point "
+                          "to create.")
+
+    if config.get(CONF_FAST_CONNECT, False):
+        networks = config.get(CONF_NETWORKS, [])
+        if not networks:
+            raise vol.Invalid("At least one network required for fast_connect!")
+        if len(networks) != 1:
+            raise vol.Invalid("Fast connect can only be used with one network!")
+
+    if CONF_USE_ADDRESS not in config:
+        if CONF_MANUAL_IP in config:
+            use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
+        else:
+            use_address = CORE.name + config[CONF_DOMAIN]
+        config[CONF_USE_ADDRESS] = use_address
+
+    return config
+
+
+CONFIG_SCHEMA = vol.All(cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(WiFiComponent),
+    vol.Optional(CONF_NETWORKS): cv.ensure_list(WIFI_NETWORK_STA),
+
+    vol.Optional(CONF_SSID): cv.ssid,
+    vol.Optional(CONF_PASSWORD): validate_password,
+    vol.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
+
+    vol.Optional(CONF_AP): WIFI_NETWORK_AP,
+    vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
+    vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SAVE_MODE): cv.one_of(*WIFI_POWER_SAVE_MODES, upper=True),
+    vol.Optional(CONF_FAST_CONNECT): cv.boolean,
+    vol.Optional(CONF_USE_ADDRESS): cv.string_strict,
+
+    vol.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"),
+}), validate)
+
+
+def safe_ip(ip):
+    if ip is None:
+        return IPAddress(0, 0, 0, 0)
+    return IPAddress(*ip.args)
+
+
+def manual_ip(config):
+    if config is None:
+        return None
+    return StructInitializer(
+        ManualIP,
+        ('static_ip', safe_ip(config[CONF_STATIC_IP])),
+        ('gateway', safe_ip(config[CONF_GATEWAY])),
+        ('subnet', safe_ip(config[CONF_SUBNET])),
+        ('dns1', safe_ip(config.get(CONF_DNS1))),
+        ('dns2', safe_ip(config.get(CONF_DNS2))),
+    )
+
+
+def wifi_network(config, static_ip):
+    ap = variable(config[CONF_ID], WiFiAP())
+    if CONF_SSID in config:
+        add(ap.set_ssid(config[CONF_SSID]))
+    if CONF_PASSWORD in config:
+        add(ap.set_password(config[CONF_PASSWORD]))
+    if CONF_BSSID in config:
+        add(ap.set_bssid([HexInt(i) for i in config[CONF_BSSID].parts]))
+    if CONF_HIDDEN in config:
+        add(ap.set_hidden(config[CONF_HIDDEN]))
+    if CONF_CHANNEL in config:
+        add(ap.set_channel(config[CONF_CHANNEL]))
+    if static_ip is not None:
+        add(ap.set_manual_ip(manual_ip(static_ip)))
+
+    return ap
+
+
+def to_code(config):
+    rhs = App.init_wifi()
+    wifi = Pvariable(config[CONF_ID], rhs)
+    add(wifi.set_use_address(config[CONF_USE_ADDRESS]))
+
+    for network in config.get(CONF_NETWORKS, []):
+        add(wifi.add_sta(wifi_network(network, config.get(CONF_MANUAL_IP))))
+
+    if CONF_AP in config:
+        add(wifi.set_ap(wifi_network(config[CONF_AP], config.get(CONF_MANUAL_IP))))
+
+    if CONF_REBOOT_TIMEOUT in config:
+        add(wifi.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+
+    if CONF_POWER_SAVE_MODE in config:
+        add(wifi.set_power_save_mode(WIFI_POWER_SAVE_MODES[config[CONF_POWER_SAVE_MODE]]))
+
+    if CONF_FAST_CONNECT in config:
+        add(wifi.set_fast_connect(config[CONF_FAST_CONNECT]))
+
+
+def lib_deps(config):
+    if CORE.is_esp8266:
+        return 'ESP8266WiFi'
+    if CORE.is_esp32:
+        return None
+    raise NotImplementedError
+
+
+CONF_WIFI_CONNECTED = 'wifi.connected'
+WIFI_CONNECTED_CONDITION_SCHEMA = cv.Schema({})
+
+
+@CONDITION_REGISTRY.register(CONF_WIFI_CONNECTED, WIFI_CONNECTED_CONDITION_SCHEMA)
+def wifi_connected_to_code(config, condition_id, template_arg, args):
+    rhs = WiFiConnectedCondition.new(template_arg)
+    type = WiFiConnectedCondition.template(template_arg)
+    yield Pvariable(condition_id, rhs, type=type)

esphome/config.py

@@ -0,0 +1,613 @@
+from __future__ import print_function
+
+from collections import OrderedDict
+import importlib
+import logging
+import re
+
+import voluptuous as vol
+
+from esphome import core, core_config, yaml_util
+from esphome.components import substitutions
+from esphome.const import CONF_ESPHOME, CONF_PLATFORM, ESP_PLATFORMS
+from esphome.core import CORE, EsphomeError
+from esphome.helpers import color, indent
+from esphome.py_compat import text_type
+from esphome.util import safe_print
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import List, Optional, Tuple, Union  # noqa
+from esphome.core import ConfigType  # noqa
+from esphome.yaml_util import is_secret
+from esphome.voluptuous_schema import ExtraKeysInvalid
+
+_LOGGER = logging.getLogger(__name__)
+
+_COMPONENT_CACHE = {}
+
+
+def get_component(domain):
+    if domain in _COMPONENT_CACHE:
+        return _COMPONENT_CACHE[domain]
+
+    path = 'esphome.components.{}'.format(domain)
+    try:
+        module = importlib.import_module(path)
+    except (ImportError, ValueError) as err:
+        _LOGGER.debug(err)
+    else:
+        _COMPONENT_CACHE[domain] = module
+        return module
+
+    _LOGGER.error("Unable to find component %s", domain)
+    return None
+
+
+def get_platform(domain, platform):
+    return get_component("{}.{}".format(domain, platform))
+
+
+def is_platform_component(component):
+    return hasattr(component, 'PLATFORM_SCHEMA')
+
+
+def iter_components(config):
+    for domain, conf in config.items():
+        if domain == CONF_ESPHOME:
+            yield CONF_ESPHOME, core_config, conf
+            continue
+        component = get_component(domain)
+        if getattr(component, 'MULTI_CONF', False):
+            for conf_ in conf:
+                yield domain, component, conf_
+        else:
+            yield domain, component, conf
+        if is_platform_component(component):
+            for p_config in conf:
+                p_name = u"{}.{}".format(domain, p_config[CONF_PLATFORM])
+                platform = get_component(p_name)
+                yield p_name, platform, p_config
+
+
+ConfigPath = List[Union[str, int]]
+
+
+def _path_begins_with_(path, other):  # type: (ConfigPath, ConfigPath) -> bool
+    if len(path) < len(other):
+        return False
+    return path[:len(other)] == other
+
+
+def _path_begins_with(path, other):  # type: (ConfigPath, ConfigPath) -> bool
+    ret = _path_begins_with_(path, other)
+    return ret
+
+
+class Config(OrderedDict):
+    def __init__(self):
+        super(Config, self).__init__()
+        self.errors = []  # type: List[Tuple[basestring, ConfigPath]]
+        self.domains = []  # type: List[Tuple[ConfigPath, basestring]]
+
+    def add_error(self, message, path):
+        # type: (basestring, ConfigPath) -> None
+        if not isinstance(message, text_type):
+            message = text_type(message)
+        self.errors.append((message, path))
+
+    def add_domain(self, path, name):
+        # type: (ConfigPath, basestring) -> None
+        self.domains.append((path, name))
+
+    def remove_domain(self, path, name):
+        self.domains.remove((path, name))
+
+    def lookup_domain(self, path):
+        # type: (ConfigPath) -> Optional[basestring]
+        best_len = 0
+        best_domain = None
+        for d_path, domain in self.domains:
+            if len(d_path) < best_len:
+                continue
+            if _path_begins_with(path, d_path):
+                best_len = len(d_path)
+                best_domain = domain
+        return best_domain
+
+    def is_in_error_path(self, path):
+        for _, p in self.errors:
+            if _path_begins_with(p, path):
+                return True
+        return False
+
+    def get_error_for_path(self, path):
+        for msg, p in self.errors:
+            if self.nested_item_path(p) == path:
+                return msg
+        return None
+
+    def nested_item(self, path):
+        data = self
+        for item_index in path:
+            try:
+                data = data[item_index]
+            except (KeyError, IndexError, TypeError):
+                return {}
+        return data
+
+    def nested_item_path(self, path):
+        data = self
+        part = []
+        for item_index in path:
+            try:
+                data = data[item_index]
+            except (KeyError, IndexError, TypeError):
+                return part
+            part.append(item_index)
+        return part
+
+
+def iter_ids(config, path=None):
+    path = path or []
+    if isinstance(config, core.ID):
+        yield config, path
+    elif isinstance(config, core.Lambda):
+        for id in config.requires_ids:
+            yield id, path
+    elif isinstance(config, list):
+        for i, item in enumerate(config):
+            for result in iter_ids(item, path + [i]):
+                yield result
+    elif isinstance(config, dict):
+        for key, value in config.items():
+            for result in iter_ids(value, path + [key]):
+                yield result
+
+
+def do_id_pass(result):  # type: (Config) -> None
+    from esphome.cpp_generator import MockObjClass
+
+    declare_ids = []  # type: List[Tuple[core.ID, ConfigPath]]
+    searching_ids = []  # type: List[Tuple[core.ID, ConfigPath]]
+    for id, path in iter_ids(result):
+        if id.is_declaration:
+            if id.id is not None and any(v[0].id == id.id for v in declare_ids):
+                result.add_error(u"ID {} redefined!".format(id.id), path)
+                continue
+            declare_ids.append((id, path))
+        else:
+            searching_ids.append((id, path))
+    # Resolve default ids after manual IDs
+    for id, _ in declare_ids:
+        id.resolve([v[0].id for v in declare_ids])
+
+    # Check searched IDs
+    for id, path in searching_ids:
+        if id.id is not None:
+            # manually declared
+            match = next((v[0] for v in declare_ids if v[0].id == id.id), None)
+            if match is None:
+                # No declared ID with this name
+                result.add_error("Couldn't find ID '{}'".format(id.id), path)
+                continue
+            if not isinstance(match.type, MockObjClass) or not isinstance(id.type, MockObjClass):
+                continue
+            if not match.type.inherits_from(id.type):
+                result.add_error("ID '{}' of type {} doesn't inherit from {}. Please double check "
+                                 "your ID is pointing to the correct value"
+                                 "".format(id.id, match.type, id.type), path)
+
+        if id.id is None and id.type is not None:
+            for v in declare_ids:
+                if v[0] is None or not isinstance(v[0].type, MockObjClass):
+                    continue
+                inherits = v[0].type.inherits_from(id.type)
+                if inherits:
+                    id.id = v[0].id
+                    break
+            else:
+                result.add_error("Couldn't resolve ID for type '{}'".format(id.type), path)
+
+
+def validate_config(config):
+    result = Config()
+
+    def _comp_error(ex, path):
+        # type: (vol.Invalid, List[basestring]) -> None
+        if isinstance(ex, vol.MultipleInvalid):
+            errors = ex.errors
+        else:
+            errors = [ex]
+
+        for e in errors:
+            path_ = path + e.path
+            domain = result.lookup_domain(path_) or ''
+            result.add_error(_format_vol_invalid(e, config, path, domain), path_)
+
+    skip_paths = list()  # type: List[ConfigPath]
+
+    # Step 1: Load everything
+    result.add_domain([CONF_ESPHOME], CONF_ESPHOME)
+    result[CONF_ESPHOME] = config[CONF_ESPHOME]
+
+    for domain, conf in config.items():
+        domain = str(domain)
+        if domain == CONF_ESPHOME or domain.startswith(u'.'):
+            skip_paths.append([domain])
+            continue
+        result.add_domain([domain], domain)
+        result[domain] = conf
+        if conf is None:
+            result[domain] = conf = {}
+        component = get_component(domain)
+        if component is None:
+            result.add_error(u"Component not found: {}".format(domain), [domain])
+            skip_paths.append([domain])
+            continue
+
+        if not isinstance(conf, list) and getattr(component, 'MULTI_CONF', False):
+            result[domain] = conf = [conf]
+
+        success = True
+        dependencies = getattr(component, 'DEPENDENCIES', [])
+        for dependency in dependencies:
+            if dependency not in config:
+                result.add_error(u"Component {} requires component {}".format(domain, dependency),
+                                 [domain])
+                success = False
+        if not success:
+            skip_paths.append([domain])
+            continue
+
+        success = True
+        conflicts_with = getattr(component, 'CONFLICTS_WITH', [])
+        for conflict in conflicts_with:
+            if conflict in config:
+                result.add_error(u"Component {} cannot be used together with component {}"
+                                 u"".format(domain, conflict), [domain])
+                success = False
+        if not success:
+            skip_paths.append([domain])
+            continue
+
+        esp_platforms = getattr(component, 'ESP_PLATFORMS', ESP_PLATFORMS)
+        if CORE.esp_platform not in esp_platforms:
+            result.add_error(u"Component {} doesn't support {}.".format(domain, CORE.esp_platform),
+                             [domain])
+            skip_paths.append([domain])
+            continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        result.remove_domain([domain], domain)
+
+        if not isinstance(conf, list) and conf:
+            result[domain] = conf = [conf]
+
+        for i, p_config in enumerate(conf):
+            if not isinstance(p_config, dict):
+                result.add_error(u"Platform schemas must have 'platform:' key", [domain, i])
+                skip_paths.append([domain, i])
+                continue
+            p_name = p_config.get('platform')
+            if p_name is None:
+                result.add_error(u"No platform specified for {}".format(domain), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+            p_domain = u'{}.{}'.format(domain, p_name)
+            result.add_domain([domain, i], p_domain)
+            platform = get_platform(domain, p_name)
+            if platform is None:
+                result.add_error(u"Platform not found: '{}'".format(p_domain), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+
+            success = True
+            dependencies = getattr(platform, 'DEPENDENCIES', [])
+            for dependency in dependencies:
+                if dependency not in config:
+                    result.add_error(u"Platform {} requires component {}"
+                                     u"".format(p_domain, dependency), [domain, i])
+                    success = False
+            if not success:
+                skip_paths.append([domain, i])
+                continue
+
+            success = True
+            conflicts_with = getattr(platform, 'CONFLICTS_WITH', [])
+            for conflict in conflicts_with:
+                if conflict in config:
+                    result.add_error(u"Platform {} cannot be used together with component {}"
+                                     u"".format(p_domain, conflict), [domain, i])
+                    success = False
+            if not success:
+                skip_paths.append([domain, i])
+                continue
+
+            esp_platforms = getattr(platform, 'ESP_PLATFORMS', ESP_PLATFORMS)
+            if CORE.esp_platform not in esp_platforms:
+                result.add_error(u"Platform {} doesn't support {}."
+                                 u"".format(p_domain, CORE.esp_platform), [domain, i])
+                skip_paths.append([domain, i])
+                continue
+
+    # Step 2: Validate configuration
+    try:
+        result[CONF_ESPHOME] = core_config.CONFIG_SCHEMA(result[CONF_ESPHOME])
+    except vol.Invalid as ex:
+        _comp_error(ex, [CONF_ESPHOME])
+
+    for domain, conf in result.items():
+        domain = str(domain)
+        if [domain] in skip_paths:
+            continue
+        component = get_component(domain)
+
+        if hasattr(component, 'CONFIG_SCHEMA'):
+            multi_conf = getattr(component, 'MULTI_CONF', False)
+
+            if multi_conf:
+                for i, conf_ in enumerate(conf):
+                    try:
+                        validated = component.CONFIG_SCHEMA(conf_)
+                        result[domain][i] = validated
+                    except vol.Invalid as ex:
+                        _comp_error(ex, [domain, i])
+            else:
+                try:
+                    validated = component.CONFIG_SCHEMA(conf)
+                    result[domain] = validated
+                except vol.Invalid as ex:
+                    _comp_error(ex, [domain])
+                    continue
+
+        if not hasattr(component, 'PLATFORM_SCHEMA'):
+            continue
+
+        for i, p_config in enumerate(conf):
+            if [domain, i] in skip_paths:
+                continue
+            p_name = p_config['platform']
+            platform = get_platform(domain, p_name)
+
+            if hasattr(platform, 'PLATFORM_SCHEMA'):
+                try:
+                    p_validated = platform.PLATFORM_SCHEMA(p_config)
+                except vol.Invalid as ex:
+                    _comp_error(ex, [domain, i])
+                    continue
+                result[domain][i] = p_validated
+
+    if not result.errors:
+        # Only parse IDs if no validation error. Otherwise
+        # user gets confusing messages
+        do_id_pass(result)
+    return result
+
+
+def _nested_getitem(data, path):
+    for item_index in path:
+        try:
+            data = data[item_index]
+        except (KeyError, IndexError, TypeError):
+            return None
+    return data
+
+
+def humanize_error(config, validation_error):
+    offending_item_summary = _nested_getitem(config, validation_error.path)
+    if isinstance(offending_item_summary, dict):
+        offending_item_summary = None
+    validation_error = text_type(validation_error)
+    m = re.match(r'^(.*?)\s*(?:for dictionary value )?@ data\[.*$', validation_error)
+    if m is not None:
+        validation_error = m.group(1)
+    validation_error = validation_error.strip()
+    if not validation_error.endswith(u'.'):
+        validation_error += u'.'
+    if offending_item_summary is None or is_secret(offending_item_summary):
+        return validation_error
+
+    return u"{} Got '{}'".format(validation_error, offending_item_summary)
+
+
+def _format_vol_invalid(ex, config, path, domain):
+    # type: (vol.Invalid, ConfigType, ConfigPath, basestring) -> unicode
+    message = u''
+    try:
+        paren = ex.path[-2]
+    except IndexError:
+        paren = domain
+
+    if isinstance(ex, ExtraKeysInvalid):
+        if ex.candidates:
+            message += u'[{}] is an invalid option for [{}]. Did you mean {}?'.format(
+                ex.path[-1], paren, u', '.join(u'[{}]'.format(x) for x in ex.candidates))
+        else:
+            message += u'[{}] is an invalid option for [{}]. Please check the indentation.'.format(
+                ex.path[-1], paren)
+    elif u'extra keys not allowed' in ex.error_message:
+        message += u'[{}] is an invalid option for [{}].'.format(ex.path[-1], paren)
+    elif u'required key not provided' in ex.error_message:
+        message += u"'{}' is a required option for [{}].".format(ex.path[-1], paren)
+    else:
+        message += humanize_error(_nested_getitem(config, path), ex)
+
+    return message
+
+
+def load_config():
+    try:
+        config = yaml_util.load_yaml(CORE.config_path)
+    except OSError:
+        raise EsphomeError(u"Invalid YAML at {}. Please see YAML syntax reference or use an online "
+                           u"YAML syntax validator".format(CORE.config_path))
+    CORE.raw_config = config
+    config = substitutions.do_substitution_pass(config)
+    core_config.preload_core_config(config)
+
+    try:
+        result = validate_config(config)
+    except EsphomeError:
+        raise
+    except Exception:
+        _LOGGER.error(u"Unexpected exception while reading configuration:")
+        raise
+
+    return result
+
+
+def line_info(obj, highlight=True):
+    """Display line config source."""
+    if not highlight:
+        return None
+    if hasattr(obj, '__config_file__'):
+        return color('cyan', "[source {}:{}]"
+                     .format(obj.__config_file__, obj.__line__ or '?'))
+    return None
+
+
+def _print_on_next_line(obj):
+    if isinstance(obj, (list, tuple, dict)):
+        return True
+    if isinstance(obj, str):
+        return len(obj) > 80
+    if isinstance(obj, core.Lambda):
+        return len(obj.value) > 80
+    return False
+
+
+def dump_dict(config, path, at_root=True):
+    # type: (Config, ConfigPath, bool) -> Tuple[unicode, bool]
+    conf = config.nested_item(path)
+    ret = u''
+    multiline = False
+
+    if at_root:
+        error = config.get_error_for_path(path)
+        if error is not None:
+            ret += u'\n' + color('bold_red', error) + u'\n'
+
+    if isinstance(conf, (list, tuple)):
+        multiline = True
+        if not conf:
+            ret += u'[]'
+            multiline = False
+
+        for i in range(len(conf)):
+            path_ = path + [i]
+            error = config.get_error_for_path(path_)
+            if error is not None:
+                ret += u'\n' + color('bold_red', error) + u'\n'
+
+            sep = u'- '
+            if config.is_in_error_path(path_):
+                sep = color('red', sep)
+            msg, _ = dump_dict(config, path_, at_root=False)
+            msg = indent(msg)
+            inf = line_info(config.nested_item(path_), highlight=config.is_in_error_path(path_))
+            if inf is not None:
+                msg = inf + u'\n' + msg
+            elif msg:
+                msg = msg[2:]
+            ret += sep + msg + u'\n'
+    elif isinstance(conf, dict):
+        multiline = True
+        if not conf:
+            ret += u'{}'
+            multiline = False
+
+        for k in conf.keys():
+            path_ = path + [k]
+            error = config.get_error_for_path(path_)
+            if error is not None:
+                ret += u'\n' + color('bold_red', error) + u'\n'
+
+            st = u'{}: '.format(k)
+            if config.is_in_error_path(path_):
+                st = color('red', st)
+            msg, m = dump_dict(config, path_, at_root=False)
+
+            inf = line_info(config.nested_item(path_), highlight=config.is_in_error_path(path_))
+            if m:
+                msg = u'\n' + indent(msg)
+
+            if inf is not None:
+                if m:
+                    msg = u' ' + inf + msg
+                else:
+                    msg = msg + u' ' + inf
+            ret += st + msg + u'\n'
+    elif isinstance(conf, str):
+        if is_secret(conf):
+            conf = u'!secret {}'.format(is_secret(conf))
+        if not conf:
+            conf += u"''"
+
+        if len(conf) > 80:
+            conf = u'|-\n' + indent(conf)
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, text_type(conf))
+    elif isinstance(conf, core.Lambda):
+        if is_secret(conf):
+            conf = u'!secret {}'.format(is_secret(conf))
+
+        conf = u'!lambda |-\n' + indent(text_type(conf.value))
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, conf)
+    elif conf is None:
+        pass
+    else:
+        error = config.get_error_for_path(path)
+        col = 'bold_red' if error else 'white'
+        ret += color(col, text_type(conf))
+        multiline = u'\n' in ret
+
+    return ret, multiline
+
+
+def strip_default_ids(config):
+    if isinstance(config, list):
+        to_remove = []
+        for i, x in enumerate(config):
+            x = config[i] = strip_default_ids(x)
+            if isinstance(x, core.ID) and not x.is_manual:
+                to_remove.append(x)
+        for x in to_remove:
+            config.remove(x)
+    elif isinstance(config, dict):
+        to_remove = []
+        for k, v in config.items():
+            v = config[k] = strip_default_ids(v)
+            if isinstance(v, core.ID) and not v.is_manual:
+                to_remove.append(k)
+        for k in to_remove:
+            config.pop(k)
+    return config
+
+
+def read_config(verbose):
+    _LOGGER.info("Reading configuration...")
+    try:
+        res = load_config()
+    except EsphomeError as err:
+        _LOGGER.error(u"Error while reading config: %s", err)
+        return None
+    if res.errors:
+        if not verbose:
+            res = strip_default_ids(res)
+
+        safe_print(color('bold_red', u"Failed config"))
+        safe_print('')
+        for path, domain in res.domains:
+            if not res.is_in_error_path(path):
+                continue
+
+            safe_print(color('bold_red', u'{}:'.format(domain)) + u' ' +
+                       (line_info(res.nested_item(path)) or u''))
+            safe_print(indent(dump_dict(res, path)[0]))
+        return None
+    return OrderedDict(res)

esphome/config_validation.py

@@ -9,21 +9,26 @@ import uuid as uuid_
 
 import voluptuous as vol
 
-from esphomeyaml import core, helpers
-from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_ID, \
-    CONF_NAME, CONF_PAYLOAD_AVAILABLE, \
-    CONF_PAYLOAD_NOT_AVAILABLE, CONF_PLATFORM, CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, \
-    ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, CONF_INTERNAL, CONF_SETUP_PRIORITY
-from esphomeyaml.core import HexInt, IPAddress, Lambda, TimePeriod, TimePeriodMicroseconds, \
-    TimePeriodMilliseconds, TimePeriodSeconds
+from esphome import core
+from esphome.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, CONF_ID, \
+    CONF_INTERNAL, CONF_NAME, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PLATFORM, \
+    CONF_RETAIN, CONF_SETUP_PRIORITY, CONF_STATE_TOPIC, CONF_TOPIC, ESP_PLATFORM_ESP32, \
+    ESP_PLATFORM_ESP8266
+from esphome.core import CORE, HexInt, IPAddress, Lambda, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, TimePeriodMinutes
+from esphome.py_compat import integer_types, string_types, text_type
+from esphome.voluptuous_schema import _Schema
 
 _LOGGER = logging.getLogger(__name__)
 
 # pylint: disable=invalid-name
 
+Schema = _Schema
 port = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
-positive_float = vol.All(vol.Coerce(float), vol.Range(min=0))
-zero_to_one_float = vol.All(vol.Coerce(float), vol.Range(min=0, max=1))
+float_ = vol.Coerce(float)
+positive_float = vol.All(float_, vol.Range(min=0))
+zero_to_one_float = vol.All(float_, vol.Range(min=0, max=1))
+negative_one_to_one_float = vol.All(float_, vol.Range(min=-1, max=1))
 positive_int = vol.All(vol.Coerce(int), vol.Range(min=0))
 positive_not_null_int = vol.All(vol.Coerce(int), vol.Range(min=0, min_included=False))
 
@@ -44,13 +49,14 @@ RESERVED_IDS = [
 
     'App', 'pinMode', 'delay', 'delayMicroseconds', 'digitalRead', 'digitalWrite', 'INPUT',
     'OUTPUT',
+    'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int8_t', 'int16_t', 'int32_t', 'int64_t',
 ]
 
 
 def alphanumeric(value):
     if value is None:
         raise vol.Invalid("string value is None")
-    value = unicode(value)
+    value = text_type(value)
     if not value.isalnum():
         raise vol.Invalid("string value is not alphanumeric")
     return value
@@ -61,7 +67,7 @@ def valid_name(value):
     for c in value:
         if c not in ALLOWED_NAME_CHARS:
             raise vol.Invalid(u"'{}' is an invalid character for names. Valid characters are: {}"
-                              u"".format(c, ALLOWED_NAME_CHARS))
+                              u" (lowercase, no spaces)".format(c, ALLOWED_NAME_CHARS))
     return value
 
 
@@ -69,16 +75,16 @@ def string(value):
     if isinstance(value, (dict, list)):
         raise vol.Invalid("string value cannot be dictionary or list.")
     if value is not None:
-        return unicode(value)
+        return text_type(value)
     raise vol.Invalid("string value is None")
 
 
 def string_strict(value):
     """Strictly only allow strings."""
-    if isinstance(value, (str, unicode)):
+    if isinstance(value, string_types):
         return value
-    raise vol.Invalid("Must be string, did you forget putting quotes "
-                      "around the value?")
+    raise vol.Invalid("Must be string, got {}. did you forget putting quotes "
+                      "around the value?".format(type(value)))
 
 
 def icon(value):
@@ -101,13 +107,25 @@ def boolean(value):
     return bool(value)
 
 
-def ensure_list(value):
+def ensure_list(*validators):
     """Wrap value in list if it is not one."""
-    if value is None or (isinstance(value, dict) and not value):
-        return []
-    if isinstance(value, list):
-        return value
-    return [value]
+    user = vol.All(*validators)
+
+    def validator(value):
+        if value is None or (isinstance(value, dict) and not value):
+            return []
+        if not isinstance(value, list):
+            return [user(value)]
+        ret = []
+        for i, val in enumerate(value):
+            try:
+                ret.append(user(val))
+            except vol.Invalid as err:
+                err.prepend([i])
+                raise err
+        return ret
+
+    return validator
 
 
 def ensure_list_not_empty(value):
@@ -125,7 +143,7 @@ def ensure_dict(value):
 
 
 def hex_int_(value):
-    if isinstance(value, (int, long)):
+    if isinstance(value, integer_types):
         return HexInt(value)
     value = string_strict(value).lower()
     if value.startswith('0x'):
@@ -134,7 +152,7 @@ def hex_int_(value):
 
 
 def int_(value):
-    if isinstance(value, (int, long)):
+    if isinstance(value, integer_types):
         return value
     value = string_strict(value).lower()
     if value.startswith('0x'):
@@ -145,7 +163,7 @@ def int_(value):
 hex_int = vol.Coerce(hex_int_)
 
 
-def variable_id_str_(value):
+def validate_id_name(value):
     value = string(value)
     if not value:
         raise vol.Invalid("ID must not be empty")
@@ -155,8 +173,9 @@ def variable_id_str_(value):
         raise vol.Invalid("Dashes are not supported in IDs, please use underscores instead.")
     for char in value:
         if char != '_' and not char.isalnum():
-            raise vol.Invalid(u"IDs must only consist of upper/lowercase characters and numbers."
-                              u"The character '{}' cannot be used".format(char))
+            raise vol.Invalid(u"IDs must only consist of upper/lowercase characters, the underscore"
+                              u"character and numbers. The character '{}' cannot be used"
+                              u"".format(char))
     if value in RESERVED_IDS:
         raise vol.Invalid(u"ID {} is reserved internally and cannot be used".format(value))
     return value
@@ -167,7 +186,7 @@ def use_variable_id(type):
         if value is None:
             return core.ID(None, is_declaration=False, type=type)
 
-        return core.ID(variable_id_str_(value), is_declaration=False, type=type)
+        return core.ID(validate_id_name(value), is_declaration=False, type=type)
 
     return validator
 
@@ -177,7 +196,7 @@ def declare_variable_id(type):
         if value is None:
             return core.ID(None, is_declaration=True, type=type)
 
-        return core.ID(variable_id_str_(value), is_declaration=True, type=type)
+        return core.ID(validate_id_name(value), is_declaration=True, type=type)
 
     return validator
 
@@ -187,7 +206,7 @@ def templatable(other_validators):
         if isinstance(value, Lambda):
             return value
         if isinstance(other_validators, dict):
-            return vol.Schema(other_validators)(value)
+            return Schema(other_validators)(value)
         return other_validators(value)
 
     return validator
@@ -198,7 +217,7 @@ def only_on(platforms):
         platforms = [platforms]
 
     def validator_(obj):
-        if core.ESP_PLATFORM not in platforms:
+        if CORE.esp_platform not in platforms:
             raise vol.Invalid(u"This feature is only available on {}".format(platforms))
         return obj
 
@@ -257,13 +276,13 @@ def has_at_most_one_key(*keys):
 TIME_PERIOD_ERROR = "Time period {} should be format number + unit, for example 5ms, 5s, 5min, 5h"
 
 time_period_dict = vol.All(
-    dict, vol.Schema({
-        'days': vol.Coerce(float),
-        'hours': vol.Coerce(float),
-        'minutes': vol.Coerce(float),
-        'seconds': vol.Coerce(float),
-        'milliseconds': vol.Coerce(float),
-        'microseconds': vol.Coerce(float),
+    dict, Schema({
+        'days': float_,
+        'hours': float_,
+        'minutes': float_,
+        'seconds': float_,
+        'milliseconds': float_,
+        'microseconds': float_,
     }),
     has_at_least_one_key('days', 'hours', 'minutes',
                          'seconds', 'milliseconds', 'microseconds'),
@@ -274,7 +293,7 @@ def time_period_str_colon(value):
     """Validate and transform time offset with format HH:MM[:SS]."""
     if isinstance(value, int):
         raise vol.Invalid('Make sure you wrap time values in quotes')
-    elif not isinstance(value, str):
+    if not isinstance(value, str):
         raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
 
     try:
@@ -296,9 +315,9 @@ def time_period_str_colon(value):
 def time_period_str_unit(value):
     """Validate and transform time period with time unit and integer value."""
     if isinstance(value, int):
-        raise vol.Invalid("Don't know what '{}' means as it has no time *unit*! Did you mean "
-                          "'{}s'?".format(value, value))
-    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid("Don't know what '{0}' means as it has no time *unit*! Did you mean "
+                          "'{0}s'?".format(value))
+    if not isinstance(value, string_types):
         raise vol.Invalid("Expected string for time period with unit.")
 
     unit_to_kwarg = {
@@ -319,11 +338,11 @@ def time_period_str_unit(value):
 
     match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*)$", value)
 
-    if match is None or match.group(2) not in unit_to_kwarg:
+    if match is None:
         raise vol.Invalid(u"Expected time period with unit, "
                           u"got {}".format(value))
+    kwarg = unit_to_kwarg[one_of(*unit_to_kwarg)(match.group(2))]
 
-    kwarg = unit_to_kwarg[match.group(2)]
     return TimePeriod(**{kwarg: float(match.group(1))})
 
 
@@ -345,6 +364,16 @@ def time_period_in_seconds_(value):
     return TimePeriodSeconds(**value.as_dict())
 
 
+def time_period_in_minutes_(value):
+    if value.microseconds is not None and value.microseconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    if value.milliseconds is not None and value.milliseconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    if value.seconds is not None and value.seconds != 0:
+        raise vol.Invalid("Maximum precision is minutes")
+    return TimePeriodMinutes(**value.as_dict())
+
+
 def update_interval(value):
     if value == 'never':
         return 4294967295  # uint32_t max
@@ -355,6 +384,7 @@ time_period = vol.Any(time_period_str_unit, time_period_str_colon, time_period_d
 positive_time_period = vol.All(time_period, vol.Range(min=TimePeriod()))
 positive_time_period_milliseconds = vol.All(positive_time_period, time_period_in_milliseconds_)
 positive_time_period_seconds = vol.All(positive_time_period, time_period_in_seconds_)
+positive_time_period_minutes = vol.All(positive_time_period, time_period_in_minutes_)
 time_period_microseconds = vol.All(time_period, time_period_in_microseconds_)
 positive_time_period_microseconds = vol.All(positive_time_period, time_period_in_microseconds_)
 positive_not_null_time_period = vol.All(time_period,
@@ -412,6 +442,8 @@ frequency = float_with_unit("frequency", r"(Hz|HZ|hz)?")
 resistance = float_with_unit("resistance", r"(Ω|Ω|ohm|Ohm|OHM)?")
 current = float_with_unit("current", r"(a|A|amp|Amp|amps|Amps|ampere|Ampere)?")
 voltage = float_with_unit("voltage", r"(v|V|volt|Volts)?")
+distance = float_with_unit("distance", r"(m)")
+framerate = float_with_unit("framerate", r"(FPS|fps|Fps|FpS|Hz)")
 
 
 def validate_bytes(value):
@@ -441,8 +473,20 @@ def hostname(value):
     return value
 
 
-def domain_name(value):
+def domain(value):
     value = string(value)
+    if re.match(vol.DOMAIN_REGEX, value) is not None:
+        return value
+    try:
+        return str(ipv4(value))
+    except vol.Invalid:
+        raise vol.Invalid("Invalid domain: {}".format(value))
+
+
+def domain_name(value):
+    value = string_strict(value)
+    if not value:
+        return value
     if not value.startswith('.'):
         raise vol.Invalid("Domain name must start with .")
     if value.startswith('..'):
@@ -454,22 +498,21 @@ def domain_name(value):
 
 
 def ssid(value):
-    if value is None:
-        raise vol.Invalid("SSID can not be None")
-    if not isinstance(value, str):
-        raise vol.Invalid("SSID must be a string. Did you wrap it in quotes?")
+    value = string_strict(value)
     if not value:
         raise vol.Invalid("SSID can't be empty.")
-    if len(value) > 31:
-        raise vol.Invalid("SSID can't be longer than 31 characters")
+    if len(value) > 32:
+        raise vol.Invalid("SSID can't be longer than 32 characters")
     return value
 
 
 def ipv4(value):
     if isinstance(value, list):
         parts = value
-    elif isinstance(value, str):
+    elif isinstance(value, string_types):
         parts = value.split('.')
+    elif isinstance(value, IPAddress):
+        return value
     else:
         raise vol.Invalid("IPv4 address must consist of either string or "
                           "integer list")
@@ -546,6 +589,15 @@ def mqtt_qos(value):
     return one_of(0, 1, 2)(value)
 
 
+def requires_component(comp):
+    def validator(value):
+        if comp not in CORE.raw_config:
+            raise vol.Invalid("This option requires component {}".format(comp))
+        return value
+
+    return validator
+
+
 uint8_t = vol.All(int_, vol.Range(min=0, max=255))
 uint16_t = vol.All(int_, vol.Range(min=0, max=65535))
 uint32_t = vol.All(int_, vol.Range(min=0, max=4294967295))
@@ -556,7 +608,12 @@ i2c_address = hex_uint8_t
 
 
 def percentage(value):
-    has_percent_sign = isinstance(value, (str, unicode)) and value.endswith('%')
+    value = possibly_negative_percentage(value)
+    return zero_to_one_float(value)
+
+
+def possibly_negative_percentage(value):
+    has_percent_sign = isinstance(value, string_types) and value.endswith('%')
     if has_percent_sign:
         value = float(value[:-1].rstrip()) / 100.0
     if value > 1:
@@ -564,11 +621,16 @@ def percentage(value):
         if not has_percent_sign:
             msg += " Please put a percent sign after the number!"
         raise vol.Invalid(msg)
-    return zero_to_one_float(value)
+    if value < -1:
+        msg = "Percentage must not be smaller than -100%."
+        if not has_percent_sign:
+            msg += " Please put a percent sign after the number!"
+        raise vol.Invalid(msg)
+    return negative_one_to_one_float(value)
 
 
 def percentage_int(value):
-    if isinstance(value, (str, unicode)) and value.endswith('%'):
+    if isinstance(value, string_types) and value.endswith('%'):
         value = int(value[:-1].rstrip())
     return value
 
@@ -584,10 +646,24 @@ def valid(value):
     return value
 
 
-def one_of(*values):
+def one_of(*values, **kwargs):
     options = u', '.join(u"'{}'".format(x) for x in values)
+    lower = kwargs.get('lower', False)
+    upper = kwargs.get('upper', False)
+    string_ = kwargs.get('string', False) or lower or upper
+    to_int = kwargs.get('int', False)
+    space = kwargs.get('space', ' ')
 
     def validator(value):
+        if string_:
+            value = string(value)
+            value = value.replace(' ', space)
+        if to_int:
+            value = int_(value)
+        if lower:
+            value = vol.Lower(value)
+        if upper:
+            value = vol.Upper(value)
         if value not in values:
             raise vol.Invalid(u"Unknown value '{}', must be one of {}".format(value, options))
         return value
@@ -621,7 +697,7 @@ def dimensions(value):
 
 def directory(value):
     value = string(value)
-    path = helpers.relative_path(value)
+    path = CORE.relative_path(value)
     if not os.path.exists(path):
         raise vol.Invalid(u"Could not find directory '{}'. Please make sure it exists.".format(
             path))
@@ -632,7 +708,7 @@ def directory(value):
 
 def file_(value):
     value = string(value)
-    path = helpers.relative_path(value)
+    path = CORE.relative_path(value)
     if not os.path.exists(path):
         raise vol.Invalid(u"Could not find file '{}'. Please make sure it exists.".format(
             path))
@@ -641,6 +717,20 @@ def file_(value):
     return value
 
 
+ENTITY_ID_CHARACTERS = 'abcdefghijklmnopqrstuvwxyz0123456789_'
+
+
+def entity_id(value):
+    value = string_strict(value).lower()
+    if value.count('.') != 1:
+        raise vol.Invalid("Entity ID must have exactly one dot in it")
+    for x in value.split('.'):
+        for c in x:
+            if c not in ENTITY_ID_CHARACTERS:
+                raise vol.Invalid("Invalid character for entity ID: {}".format(c))
+    return value
+
+
 class GenerateID(vol.Optional):
     def __init__(self, key=CONF_ID):
         super(GenerateID, self).__init__(key, default=lambda: None)
@@ -663,29 +753,30 @@ def nameable(*schemas):
     return validator
 
 
-PLATFORM_SCHEMA = vol.Schema({
+PLATFORM_SCHEMA = Schema({
     vol.Required(CONF_PLATFORM): valid,
 })
 
-MQTT_COMPONENT_AVAILABILITY_SCHEMA = vol.Schema({
+MQTT_COMPONENT_AVAILABILITY_SCHEMA = Schema({
     vol.Required(CONF_TOPIC): subscribe_topic,
     vol.Optional(CONF_PAYLOAD_AVAILABLE, default='online'): mqtt_payload,
     vol.Optional(CONF_PAYLOAD_NOT_AVAILABLE, default='offline'): mqtt_payload,
 })
 
-MQTT_COMPONENT_SCHEMA = vol.Schema({
+MQTT_COMPONENT_SCHEMA = Schema({
     vol.Optional(CONF_NAME): string,
-    vol.Optional(CONF_RETAIN): boolean,
-    vol.Optional(CONF_DISCOVERY): boolean,
-    vol.Optional(CONF_STATE_TOPIC): publish_topic,
-    vol.Optional(CONF_AVAILABILITY): vol.Any(None, MQTT_COMPONENT_AVAILABILITY_SCHEMA),
+    vol.Optional(CONF_RETAIN): vol.All(requires_component('mqtt'), boolean),
+    vol.Optional(CONF_DISCOVERY): vol.All(requires_component('mqtt'), boolean),
+    vol.Optional(CONF_STATE_TOPIC): vol.All(requires_component('mqtt'), publish_topic),
+    vol.Optional(CONF_AVAILABILITY): vol.All(requires_component('mqtt'),
+                                             vol.Any(None, MQTT_COMPONENT_AVAILABILITY_SCHEMA)),
     vol.Optional(CONF_INTERNAL): boolean,
 })
 
 MQTT_COMMAND_COMPONENT_SCHEMA = MQTT_COMPONENT_SCHEMA.extend({
-    vol.Optional(CONF_COMMAND_TOPIC): subscribe_topic,
+    vol.Optional(CONF_COMMAND_TOPIC): vol.All(requires_component('mqtt'), subscribe_topic),
 })
 
-COMPONENT_SCHEMA = vol.Schema({
-    vol.Optional(CONF_SETUP_PRIORITY): vol.Coerce(float)
+COMPONENT_SCHEMA = Schema({
+    vol.Optional(CONF_SETUP_PRIORITY): float_
 })

esphome/const.py

@@ -1,11 +1,11 @@
-"""Constants used by esphomeyaml."""
+"""Constants used by esphome."""
 
 MAJOR_VERSION = 1
-MINOR_VERSION = 9
-PATCH_VERSION = '2'
+MINOR_VERSION = 12
+PATCH_VERSION = '0'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
-ESPHOMELIB_VERSION = '1.9.2'
+ESPHOME_CORE_VERSION = '1.12.0'
 
 ESP_PLATFORM_ESP32 = 'ESP32'
 ESP_PLATFORM_ESP8266 = 'ESP8266'
@@ -13,21 +13,24 @@ ESP_PLATFORMS = [ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266]
 
 APB_CLOCK_FREQ = 80000000
 
-CONF_ESPHOMEYAML = 'esphomeyaml'
+CONF_ESPHOME = 'esphome'
 CONF_NAME = 'name'
 CONF_PLATFORM = 'platform'
 CONF_BOARD = 'board'
-CONF_ESPHOMELIB_VERSION = 'esphomelib_version'
+CONF_ESPHOME_CORE_VERSION = 'esphome_core_version'
 CONF_USE_CUSTOM_CODE = 'use_custom_code'
 CONF_ARDUINO_VERSION = 'arduino_version'
 CONF_LOCAL = 'local'
 CONF_REPOSITORY = 'repository'
 CONF_COMMIT = 'commit'
+CONF_SERVICES = 'services'
 CONF_TAG = 'tag'
 CONF_BRANCH = 'branch'
 CONF_LOGGER = 'logger'
 CONF_WIFI = 'wifi'
 CONF_SSID = 'ssid'
+CONF_IP_ADDRESS = 'ip_address'
+CONF_BSSID = 'bssid'
 CONF_PASSWORD = 'password'
 CONF_MANUAL_IP = 'manual_ip'
 CONF_STATIC_IP = 'static_ip'
@@ -37,6 +40,9 @@ CONF_OTA = 'ota'
 CONF_MQTT = 'mqtt'
 CONF_BROKER = 'broker'
 CONF_USERNAME = 'username'
+CONF_MIN_LEVEL = 'min_level'
+CONF_IDLE_LEVEL = 'idle_level'
+CONF_MAX_LEVEL = 'max_level'
 CONF_POWER_SUPPLY = 'power_supply'
 CONF_ID = 'id'
 CONF_MQTT_ID = 'mqtt_id'
@@ -58,6 +64,7 @@ CONF_PCA9685 = 'pca9685'
 CONF_PCA9685_ID = 'pca9685_id'
 CONF_OUTPUT = 'output'
 CONF_CHANNEL = 'channel'
+CONF_CHANNELS = 'channels'
 CONF_LIGHT = 'light'
 CONF_RED = 'red'
 CONF_GREEN = 'green'
@@ -91,6 +98,8 @@ CONF_ABOVE = 'above'
 CONF_BELOW = 'below'
 CONF_ON = 'on'
 CONF_IF = 'if'
+CONF_WHILE = 'while'
+CONF_WAIT_UNTIL = 'wait_until'
 CONF_THEN = 'then'
 CONF_BINARY = 'binary'
 CONF_WHITE = 'white'
@@ -110,7 +119,6 @@ CONF_PAYLOAD = 'payload'
 CONF_QOS = 'qos'
 CONF_DISCOVERY_RETAIN = 'discovery_retain'
 CONF_TOPIC_PREFIX = 'topic_prefix'
-CONF_HOSTNAME = 'hostname'
 CONF_PHASE_BALANCER = 'phase_balancer'
 CONF_ADDRESS = 'address'
 CONF_ENABLE_TIME = 'enable_time'
@@ -125,7 +133,6 @@ CONF_FILTERS = 'filters'
 CONF_OFFSET = 'offset'
 CONF_MULTIPLY = 'multiply'
 CONF_FILTER_OUT = 'filter_out'
-CONF_FILTER_NAN = 'filter_nan'
 CONF_SLIDING_WINDOW_MOVING_AVERAGE = 'sliding_window_moving_average'
 CONF_EXPONENTIAL_MOVING_AVERAGE = 'exponential_moving_average'
 CONF_WINDOW_SIZE = 'window_size'
@@ -135,6 +142,7 @@ CONF_LAMBDA = 'lambda'
 CONF_THROTTLE = 'throttle'
 CONF_DELTA = 'delta'
 CONF_OR = 'or'
+CONF_CALIBRATE_LINEAR = 'calibrate_linear'
 CONF_AND = 'and'
 CONF_RANGE = 'range'
 CONF_UNIQUE = 'unique'
@@ -153,13 +161,14 @@ CONF_ATTENUATION = 'attenuation'
 CONF_PRESSURE = 'pressure'
 CONF_TRIGGER_PIN = 'trigger_pin'
 CONF_ECHO_PIN = 'echo_pin'
-CONF_TIMEOUT_METER = 'timeout_meter'
-CONF_TIMEOUT_TIME = 'timeout_time'
+CONF_TIMEOUT = 'timeout'
 CONF_CARRIER_DUTY_PERCENT = 'carrier_duty_percent'
 CONF_NEC = 'nec'
 CONF_COMMAND = 'command'
 CONF_DATA = 'data'
 CONF_NBITS = 'nbits'
+CONF_JVC = 'jvc'
+CONF_RC5 = 'rc5'
 CONF_LG = 'lg'
 CONF_SAMSUNG = 'samsung'
 CONF_SONY = 'sony'
@@ -194,6 +203,7 @@ CONF_CSS_URL = 'css_url'
 CONF_JS_URL = 'js_url'
 CONF_SSL_FINGERPRINTS = 'ssl_fingerprints'
 CONF_PCF8574 = 'pcf8574'
+CONF_MCP23017 = 'mcp23017'
 CONF_PCF8575 = 'pcf8575'
 CONF_SCAN = 'scan'
 CONF_KEEPALIVE = 'keepalive'
@@ -221,6 +231,7 @@ CONF_ACCURACY = 'accuracy'
 CONF_BOARD_FLASH_MODE = 'board_flash_mode'
 CONF_ON_PRESS = 'on_press'
 CONF_ON_RELEASE = 'on_release'
+CONF_ON_STATE = 'on_state'
 CONF_ON_CLICK = 'on_click'
 CONF_ON_DOUBLE_CLICK = 'on_double_click'
 CONF_ON_MULTI_CLICK = 'on_multi_click'
@@ -241,6 +252,7 @@ CONF_CLOSE_ACTION = 'close_action'
 CONF_STOP_ACTION = 'stop_action'
 CONF_DOMAIN = 'domain'
 CONF_OPTIMISTIC = 'optimistic'
+CONF_ASSUMED_STATE = 'assumed_state'
 CONF_ON_BOOT = 'on_boot'
 CONF_ON_SHUTDOWN = 'on_shutdown'
 CONF_PRIORITY = 'priority'
@@ -252,6 +264,7 @@ CONF_IDLE = 'idle'
 CONF_NETWORKS = 'networks'
 CONF_INTERNAL = 'internal'
 CONF_BUILD_PATH = 'build_path'
+CONF_PLATFORMIO_OPTIONS = 'platformio_options'
 CONF_REBOOT_TIMEOUT = 'reboot_timeout'
 CONF_INVERT = 'invert'
 CONF_DELAYED_ON = 'delayed_on'
@@ -259,6 +272,7 @@ CONF_DELAYED_OFF = 'delayed_off'
 CONF_UUID = 'uuid'
 CONF_TYPE = 'type'
 CONF_SPI_ID = 'spi_id'
+CONF_HARDWARE_UART = 'hardware_uart'
 CONF_UART_ID = 'uart_id'
 CONF_UID = 'uid'
 CONF_TX_PIN = 'tx_pin'
@@ -307,6 +321,7 @@ CONF_ROTATION = 'rotation'
 CONF_DC_PIN = 'dc_pin'
 CONF_RESET_PIN = 'reset_pin'
 CONF_BUSY_PIN = 'busy_pin'
+CONF_ESP8266_RESTORE_FROM_FLASH = 'esp8266_restore_from_flash'
 CONF_FULL_UPDATE_EVERY = 'full_update_every'
 CONF_DATA_PINS = 'data_pins'
 CONF_ENABLE_PIN = 'enable_pin'
@@ -329,9 +344,11 @@ CONF_CHANGE_MODE_EVERY = 'change_mode_every'
 CONF_PAGE_ID = 'page_id'
 CONF_COMPONENT_ID = 'component_id'
 CONF_COLD_WHITE = 'cold_white'
+CONF_PAGES = 'pages'
 CONF_WARM_WHITE = 'warm_white'
 CONF_COLD_WHITE_COLOR_TEMPERATURE = 'cold_white_color_temperature'
 CONF_WARM_WHITE_COLOR_TEMPERATURE = 'warm_white_color_temperature'
+CONF_HIDDEN = 'hidden'
 CONF_ON_LOOP = 'on_loop'
 CONF_ON_TIME = 'on_time'
 CONF_SECONDS = 'seconds'
@@ -350,6 +367,7 @@ CONF_FORMALDEHYDE = 'formaldehyde'
 CONF_ON_TAG = 'on_tag'
 CONF_ARGS = 'args'
 CONF_FORMAT = 'format'
+CONF_FOR = 'for'
 CONF_COLOR_CORRECT = 'color_correct'
 CONF_ON_JSON_MESSAGE = 'on_json_message'
 CONF_ACCELERATION = 'acceleration'
@@ -371,9 +389,47 @@ CONF_UPDATE_ON_BOOT = 'update_on_boot'
 CONF_INITIAL_VALUE = 'initial_value'
 CONF_RESTORE_VALUE = 'restore_value'
 CONF_PINS = 'pins'
+CONF_SENSORS = 'sensors'
+CONF_BINARY_SENSORS = 'binary_sensors'
+CONF_OUTPUTS = 'outputs'
+CONF_SWITCHES = 'switches'
+CONF_TEXT_SENSORS = 'text_sensors'
+CONF_INCLUDES = 'includes'
+CONF_LIBRARIES = 'libraries'
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_C = 'pin_c'
+CONF_PIN_D = 'pin_d'
+CONF_SLEEP_WHEN_DONE = 'sleep_when_done'
+CONF_STEP_MODE = 'step_mode'
+CONF_COMPONENTS = 'components'
+CONF_DATA_TEMPLATE = 'data_template'
+CONF_VARIABLES = 'variables'
+CONF_SERVICE = 'service'
+CONF_ENTITY_ID = 'entity_id'
+CONF_RESTORE_MODE = 'restore_mode'
+CONF_INTERVAL = 'interval'
+CONF_DIRECTION = 'direction'
+CONF_VARIANT = 'variant'
+CONF_METHOD = 'method'
+CONF_FAST_CONNECT = 'fast_connect'
+CONF_INTERLOCK = 'interlock'
+CONF_ON_TURN_ON = 'on_turn_on'
+CONF_ON_TURN_OFF = 'on_turn_off'
+CONF_USE_ADDRESS = 'use_address'
+CONF_FROM = 'from'
+CONF_TO = 'to'
+CONF_SEGMENTS = 'segments'
+CONF_MIN_POWER = 'min_power'
+CONF_MIN_VALUE = 'min_value'
+CONF_MAX_VALUE = 'max_value'
+CONF_RX_ONLY = 'rx_only'
 
 
 ALLOWED_NAME_CHARS = u'abcdefghijklmnopqrstuvwxyz0123456789_'
 ARDUINO_VERSION_ESP32_DEV = 'https://github.com/platformio/platform-espressif32.git#feature/stage'
+ARDUINO_VERSION_ESP32_1_0_0 = 'espressif32@1.5.0'
+ARDUINO_VERSION_ESP32_1_0_1 = 'espressif32@1.6.0'
 ARDUINO_VERSION_ESP8266_DEV = 'https://github.com/platformio/platform-espressif8266.git#feature' \
                               '/stage'
+ARDUINO_VERSION_ESP8266_2_5_0 = 'espressif8266@2.0.0'

esphome/core.py

@@ -0,0 +1,461 @@
+import collections
+from collections import OrderedDict
+import inspect
+import logging
+import math
+import os
+import re
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import Any, Dict, List  # noqa
+
+from esphome.const import CONF_ARDUINO_VERSION, CONF_ESPHOME, CONF_ESPHOME_CORE_VERSION, \
+    CONF_LOCAL, CONF_USE_ADDRESS, CONF_WIFI, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, \
+    CONF_REPOSITORY, CONF_BRANCH
+from esphome.helpers import ensure_unique_string, is_hassio
+from esphome.py_compat import IS_PY2, integer_types
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EsphomeError(Exception):
+    """General ESPHome exception occurred."""
+
+
+if IS_PY2:
+    base_int = long
+else:
+    base_int = int
+
+
+class HexInt(base_int):
+    def __str__(self):
+        if 0 <= self <= 255:
+            return "0x{:02X}".format(self)
+        return "0x{:X}".format(self)
+
+
+class IPAddress(object):
+    def __init__(self, *args):
+        if len(args) != 4:
+            raise ValueError(u"IPAddress must consist up 4 items")
+        self.args = args
+
+    def __str__(self):
+        return '.'.join(str(x) for x in self.args)
+
+
+class MACAddress(object):
+    def __init__(self, *parts):
+        if len(parts) != 6:
+            raise ValueError(u"MAC Address must consist of 6 items")
+        self.parts = parts
+
+    def __str__(self):
+        return ':'.join('{:02X}'.format(part) for part in self.parts)
+
+    def as_hex(self):
+        from esphome.cpp_generator import RawExpression
+
+        num = ''.join('{:02X}'.format(part) for part in self.parts)
+        return RawExpression('0x{}ULL'.format(num))
+
+
+def is_approximately_integer(value):
+    if isinstance(value, integer_types):
+        return True
+    return abs(value - round(value)) < 0.001
+
+
+class TimePeriod(object):
+    def __init__(self, microseconds=None, milliseconds=None, seconds=None,
+                 minutes=None, hours=None, days=None):
+        if days is not None:
+            if not is_approximately_integer(days):
+                frac_days, days = math.modf(days)
+                hours = (hours or 0) + frac_days * 24
+            self.days = int(round(days))
+        else:
+            self.days = None
+
+        if hours is not None:
+            if not is_approximately_integer(hours):
+                frac_hours, hours = math.modf(hours)
+                minutes = (minutes or 0) + frac_hours * 60
+            self.hours = int(round(hours))
+        else:
+            self.hours = None
+
+        if minutes is not None:
+            if not is_approximately_integer(minutes):
+                frac_minutes, minutes = math.modf(minutes)
+                seconds = (seconds or 0) + frac_minutes * 60
+            self.minutes = int(round(minutes))
+        else:
+            self.minutes = None
+
+        if seconds is not None:
+            if not is_approximately_integer(seconds):
+                frac_seconds, seconds = math.modf(seconds)
+                milliseconds = (milliseconds or 0) + frac_seconds * 1000
+            self.seconds = int(round(seconds))
+        else:
+            self.seconds = None
+
+        if milliseconds is not None:
+            if not is_approximately_integer(milliseconds):
+                frac_milliseconds, milliseconds = math.modf(milliseconds)
+                microseconds = (microseconds or 0) + frac_milliseconds * 1000
+            self.milliseconds = int(round(milliseconds))
+        else:
+            self.milliseconds = None
+
+        if microseconds is not None:
+            if not is_approximately_integer(microseconds):
+                raise ValueError("Maximum precision is microseconds")
+            self.microseconds = int(round(microseconds))
+        else:
+            self.microseconds = None
+
+    def as_dict(self):
+        out = OrderedDict()
+        if self.microseconds is not None:
+            out['microseconds'] = self.microseconds
+        if self.milliseconds is not None:
+            out['milliseconds'] = self.milliseconds
+        if self.seconds is not None:
+            out['seconds'] = self.seconds
+        if self.minutes is not None:
+            out['minutes'] = self.minutes
+        if self.hours is not None:
+            out['hours'] = self.hours
+        if self.days is not None:
+            out['days'] = self.days
+        return out
+
+    def __str__(self):
+        if self.microseconds is not None:
+            return '{} us'.format(self.total_microseconds)
+        if self.milliseconds is not None:
+            return '{} ms'.format(self.total_milliseconds)
+        if self.seconds is not None:
+            return '{} s'.format(self.total_seconds)
+        if self.minutes is not None:
+            return '{} min'.format(self.total_minutes)
+        if self.hours is not None:
+            return '{} h'.format(self.total_hours)
+        if self.days is not None:
+            return '{} d'.format(self.total_days)
+        return '0'
+
+    @property
+    def total_microseconds(self):
+        return self.total_milliseconds * 1000 + (self.microseconds or 0)
+
+    @property
+    def total_milliseconds(self):
+        return self.total_seconds * 1000 + (self.milliseconds or 0)
+
+    @property
+    def total_seconds(self):
+        return self.total_minutes * 60 + (self.seconds or 0)
+
+    @property
+    def total_minutes(self):
+        return self.total_hours * 60 + (self.minutes or 0)
+
+    @property
+    def total_hours(self):
+        return self.total_days * 24 + (self.hours or 0)
+
+    @property
+    def total_days(self):
+        return self.days or 0
+
+    def __eq__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds == other.total_microseconds
+
+    def __ne__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds != other.total_microseconds
+
+    def __lt__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds < other.total_microseconds
+
+    def __gt__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds > other.total_microseconds
+
+    def __le__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds <= other.total_microseconds
+
+    def __ge__(self, other):
+        if not isinstance(other, TimePeriod):
+            raise ValueError("other must be TimePeriod")
+        return self.total_microseconds >= other.total_microseconds
+
+
+class TimePeriodMicroseconds(TimePeriod):
+    pass
+
+
+class TimePeriodMilliseconds(TimePeriod):
+    pass
+
+
+class TimePeriodSeconds(TimePeriod):
+    pass
+
+
+class TimePeriodMinutes(TimePeriod):
+    pass
+
+
+LAMBDA_PROG = re.compile(r'id\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)')
+
+
+class Lambda(object):
+    def __init__(self, value):
+        self._value = value
+        self._parts = None
+        self._requires_ids = None
+
+    @property
+    def parts(self):
+        if self._parts is None:
+            self._parts = re.split(LAMBDA_PROG, self._value)
+        return self._parts
+
+    @property
+    def requires_ids(self):
+        if self._requires_ids is None:
+            self._requires_ids = [ID(self.parts[i]) for i in range(1, len(self.parts), 3)]
+        return self._requires_ids
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+        self._parts = None
+        self._requires_ids = None
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return u'Lambda<{}>'.format(self.value)
+
+
+class ID(object):
+    def __init__(self, id, is_declaration=False, type=None):
+        self.id = id
+        self.is_manual = id is not None
+        self.is_declaration = is_declaration
+        self.type = type
+
+    def resolve(self, registered_ids):
+        from esphome.config_validation import RESERVED_IDS
+
+        if self.id is None:
+            base = str(self.type).replace('::', '_').lower()
+            name = ''.join(c for c in base if c.isalnum() or c == '_')
+            used = set(registered_ids) | set(RESERVED_IDS)
+            self.id = ensure_unique_string(name, used)
+        return self.id
+
+    def __str__(self):
+        if self.id is None:
+            return ''
+        return self.id
+
+    def __repr__(self):
+        return u'ID<{} declaration={}, type={}, manual={}>'.format(
+            self.id, self.is_declaration, self.type, self.is_manual)
+
+    def __eq__(self, other):
+        if not isinstance(other, ID):
+            raise ValueError("other must be ID")
+        return self.id == other.id
+
+    def __hash__(self):
+        return hash(self.id)
+
+
+# pylint: disable=too-many-instance-attributes,too-many-public-methods
+class EsphomeCore(object):
+    def __init__(self):
+        # True if command is run from dashboard
+        self.dashboard = False
+        # The name of the node
+        self.name = None  # type: str
+        # The relative path to the configuration YAML
+        self.config_path = None  # type: str
+        # The relative path to where all build files are stored
+        self.build_path = None  # type: str
+        # The platform (ESP8266, ESP32) of this device
+        self.esp_platform = None  # type: str
+        # The board that's used (for example nodemcuv2)
+        self.board = None  # type: str
+        # The full raw configuration
+        self.raw_config = {}  # type: ConfigType
+        # The validated configuration, this is None until the config has been validated
+        self.config = {}  # type: ConfigType
+        # The pending tasks in the task queue (mostly for C++ generation)
+        self.pending_tasks = collections.deque()
+        # The variable cache, for each ID this holds a MockObj of the variable obj
+        self.variables = {}  # type: Dict[str, MockObj]
+        # The list of expressions for the C++ generation
+        self.expressions = []  # type: List[Expression]
+
+    @property
+    def address(self):  # type: () -> str
+        if 'wifi' in self.config:
+            return self.config[CONF_WIFI][CONF_USE_ADDRESS]
+
+        if 'ethernet' in self.config:
+            return self.config['ethernet'][CONF_USE_ADDRESS]
+
+        return None
+
+    @property
+    def esphome_core_version(self):  # type: () -> Dict[str, str]
+        return self.config[CONF_ESPHOME][CONF_ESPHOME_CORE_VERSION]
+
+    @property
+    def is_dev_esphome_core_version(self):
+        if CONF_REPOSITORY not in self.esphome_core_version:
+            return False
+        return self.esphome_core_version.get(CONF_BRANCH) == 'dev'
+
+    @property
+    def is_local_esphome_core_copy(self):
+        return CONF_LOCAL in self.esphome_core_version
+
+    @property
+    def arduino_version(self):  # type: () -> str
+        return self.config[CONF_ESPHOME][CONF_ARDUINO_VERSION]
+
+    @property
+    def config_dir(self):
+        return os.path.dirname(self.config_path)
+
+    @property
+    def config_filename(self):
+        return os.path.basename(self.config_path)
+
+    def relative_path(self, *path):
+        path_ = os.path.expanduser(os.path.join(*path))
+        return os.path.join(self.config_dir, path_)
+
+    def relative_build_path(self, *path):
+        path_ = os.path.expanduser(os.path.join(*path))
+        return os.path.join(self.build_path, path_)
+
+    def relative_pioenvs_path(self, *path):
+        if is_hassio():
+            return os.path.join('/data', self.name, '.pioenvs', *path)
+        return self.relative_build_path('.pioenvs', *path)
+
+    def relative_piolibdeps_path(self, *path):
+        if is_hassio():
+            return os.path.join('/data', self.name, '.piolibdeps', *path)
+        return self.relative_build_path('.piolibdeps', *path)
+
+    @property
+    def firmware_bin(self):
+        return self.relative_pioenvs_path(self.name, 'firmware.bin')
+
+    @property
+    def is_esp8266(self):
+        if self.esp_platform is None:
+            raise ValueError
+        return self.esp_platform == ESP_PLATFORM_ESP8266
+
+    @property
+    def is_esp32(self):
+        if self.esp_platform is None:
+            raise ValueError
+        return self.esp_platform == ESP_PLATFORM_ESP32
+
+    def add_job(self, func, *args, **kwargs):
+        domain = kwargs.get('domain')
+        if inspect.isgeneratorfunction(func):
+            def func_():
+                yield
+                for _ in func(*args):
+                    yield
+        else:
+            def func_():
+                yield
+                func(*args)
+        gen = func_()
+        self.pending_tasks.append((gen, domain))
+        return gen
+
+    def flush_tasks(self):
+        i = 0
+        while self.pending_tasks:
+            i += 1
+            if i > 1000000:
+                raise EsphomeError("Circular dependency detected!")
+
+            task, domain = self.pending_tasks.popleft()
+            _LOGGER.debug("Executing task for domain=%s", domain)
+            try:
+                next(task)
+                self.pending_tasks.append((task, domain))
+            except StopIteration:
+                _LOGGER.debug(" -> %s finished", domain)
+
+    def add(self, expression, require=True):
+        from esphome.cpp_generator import Expression
+
+        if require and isinstance(expression, Expression):
+            expression.require()
+        self.expressions.append(expression)
+        _LOGGER.debug("Adding: %s", expression)
+        return expression
+
+    def get_variable(self, id):
+        while True:
+            if id in self.variables:
+                yield self.variables[id]
+                return
+            _LOGGER.debug("Waiting for variable %s", id)
+            yield None
+
+    def get_variable_with_full_id(self, id):
+        while True:
+            if id in self.variables:
+                for k, v in self.variables.items():
+                    if k == id:
+                        yield (k, v)
+                        return
+            _LOGGER.debug("Waiting for variable %s", id)
+            yield None, None
+
+    def register_variable(self, id, obj):
+        if id in self.variables:
+            raise EsphomeError("ID {} is already registered".format(id))
+        _LOGGER.debug("Registered variable %s of type %s", id.id, id.type)
+        self.variables[id] = obj
+
+    def has_id(self, id):
+        return id in self.variables
+
+
+CORE = EsphomeCore()
+
+ConfigType = Dict[str, Any]
+CoreType = EsphomeCore

esphome/core_config.py

@@ -1,39 +1,40 @@
 import logging
 import os
 import re
-import subprocess
 
 import voluptuous as vol
 
-from esphomeyaml import automation, core, pins
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import ARDUINO_VERSION_ESP32_DEV, ARDUINO_VERSION_ESP8266_DEV, \
+from esphome import automation, pins
+import esphome.config_validation as cv
+from esphome.const import ARDUINO_VERSION_ESP32_DEV, ARDUINO_VERSION_ESP8266_DEV, \
     CONF_ARDUINO_VERSION, CONF_BOARD, CONF_BOARD_FLASH_MODE, CONF_BRANCH, CONF_BUILD_PATH, \
-    CONF_COMMIT, CONF_ESPHOMELIB_VERSION, CONF_ESPHOMEYAML, CONF_LOCAL, CONF_NAME, CONF_ON_BOOT, \
-    CONF_ON_LOOP, CONF_ON_SHUTDOWN, CONF_PLATFORM, CONF_PRIORITY, CONF_REPOSITORY, CONF_TAG, \
-    CONF_TRIGGER_ID, CONF_USE_CUSTOM_CODE, ESPHOMELIB_VERSION, ESP_PLATFORM_ESP32, \
-    ESP_PLATFORM_ESP8266
-from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, NoArg, Pvariable, RawExpression, add, const_char_p, \
-    esphomelib_ns, relative_path
-from esphomeyaml.util import safe_print
+    CONF_COMMIT, CONF_ESPHOME, CONF_ESPHOME_CORE_VERSION, CONF_INCLUDES, CONF_LIBRARIES, \
+    CONF_LOCAL, CONF_NAME, CONF_ON_BOOT, CONF_ON_LOOP, CONF_ON_SHUTDOWN, CONF_PLATFORM, \
+    CONF_PLATFORMIO_OPTIONS, CONF_PRIORITY, CONF_REPOSITORY, CONF_TAG, CONF_TRIGGER_ID, \
+    CONF_USE_CUSTOM_CODE, ESPHOME_CORE_VERSION, ESP_PLATFORM_ESP32, ESP_PLATFORM_ESP8266, \
+    CONF_ESP8266_RESTORE_FROM_FLASH
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import Pvariable, RawExpression, add
+from esphome.cpp_types import App, const_char_ptr, esphome_ns
+from esphome.py_compat import text_type
 
 _LOGGER = logging.getLogger(__name__)
 
-LIBRARY_URI_REPO = u'https://github.com/OttoWinter/esphomelib.git'
+LIBRARY_URI_REPO = u'https://github.com/esphome/esphome-core.git'
+GITHUB_ARCHIVE_ZIP = u'https://github.com/esphome/esphome-core/archive/{}.zip'
 
 BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
-StartupTrigger = esphomelib_ns.StartupTrigger
-ShutdownTrigger = esphomelib_ns.ShutdownTrigger
-LoopTrigger = esphomelib_ns.LoopTrigger
+StartupTrigger = esphome_ns.StartupTrigger
+ShutdownTrigger = esphome_ns.ShutdownTrigger
+LoopTrigger = esphome_ns.LoopTrigger
 
-VERSION_REGEX = re.compile(r'^[0-9]+\.[0-9]+\.[0-9]+(?:-beta)?(?:-alpha)?$')
+VERSION_REGEX = re.compile(r'^[0-9]+\.[0-9]+\.[0-9]+(?:[ab]\d+)?$')
 
 
 def validate_board(value):
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    if CORE.is_esp8266:
         board_pins = pins.ESP8266_BOARD_PINS
-    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    elif CORE.is_esp32:
         board_pins = pins.ESP32_BOARD_PINS
     else:
         raise NotImplementedError
@@ -44,35 +45,35 @@ def validate_board(value):
     return value
 
 
-def validate_simple_esphomelib_version(value):
+def validate_simple_esphome_core_version(value):
     value = cv.string_strict(value)
     if value.upper() == 'LATEST':
-        if ESPHOMELIB_VERSION == 'dev':
-            return validate_simple_esphomelib_version('dev')
+        if ESPHOME_CORE_VERSION == 'dev':
+            return validate_simple_esphome_core_version('dev')
         return {
             CONF_REPOSITORY: LIBRARY_URI_REPO,
-            CONF_TAG: 'v' + ESPHOMELIB_VERSION,
+            CONF_TAG: 'v' + ESPHOME_CORE_VERSION,
         }
-    elif value.upper() == 'DEV':
+    if value.upper() == 'DEV':
         return {
             CONF_REPOSITORY: LIBRARY_URI_REPO,
             CONF_BRANCH: 'dev'
         }
-    elif VERSION_REGEX.match(value) is not None:
+    if VERSION_REGEX.match(value) is not None:
         return {
             CONF_REPOSITORY: LIBRARY_URI_REPO,
             CONF_TAG: 'v' + value,
         }
-    raise vol.Invalid("Only simple esphomelib versions!")
+    raise vol.Invalid("Only simple esphome core versions!")
 
 
-def validate_local_esphomelib_version(value):
+def validate_local_esphome_core_version(value):
     value = cv.directory(value)
-    path = relative_path(value)
+    path = CORE.relative_path(value)
     library_json = os.path.join(path, 'library.json')
     if not os.path.exists(library_json):
         raise vol.Invalid(u"Could not find '{}' file. '{}' does not seem to point to an "
-                          u"esphomelib copy.".format(library_json, value))
+                          u"esphome-core copy.".format(library_json, value))
     return value
 
 
@@ -83,13 +84,13 @@ def validate_commit(value):
     return value
 
 
-ESPHOMELIB_VERSION_SCHEMA = vol.Any(
-    validate_simple_esphomelib_version,
-    vol.Schema({
-        vol.Required(CONF_LOCAL): validate_local_esphomelib_version,
+ESPHOME_CORE_VERSION_SCHEMA = vol.Any(
+    validate_simple_esphome_core_version,
+    cv.Schema({
+        vol.Required(CONF_LOCAL): validate_local_esphome_core_version,
     }),
     vol.All(
-        vol.Schema({
+        cv.Schema({
             vol.Optional(CONF_REPOSITORY, default=LIBRARY_URI_REPO): cv.string,
             vol.Optional(CONF_COMMIT): validate_commit,
             vol.Optional(CONF_BRANCH): cv.string,
@@ -112,18 +113,20 @@ def validate_platform(value):
 
 
 PLATFORMIO_ESP8266_LUT = {
+    '2.5.0': 'espressif8266@2.0.1',
     '2.4.2': 'espressif8266@1.8.0',
     '2.4.1': 'espressif8266@1.7.3',
     '2.4.0': 'espressif8266@1.6.0',
     '2.3.0': 'espressif8266@1.5.0',
-    'RECOMMENDED': 'espressif8266@>=1.8.0',
+    'RECOMMENDED': 'espressif8266@1.8.0',
     'LATEST': 'espressif8266',
     'DEV': ARDUINO_VERSION_ESP8266_DEV,
 }
 
 PLATFORMIO_ESP32_LUT = {
     '1.0.0': 'espressif32@1.4.0',
-    'RECOMMENDED': 'espressif32@>=1.4.0',
+    '1.0.1': 'espressif32@1.6.0',
+    'RECOMMENDED': 'espressif32@1.6.0',
     'LATEST': 'espressif32',
     'DEV': ARDUINO_VERSION_ESP32_DEV,
 }
@@ -132,7 +135,7 @@ PLATFORMIO_ESP32_LUT = {
 def validate_arduino_version(value):
     value = cv.string_strict(value)
     value_ = value.upper()
-    if core.ESP_PLATFORM == ESP_PLATFORM_ESP8266:
+    if CORE.is_esp8266:
         if VERSION_REGEX.match(value) is not None and value_ not in PLATFORMIO_ESP8266_LUT:
             raise vol.Invalid("Unfortunately the arduino framework version '{}' is unsupported "
                               "at this time. You can override this by manually using "
@@ -140,7 +143,7 @@ def validate_arduino_version(value):
         if value_ in PLATFORMIO_ESP8266_LUT:
             return PLATFORMIO_ESP8266_LUT[value_]
         return value
-    elif core.ESP_PLATFORM == ESP_PLATFORM_ESP32:
+    if CORE.is_esp32:
         if VERSION_REGEX.match(value) is not None and value_ not in PLATFORMIO_ESP32_LUT:
             raise vol.Invalid("Unfortunately the arduino framework version '{}' is unsupported "
                               "at this time. You can override this by manually using "
@@ -148,28 +151,31 @@ def validate_arduino_version(value):
         if value_ in PLATFORMIO_ESP32_LUT:
             return PLATFORMIO_ESP32_LUT[value_]
         return value
-    else:
-        raise NotImplementedError
+    raise NotImplementedError
 
 
 def default_build_path():
-    return core.NAME
+    return CORE.name
 
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = cv.Schema({
     vol.Required(CONF_NAME): cv.valid_name,
-    vol.Required(CONF_PLATFORM): vol.All(vol.Upper, cv.one_of('ESP8266', 'ESPRESSIF8266',
-                                                              'ESP32', 'ESPRESSIF32')),
+    vol.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESPRESSIF8266', 'ESP32', 'ESPRESSIF32',
+                                           upper=True),
     vol.Required(CONF_BOARD): validate_board,
-    vol.Optional(CONF_ESPHOMELIB_VERSION, default='latest'): ESPHOMELIB_VERSION_SCHEMA,
+    vol.Optional(CONF_ESPHOME_CORE_VERSION, default='latest'): ESPHOME_CORE_VERSION_SCHEMA,
     vol.Optional(CONF_ARDUINO_VERSION, default='recommended'): validate_arduino_version,
     vol.Optional(CONF_USE_CUSTOM_CODE, default=False): cv.boolean,
     vol.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
+    vol.Optional(CONF_PLATFORMIO_OPTIONS): cv.Schema({
+        cv.string_strict: vol.Any([cv.string], cv.string),
+    }),
+    vol.Optional(CONF_ESP8266_RESTORE_FROM_FLASH): vol.All(cv.only_on_esp8266, cv.boolean),
 
-    vol.Optional(CONF_BOARD_FLASH_MODE): vol.All(vol.Lower, cv.one_of(*BUILD_FLASH_MODES)),
+    vol.Optional(CONF_BOARD_FLASH_MODE, default='dout'): cv.one_of(*BUILD_FLASH_MODES, lower=True),
     vol.Optional(CONF_ON_BOOT): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger),
-        vol.Optional(CONF_PRIORITY): vol.Coerce(float),
+        vol.Optional(CONF_PRIORITY): cv.float_,
     }),
     vol.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ShutdownTrigger),
@@ -177,72 +183,37 @@ CONFIG_SCHEMA = vol.Schema({
     vol.Optional(CONF_ON_LOOP): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(LoopTrigger),
     }),
+    vol.Optional(CONF_INCLUDES): cv.ensure_list(cv.file_),
+    vol.Optional(CONF_LIBRARIES): cv.ensure_list(cv.string_strict),
 
-    vol.Optional('library_uri'): cv.invalid("The library_uri option has been removed in 1.8.0 and "
-                                            "was moved into the esphomelib_version option."),
-    vol.Optional('use_build_flags'): cv.invalid("The use_build_flags option has been replaced by "
-                                                "use_custom_code option in 1.8.0."),
+    vol.Optional('esphomelib_version'): cv.invalid("The esphomelib_version has been renamed to "
+                                                   "esphome_core_version in 1.11.0"),
 })
 
 
 def preload_core_config(config):
-    if CONF_ESPHOMEYAML not in config:
-        raise ESPHomeYAMLError(u"No esphomeyaml section in config")
-    core_conf = config[CONF_ESPHOMEYAML]
+    if 'esphomeyaml' in config:
+        _LOGGER.warning("The esphomeyaml section has been renamed to esphome in 1.11.0. "
+                        "Please replace 'esphomeyaml:' in your configuration with 'esphome:'.")
+        config[CONF_ESPHOME] = config.pop('esphomeyaml')
+    if CONF_ESPHOME not in config:
+        raise EsphomeError(u"No esphome section in config")
+    core_conf = config[CONF_ESPHOME]
     if CONF_PLATFORM not in core_conf:
-        raise ESPHomeYAMLError("esphomeyaml.platform not specified.")
+        raise EsphomeError("esphome.platform not specified.")
     if CONF_BOARD not in core_conf:
-        raise ESPHomeYAMLError("esphomeyaml.board not specified.")
+        raise EsphomeError("esphome.board not specified.")
     if CONF_NAME not in core_conf:
-        raise ESPHomeYAMLError("esphomeyaml.name not specified.")
+        raise EsphomeError("esphome.name not specified.")
 
     try:
-        core.ESP_PLATFORM = validate_platform(core_conf[CONF_PLATFORM])
-        core.BOARD = validate_board(core_conf[CONF_BOARD])
-        core.NAME = cv.valid_name(core_conf[CONF_NAME])
+        CORE.esp_platform = validate_platform(core_conf[CONF_PLATFORM])
+        CORE.board = validate_board(core_conf[CONF_BOARD])
+        CORE.name = cv.valid_name(core_conf[CONF_NAME])
+        CORE.build_path = CORE.relative_path(
+            cv.string(core_conf.get(CONF_BUILD_PATH, default_build_path())))
     except vol.Invalid as e:
-        raise ESPHomeYAMLError(unicode(e))
-
-
-def run_command(*args):
-    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    stdout, stderr = p.communicate()
-    rc = p.returncode
-    return rc, stdout, stderr
-
-
-def update_esphomelib_repo(config):
-    esphomelib_version = config[CONF_ESPHOMELIB_VERSION]
-    if CONF_REPOSITORY not in esphomelib_version:
-        return
-
-    build_path = relative_path(config[CONF_BUILD_PATH])
-    esphomelib_path = os.path.join(build_path, '.piolibdeps', 'esphomelib')
-    is_default_branch = all(x not in esphomelib_version
-                            for x in (CONF_BRANCH, CONF_TAG, CONF_COMMIT))
-    if not (CONF_BRANCH in esphomelib_version or is_default_branch):
-        # Git commit hash or tag cannot be updated
-        return
-
-    rc, _, _ = run_command('git', '-C', esphomelib_path, '--help')
-    if rc != 0:
-        # git not installed or repo not downloaded yet
-        return
-    rc, _, _ = run_command('git', '-C', esphomelib_path, 'diff-index', '--quiet', 'HEAD', '--')
-    if rc != 0:
-        # local changes, cannot update
-        _LOGGER.warn("Local changes in esphomelib copy from git. Will not auto-update.")
-        return
-    _LOGGER.info("Updating esphomelib copy from git (%s)", esphomelib_path)
-    rc, stdout, _ = run_command('git', '-c', 'color.ui=always', '-C', esphomelib_path,
-                                'pull', '--stat')
-    if rc != 0:
-        _LOGGER.warn("Couldn't auto-update local git copy of esphomelib.")
-        return
-    stdout = stdout.strip()
-    if 'Already up to date' in stdout:
-        return
-    safe_print(stdout)
+        raise EsphomeError(text_type(e))
 
 
 def to_code(config):
@@ -251,17 +222,34 @@ def to_code(config):
     for conf in config.get(CONF_ON_BOOT, []):
         rhs = App.register_component(StartupTrigger.new(conf.get(CONF_PRIORITY)))
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
+        automation.build_automations(trigger, [], conf)
 
     for conf in config.get(CONF_ON_SHUTDOWN, []):
         trigger = Pvariable(conf[CONF_TRIGGER_ID], ShutdownTrigger.new())
-        automation.build_automation(trigger, const_char_p, conf)
+        automation.build_automations(trigger, [(const_char_ptr, 'x')], conf)
 
     for conf in config.get(CONF_ON_LOOP, []):
         rhs = App.register_component(LoopTrigger.new())
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, NoArg, conf)
-
-    update_esphomelib_repo(config)
+        automation.build_automations(trigger, [], conf)
 
     add(App.set_compilation_datetime(RawExpression('__DATE__ ", " __TIME__')))
+
+
+def lib_deps(config):
+    return set(config.get(CONF_LIBRARIES, []))
+
+
+def includes(config):
+    ret = []
+    for include in config.get(CONF_INCLUDES, []):
+        path = CORE.relative_path(include)
+        res = os.path.relpath(path, CORE.relative_build_path('src'))
+        ret.append(u'#include "{}"'.format(res))
+    return ret
+
+
+def required_build_flags(config):
+    if config.get(CONF_ESP8266_RESTORE_FROM_FLASH, False):
+        return ['-DUSE_ESP8266_PREFERENCES_FLASH']
+    return []

esphome/cpp_generator.py

@@ -1,47 +1,13 @@
-from __future__ import print_function
+from collections import OrderedDict
 
-from collections import OrderedDict, deque
-import inspect
-import logging
-import os
+from esphome.core import CORE, HexInt, Lambda, TimePeriod, TimePeriodMicroseconds, \
+    TimePeriodMilliseconds, TimePeriodSeconds, TimePeriodMinutes
+from esphome.helpers import cpp_string_escape, indent_all_but_first_and_last
 
-from esphomeyaml import core
-from esphomeyaml.const import CONF_AVAILABILITY, CONF_COMMAND_TOPIC, CONF_DISCOVERY, \
-    CONF_INVERTED, \
-    CONF_MODE, CONF_NUMBER, CONF_PAYLOAD_AVAILABLE, CONF_PAYLOAD_NOT_AVAILABLE, CONF_PCF8574, \
-    CONF_RETAIN, CONF_STATE_TOPIC, CONF_TOPIC, CONF_SETUP_PRIORITY
-from esphomeyaml.core import ESPHomeYAMLError, HexInt, Lambda, TimePeriodMicroseconds, \
-    TimePeriodMilliseconds, TimePeriodSeconds
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def ensure_unique_string(preferred_string, current_strings):
-    test_string = preferred_string
-    current_strings_set = set(current_strings)
-
-    tries = 1
-
-    while test_string in current_strings_set:
-        tries += 1
-        test_string = u"{}_{}".format(preferred_string, tries)
-
-    return test_string
-
-
-def indent_all_but_first_and_last(text, padding=u'  '):
-    lines = text.splitlines(True)
-    if len(lines) <= 2:
-        return text
-    return lines[0] + u''.join(padding + line for line in lines[1:-1]) + lines[-1]
-
-
-def indent_list(text, padding=u'  '):
-    return [padding + line for line in text.splitlines()]
-
-
-def indent(text, padding=u'  '):
-    return u'\n'.join(indent_list(text, padding))
+# pylint: disable=unused-import, wrong-import-order
+from typing import Any, Generator, List, Optional, Tuple, Union  # noqa
+from esphome.core import ID  # noqa
+from esphome.py_compat import text_type, string_types, integer_types
 
 
 class Expression(object):
@@ -63,8 +29,11 @@ class Expression(object):
         return self.required
 
 
+SafeExpType = Union[Expression, bool, str, text_type, int, float, TimePeriod]
+
+
 class RawExpression(Expression):
-    def __init__(self, text):
+    def __init__(self, text):  # type: (Union[str, unicode]) -> None
         super(RawExpression, self).__init__()
         self.text = text
 
@@ -105,12 +74,12 @@ class ExpressionList(Expression):
             self.args.append(exp)
 
     def __str__(self):
-        text = u", ".join(unicode(x) for x in self.args)
+        text = u", ".join(text_type(x) for x in self.args)
         return indent_all_but_first_and_last(text)
 
 
 class TemplateArguments(Expression):
-    def __init__(self, *args):
+    def __init__(self, *args):  # type: (*SafeExpType) -> None
         super(TemplateArguments, self).__init__()
         self.args = ExpressionList(*args)
         self.requires.append(self.args)
@@ -120,7 +89,7 @@ class TemplateArguments(Expression):
 
 
 class CallExpression(Expression):
-    def __init__(self, base, *args):
+    def __init__(self, base, *args):  # type: (Expression, *SafeExpType) -> None
         super(CallExpression, self).__init__()
         self.base = base
         if args and isinstance(args[0], TemplateArguments):
@@ -139,7 +108,7 @@ class CallExpression(Expression):
 
 
 class StructInitializer(Expression):
-    def __init__(self, base, *args):
+    def __init__(self, base, *args):  # type: (Expression, *Tuple[str, SafeExpType]) -> None
         super(StructInitializer, self).__init__()
         self.base = base
         if isinstance(base, Expression):
@@ -147,7 +116,7 @@ class StructInitializer(Expression):
         if not isinstance(args, OrderedDict):
             args = OrderedDict(args)
         self.args = OrderedDict()
-        for key, value in args.iteritems():
+        for key, value in args.items():
             if value is None:
                 continue
             exp = safe_exp(value)
@@ -156,16 +125,16 @@ class StructInitializer(Expression):
 
     def __str__(self):
         cpp = u'{}{{\n'.format(self.base)
-        for key, value in self.args.iteritems():
+        for key, value in self.args.items():
             cpp += u'  .{} = {},\n'.format(key, value)
         cpp += u'}'
         return cpp
 
 
 class ArrayInitializer(Expression):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):  # type: (*Any, **Any) -> None
         super(ArrayInitializer, self).__init__()
-        self.multiline = kwargs.get('multiline', True)
+        self.multiline = kwargs.get('multiline', False)
         self.args = []
         for arg in args:
             if arg is None:
@@ -187,7 +156,6 @@ class ArrayInitializer(Expression):
         return cpp
 
 
-# pylint: disable=invalid-name
 class ParameterExpression(Expression):
     def __init__(self, type, id):
         super(ParameterExpression, self).__init__()
@@ -209,7 +177,7 @@ class ParameterListExpression(Expression):
             self.requires.append(parameter)
 
     def __str__(self):
-        return u", ".join(unicode(x) for x in self.parameters)
+        return u", ".join(text_type(x) for x in self.parameters)
 
 
 class LambdaExpression(Expression):
@@ -236,7 +204,7 @@ class LambdaExpression(Expression):
 
     @property
     def content(self):
-        return u''.join(unicode(part) for part in self.parts)
+        return u''.join(text_type(part) for part in self.parts)
 
 
 class Literal(Expression):
@@ -244,21 +212,8 @@ class Literal(Expression):
         raise NotImplementedError
 
 
-# From https://stackoverflow.com/a/14945195/8924614
-def cpp_string_escape(string, encoding='utf-8'):
-    if isinstance(string, unicode):
-        string = string.encode(encoding)
-    result = ''
-    for character in string:
-        if not (32 <= ord(character) < 127) or character in ('\\', '"'):
-            result += '\\%03o' % ord(character)
-        else:
-            result += character
-    return '"' + result + '"'
-
-
 class StringLiteral(Literal):
-    def __init__(self, string):
+    def __init__(self, string):  # type: (Union[str, unicode]) -> None
         super(StringLiteral, self).__init__()
         self.string = string
 
@@ -267,7 +222,7 @@ class StringLiteral(Literal):
 
 
 class IntLiteral(Literal):
-    def __init__(self, i):
+    def __init__(self, i):  # type: (Union[int, long]) -> None
         super(IntLiteral, self).__init__()
         self.i = i
 
@@ -278,11 +233,11 @@ class IntLiteral(Literal):
             return u'{}UL'.format(self.i)
         if self.i < -2147483648:
             return u'{}LL'.format(self.i)
-        return unicode(self.i)
+        return text_type(self.i)
 
 
 class BoolLiteral(Literal):
-    def __init__(self, binary):
+    def __init__(self, binary):  # type: (bool) -> None
         super(BoolLiteral, self).__init__()
         self.binary = binary
 
@@ -291,7 +246,7 @@ class BoolLiteral(Literal):
 
 
 class HexIntLiteral(Literal):
-    def __init__(self, i):
+    def __init__(self, i):  # type: (int) -> None
         super(HexIntLiteral, self).__init__()
         self.i = HexInt(i)
 
@@ -300,7 +255,7 @@ class HexIntLiteral(Literal):
 
 
 class FloatLiteral(Literal):
-    def __init__(self, value):
+    def __init__(self, value):  # type: (float) -> None
         super(FloatLiteral, self).__init__()
         self.float_ = value
 
@@ -308,25 +263,33 @@ class FloatLiteral(Literal):
         return u"{:f}f".format(self.float_)
 
 
-def safe_exp(obj):
+# pylint: disable=bad-continuation
+def safe_exp(
+        obj  # type: Union[Expression, bool, str, unicode, int, long, float, TimePeriod, list]
+             ):
+    # type: (...) -> Expression
     if isinstance(obj, Expression):
         return obj
-    elif isinstance(obj, bool):
+    if isinstance(obj, bool):
         return BoolLiteral(obj)
-    elif isinstance(obj, (str, unicode)):
+    if isinstance(obj, string_types):
         return StringLiteral(obj)
-    elif isinstance(obj, HexInt):
+    if isinstance(obj, HexInt):
         return HexIntLiteral(obj)
-    elif isinstance(obj, (int, long)):
+    if isinstance(obj, integer_types):
         return IntLiteral(obj)
-    elif isinstance(obj, float):
+    if isinstance(obj, float):
         return FloatLiteral(obj)
-    elif isinstance(obj, TimePeriodMicroseconds):
+    if isinstance(obj, TimePeriodMicroseconds):
         return IntLiteral(int(obj.total_microseconds))
-    elif isinstance(obj, TimePeriodMilliseconds):
+    if isinstance(obj, TimePeriodMilliseconds):
         return IntLiteral(int(obj.total_milliseconds))
-    elif isinstance(obj, TimePeriodSeconds):
+    if isinstance(obj, TimePeriodSeconds):
         return IntLiteral(int(obj.total_seconds))
+    if isinstance(obj, TimePeriodMinutes):
+        return IntLiteral(int(obj.total_minutes))
+    if isinstance(obj, (tuple, list)):
+        return ArrayInitializer(*[safe_exp(o) for o in obj])
     raise ValueError(u"Object is not an expression", obj)
 
 
@@ -356,30 +319,54 @@ class ExpressionStatement(Statement):
         return u"{};".format(self.expression)
 
 
-def statement(expression):
+class ProgmemAssignmentExpression(AssignmentExpression):
+    def __init__(self, type, name, rhs, obj):
+        super(ProgmemAssignmentExpression, self).__init__(
+            type, '', name, rhs, obj
+        )
+
+    def __str__(self):
+        type_ = self.type
+        return u"static const {} {}[] PROGMEM = {}".format(type_, self.name, self.rhs)
+
+
+def progmem_array(id, rhs):
+    rhs = safe_exp(rhs)
+    obj = MockObj(id, u'.')
+    assignment = ProgmemAssignmentExpression(id.type, id, rhs, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
+    obj.requires.append(assignment)
+    return obj
+
+
+def statement(expression):  # type: (Union[Expression, Statement]) -> Statement
     if isinstance(expression, Statement):
         return expression
     return ExpressionStatement(expression)
 
 
-def register_variable(id, obj):
-    _LOGGER.debug("Registered variable %s of type %s", id.id, id.type)
-    _VARIABLES[id] = obj
-
-
-# pylint: disable=redefined-builtin, invalid-name
-def variable(id, rhs, type=None):
+def variable(id,  # type: ID
+             rhs,  # type: Expression
+             type=None  # type: MockObj
+             ):
+    # type: (...) -> MockObj
     rhs = safe_exp(rhs)
     obj = MockObj(id, u'.')
     id.type = type or id.type
     assignment = AssignmentExpression(id.type, '', id, rhs, obj)
-    add(assignment)
-    register_variable(id, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
     obj.requires.append(assignment)
     return obj
 
 
-def Pvariable(id, rhs, has_side_effects=True, type=None):
+def Pvariable(id,  # type: ID
+              rhs,  # type: Expression
+              has_side_effects=True,  # type: bool
+              type=None  # type: MockObj
+              ):
+    # type: (...) -> MockObj
     rhs = safe_exp(rhs)
     if not has_side_effects and hasattr(rhs, '_has_side_effects'):
         # pylint: disable=attribute-defined-outside-init, protected-access
@@ -387,45 +374,39 @@ def Pvariable(id, rhs, has_side_effects=True, type=None):
     obj = MockObj(id, u'->', has_side_effects=has_side_effects)
     id.type = type or id.type
     assignment = AssignmentExpression(id.type, '*', id, rhs, obj)
-    add(assignment)
-    register_variable(id, obj)
+    CORE.add(assignment)
+    CORE.register_variable(id, obj)
     obj.requires.append(assignment)
     return obj
 
 
-_TASKS = deque()
-_VARIABLES = {}
-_EXPRESSIONS = []
+def add(expression,  # type: Union[Expression, Statement]
+        require=True  # type: bool
+        ):
+    # type: (...) -> None
+    CORE.add(expression, require=require)
 
 
-def get_variable(id):
-    while True:
-        if id in _VARIABLES:
-            yield _VARIABLES[id]
-            return
-        _LOGGER.debug("Waiting for variable %s", id)
+def get_variable(id):  # type: (ID) -> Generator[MockObj]
+    for var in CORE.get_variable(id):
         yield None
+    yield var
 
 
-def get_variable_with_full_id(id):
-    while True:
-        for k, v in _VARIABLES.iteritems():
-            if k == id:
-                yield (k, v)
-                return
-        _LOGGER.debug("Waiting for variable %s", id)
-        yield None, None
-
-
-def process_lambda(value, parameters, capture='=', return_type=None):
-    from esphomeyaml.components.globals import GlobalVariableComponent
+def process_lambda(value,  # type: Lambda
+                   parameters,  # type: List[Tuple[Expression, str]]
+                   capture='=',  # type: str
+                   return_type=None  # type: Optional[Expression]
+                   ):
+    # type: (...) -> Generator[LambdaExpression]
+    from esphome.components.globals import GlobalVariableComponent
 
     if value is None:
         yield
         return
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
-        for full_id, var in get_variable_with_full_id(id):
+        for full_id, var in CORE.get_variable_with_full_id(id):
             yield
         if full_id is not None and isinstance(full_id.type, MockObjClass) and \
                 full_id.type.inherits_from(GlobalVariableComponent):
@@ -440,56 +421,18 @@ def process_lambda(value, parameters, capture='=', return_type=None):
     yield LambdaExpression(parts, parameters, capture, return_type)
 
 
-def templatable(value, input_type, output_type):
+def templatable(value,  # type: Any
+                args,  # type: List[Tuple[Expression, str]]
+                output_type  # type: Optional[Expression]
+                ):
     if isinstance(value, Lambda):
-        lambda_ = None
-        for lambda_ in process_lambda(value, [(input_type, 'x')], return_type=output_type):
+        for lambda_ in process_lambda(value, args, return_type=output_type):
             yield None
         yield lambda_
     else:
         yield value
 
 
-def add_job(func, *args, **kwargs):
-    domain = kwargs.get('domain')
-    if inspect.isgeneratorfunction(func):
-        def func_():
-            yield
-            for _ in func(*args):
-                yield
-    else:
-        def func_():
-            yield
-            func(*args)
-    gen = func_()
-    _TASKS.append((gen, domain))
-    return gen
-
-
-def flush_tasks():
-    i = 0
-    while _TASKS:
-        i += 1
-        if i > 1000000:
-            raise ESPHomeYAMLError("Circular dependency detected!")
-
-        task, domain = _TASKS.popleft()
-        _LOGGER.debug("Executing task for domain=%s", domain)
-        try:
-            task.next()
-            _TASKS.append((task, domain))
-        except StopIteration:
-            _LOGGER.debug(" -> %s finished", domain)
-
-
-def add(expression, require=True):
-    if require and isinstance(expression, Expression):
-        expression.require()
-    _EXPRESSIONS.append(expression)
-    _LOGGER.debug("Adding: %s", statement(expression))
-    return expression
-
-
 class MockObj(Expression):
     def __init__(self, base, op=u'.', has_side_effects=True):
         self.base = base
@@ -497,7 +440,7 @@ class MockObj(Expression):
         self._has_side_effects = has_side_effects
         super(MockObj, self).__init__()
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr):  # type: (str) -> MockObj
         if attr == u'_':
             obj = MockObj(u'{}{}'.format(self.base, self.op))
             obj.requires.append(self)
@@ -516,65 +459,72 @@ class MockObj(Expression):
         obj.requires.append(self)
         return obj
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args, **kwargs):  # type: (*Any, **Any) -> MockObj
         call = CallExpression(self.base, *args)
         obj = MockObj(call, self.op)
         obj.requires.append(self)
         obj.requires.append(call)
         return obj
 
-    def __str__(self):
-        return unicode(self.base)
+    def __str__(self):  # type: () -> unicode
+        return text_type(self.base)
 
-    def require(self):
+    def require(self):  # type: () -> None
         self.required = True
         for require in self.requires:
             if require.required:
                 continue
             require.require()
 
-    def template(self, args):
-        if not isinstance(args, TemplateArguments):
-            args = TemplateArguments(args)
+    def template(self, *args):  # type: (Tuple[Union[TemplateArguments, Expression]]) -> MockObj
+        if len(args) != 1 or not isinstance(args[0], TemplateArguments):
+            args = TemplateArguments(*args)
+        else:
+            args = args[0]
         obj = MockObj(u'{}{}'.format(self.base, args))
         obj.requires.append(self)
         obj.requires.append(args)
         return obj
 
-    def namespace(self, name):
+    def namespace(self, name):  # type: (str) -> MockObj
         obj = MockObj(u'{}{}{}'.format(self.base, self.op, name), u'::')
         obj.requires.append(self)
         return obj
 
-    def class_(self, name, *parents):
-        obj = MockObjClass(u'{}::{}'.format(self.base, name), u'.', parents=parents)
+    def class_(self, name, *parents):  # type: (str, *MockObjClass) -> MockObjClass
+        op = '' if self.op == '' else '::'
+        obj = MockObjClass(u'{}{}{}'.format(self.base, op, name), u'.', parents=parents)
         obj.requires.append(self)
         return obj
 
-    def struct(self, name):
+    def struct(self, name):  # type: (str) -> MockObjClass
         return self.class_(name)
 
-    def enum(self, name, is_class=False):
+    def enum(self, name, is_class=False):  # type: (str, bool) -> MockObj
         if is_class:
             return self.namespace(name)
 
         return self
 
-    def operator(self, name):
+    def operator(self, name):  # type: (str) -> MockObj
         if name == 'ref':
             obj = MockObj(u'{} &'.format(self.base), u'')
             obj.requires.append(self)
             return obj
+        if name == 'ptr':
+            obj = MockObj(u'{} *'.format(self.base), u'')
+            obj.requires.append(self)
+            return obj
         if name == "const":
             obj = MockObj(u'const {}'.format(self.base), u'')
             obj.requires.append(self)
             return obj
-        raise NotImplementedError()
+        raise NotImplementedError
 
-    def has_side_effects(self):
+    def has_side_effects(self):  # type: () -> bool
         return self._has_side_effects
 
-    def __getitem__(self, item):
+    def __getitem__(self, item):  # type: (Union[str, Expression]) -> MockObj
         next_op = u'.'
         if isinstance(item, str) and item.startswith(u'P'):
             item = item[1:]
@@ -598,7 +548,7 @@ class MockObjClass(MockObj):
             # pylint: disable=protected-access
             self._parents += paren._parents
 
-    def inherits_from(self, other):
+    def inherits_from(self, other):  # type: (MockObjClass) -> bool
         if self == other:
             return True
         for parent in self._parents:
@@ -606,128 +556,17 @@ class MockObjClass(MockObj):
                 return True
         return False
 
-    def template(self, args):
-        if not isinstance(args, TemplateArguments):
-            args = TemplateArguments(args)
+    def template(self,
+                 *args  # type: Tuple[Union[TemplateArguments, Expression]]
+                 ):
+        # type: (...) -> MockObjClass
+        if len(args) != 1 or not isinstance(args[0], TemplateArguments):
+            args = TemplateArguments(*args)
+        else:
+            args = args[0]
         new_parents = self._parents[:]
         new_parents.append(self)
         obj = MockObjClass(u'{}{}'.format(self.base, args), parents=new_parents)
         obj.requires.append(self)
         obj.requires.append(args)
         return obj
-
-
-global_ns = MockObj('', '')
-float_ = global_ns.namespace('float')
-bool_ = global_ns.namespace('bool')
-std_ns = global_ns.namespace('std')
-std_string = std_ns.string
-uint8 = global_ns.namespace('uint8_t')
-uint16 = global_ns.namespace('uint16_t')
-uint32 = global_ns.namespace('uint32_t')
-int32 = global_ns.namespace('int32_t')
-const_char_p = global_ns.namespace('const char *')
-NAN = global_ns.namespace('NAN')
-esphomelib_ns = global_ns  # using namespace esphomelib;
-NoArg = esphomelib_ns.NoArg
-App = esphomelib_ns.App
-io_ns = esphomelib_ns.namespace('io')
-Nameable = esphomelib_ns.class_('Nameable')
-Trigger = esphomelib_ns.class_('Trigger')
-Action = esphomelib_ns.class_('Action')
-Component = esphomelib_ns.class_('Component')
-PollingComponent = esphomelib_ns.class_('PollingComponent', Component)
-Application = esphomelib_ns.class_('Application')
-optional = esphomelib_ns.class_('optional')
-arduino_json_ns = global_ns.namespace('ArduinoJson')
-JsonObject = arduino_json_ns.class_('JsonObject')
-JsonObjectRef = JsonObject.operator('ref')
-JsonObjectConstRef = JsonObjectRef.operator('const')
-Controller = esphomelib_ns.class_('Controller')
-StoringController = esphomelib_ns.class_('StoringController', Controller)
-
-GPIOPin = esphomelib_ns.class_('GPIOPin')
-GPIOOutputPin = esphomelib_ns.class_('GPIOOutputPin', GPIOPin)
-GPIOInputPin = esphomelib_ns.class_('GPIOInputPin', GPIOPin)
-
-
-def get_gpio_pin_number(conf):
-    if isinstance(conf, int):
-        return conf
-    return conf[CONF_NUMBER]
-
-
-def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
-    if conf is None:
-        return
-    number = conf[CONF_NUMBER]
-    inverted = conf.get(CONF_INVERTED)
-    if CONF_PCF8574 in conf:
-        hub = None
-        for hub in get_variable(conf[CONF_PCF8574]):
-            yield None
-        if default_mode == u'INPUT':
-            mode = conf.get(CONF_MODE, u'INPUT')
-            yield hub.make_input_pin(number,
-                                     RawExpression('PCF8574_' + mode),
-                                     inverted)
-            return
-        elif default_mode == u'OUTPUT':
-            yield hub.make_output_pin(number, inverted)
-            return
-        else:
-            raise ESPHomeYAMLError(u"Unknown default mode {}".format(default_mode))
-    if len(conf) == 1:
-        yield IntLiteral(number)
-        return
-    mode = RawExpression(conf.get(CONF_MODE, default_mode))
-    yield mock_obj(number, mode, inverted)
-
-
-def gpio_output_pin_expression(conf):
-    exp = None
-    for exp in generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT'):
-        yield None
-    yield exp
-
-
-def gpio_input_pin_expression(conf):
-    exp = None
-    for exp in generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT'):
-        yield None
-    yield exp
-
-
-def setup_mqtt_component(obj, config):
-    if CONF_RETAIN in config:
-        add(obj.set_retain(config[CONF_RETAIN]))
-    if not config.get(CONF_DISCOVERY, True):
-        add(obj.disable_discovery())
-    if CONF_STATE_TOPIC in config:
-        add(obj.set_custom_state_topic(config[CONF_STATE_TOPIC]))
-    if CONF_COMMAND_TOPIC in config:
-        add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
-    if CONF_AVAILABILITY in config:
-        availability = config[CONF_AVAILABILITY]
-        if not availability:
-            add(obj.disable_availability())
-        else:
-            add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
-                                     availability[CONF_PAYLOAD_NOT_AVAILABLE]))
-
-
-def setup_component(obj, config):
-    if CONF_SETUP_PRIORITY in config:
-        add(obj.set_setup_priority(config[CONF_SETUP_PRIORITY]))
-
-
-def color(the_color, message='', reset=None):
-    """Color helper."""
-    from colorlog.escape_codes import escape_codes, parse_colors
-    if not message:
-        return parse_colors(the_color)
-    return parse_colors(the_color) + message + escape_codes[reset or 'reset']
-
-
-def relative_path(path):
-    return os.path.join(os.path.dirname(core.CONFIG_PATH), os.path.expanduser(path))

esphome/cpp_helpers.py

@@ -0,0 +1,64 @@
+from esphome.const import CONF_INVERTED, CONF_MODE, CONF_NUMBER, CONF_PCF8574, \
+    CONF_SETUP_PRIORITY, CONF_MCP23017
+from esphome.core import CORE, EsphomeError
+from esphome.cpp_generator import IntLiteral, RawExpression
+from esphome.cpp_types import GPIOInputPin, GPIOOutputPin
+
+
+def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
+    if conf is None:
+        return
+    number = conf[CONF_NUMBER]
+    inverted = conf.get(CONF_INVERTED)
+    if CONF_PCF8574 in conf:
+        from esphome.components import pcf8574
+
+        for hub in CORE.get_variable(conf[CONF_PCF8574]):
+            yield None
+
+        if default_mode == u'INPUT':
+            mode = pcf8574.PCF8675_GPIO_MODES[conf.get(CONF_MODE, u'INPUT')]
+            yield hub.make_input_pin(number, mode, inverted)
+            return
+        if default_mode == u'OUTPUT':
+            yield hub.make_output_pin(number, inverted)
+            return
+
+        raise EsphomeError(u"Unknown default mode {}".format(default_mode))
+    if CONF_MCP23017 in conf:
+        from esphome.components import mcp23017
+
+        for hub in CORE.get_variable(conf[CONF_MCP23017]):
+            yield None
+
+        if default_mode == u'INPUT':
+            mode = mcp23017.MCP23017_GPIO_MODES[conf.get(CONF_MODE, u'INPUT')]
+            yield hub.make_input_pin(number, mode, inverted)
+            return
+        if default_mode == u'OUTPUT':
+            yield hub.make_output_pin(number, inverted)
+            return
+
+        raise EsphomeError(u"Unknown default mode {}".format(default_mode))
+    if len(conf) == 1:
+        yield IntLiteral(number)
+        return
+    mode = RawExpression(conf.get(CONF_MODE, default_mode))
+    yield mock_obj(number, mode, inverted)
+
+
+def gpio_output_pin_expression(conf):
+    for exp in generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT'):
+        yield None
+    yield exp
+
+
+def gpio_input_pin_expression(conf):
+    for exp in generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT'):
+        yield None
+    yield exp
+
+
+def setup_component(obj, config):
+    if CONF_SETUP_PRIORITY in config:
+        CORE.add(obj.set_setup_priority(config[CONF_SETUP_PRIORITY]))

esphome/cpp_types.py

@@ -0,0 +1,36 @@
+from esphome.cpp_generator import MockObj
+
+global_ns = MockObj('', '')
+void = global_ns.namespace('void')
+float_ = global_ns.namespace('float')
+bool_ = global_ns.namespace('bool')
+std_ns = global_ns.namespace('std')
+std_string = std_ns.class_('string')
+std_vector = std_ns.class_('vector')
+uint8 = global_ns.namespace('uint8_t')
+uint16 = global_ns.namespace('uint16_t')
+uint32 = global_ns.namespace('uint32_t')
+int32 = global_ns.namespace('int32_t')
+const_char_ptr = global_ns.namespace('const char *')
+NAN = global_ns.namespace('NAN')
+esphome_ns = global_ns  # using namespace esphome;
+App = esphome_ns.App
+io_ns = esphome_ns.namespace('io')
+Nameable = esphome_ns.class_('Nameable')
+Trigger = esphome_ns.class_('Trigger')
+Action = esphome_ns.class_('Action')
+Component = esphome_ns.class_('Component')
+ComponentPtr = Component.operator('ptr')
+PollingComponent = esphome_ns.class_('PollingComponent', Component)
+Application = esphome_ns.class_('Application')
+optional = esphome_ns.class_('optional')
+arduino_json_ns = global_ns.namespace('ArduinoJson')
+JsonObject = arduino_json_ns.class_('JsonObject')
+JsonObjectRef = JsonObject.operator('ref')
+JsonObjectConstRef = JsonObjectRef.operator('const')
+Controller = esphome_ns.class_('Controller')
+StoringController = esphome_ns.class_('StoringController', Controller)
+
+GPIOPin = esphome_ns.class_('GPIOPin')
+GPIOOutputPin = esphome_ns.class_('GPIOOutputPin', GPIOPin)
+GPIOInputPin = esphome_ns.class_('GPIOInputPin', GPIOPin)

esphome/dashboard/dashboard.py

@@ -0,0 +1,668 @@
+# pylint: disable=wrong-import-position
+from __future__ import print_function
+
+import codecs
+import collections
+import hashlib
+import hmac
+import json
+import logging
+import multiprocessing
+import os
+import shutil
+import subprocess
+import threading
+
+import tornado
+import tornado.concurrent
+import tornado.gen
+import tornado.httpserver
+import tornado.ioloop
+import tornado.iostream
+from tornado.log import access_log
+import tornado.netutil
+import tornado.process
+import tornado.web
+import tornado.websocket
+
+from esphome import const
+from esphome.__main__ import get_serial_ports
+from esphome.helpers import mkdir_p, get_bool_env, run_system_command
+from esphome.py_compat import IS_PY2
+from esphome.storage_json import EsphomeStorageJSON, StorageJSON, \
+    esphome_storage_path, ext_storage_path, trash_storage_path
+from esphome.util import shlex_quote
+
+# pylint: disable=unused-import, wrong-import-order
+from typing import Optional  # noqa
+
+from esphome.zeroconf import DashboardStatus, Zeroconf
+
+_LOGGER = logging.getLogger(__name__)
+CONFIG_DIR = ''
+PASSWORD_DIGEST = ''
+COOKIE_SECRET = None
+USING_PASSWORD = False
+ON_HASSIO = False
+USING_HASSIO_AUTH = True
+HASSIO_MQTT_CONFIG = None
+RELATIVE_URL = os.getenv('ESPHOME_DASHBOARD_RELATIVE_URL', '/')
+STATUS_USE_PING = get_bool_env('ESPHOME_DASHBOARD_USE_PING')
+
+if IS_PY2:
+    cookie_authenticated_yes = 'yes'
+else:
+    cookie_authenticated_yes = b'yes'
+
+
+def template_args():
+    version = const.__version__
+    return {
+        'version': version,
+        'docs_link': 'https://beta.esphome.io/' if 'b' in version else 'https://esphome.io/',
+        'get_static_file_url': get_static_file_url,
+        'relative_url': RELATIVE_URL,
+        'streamer_mode': get_bool_env('ESPHOME_STREAMER_MODE'),
+    }
+
+
+def authenticated(func):
+    def decorator(self, *args, **kwargs):
+        if not self.is_authenticated():
+            self.redirect(RELATIVE_URL + 'login')
+            return None
+        return func(self, *args, **kwargs)
+    return decorator
+
+
+def bind_config(func):
+    def decorator(self, *args, **kwargs):
+        configuration = self.get_argument('configuration')
+        if not is_allowed(configuration):
+            self.set_status(500)
+            return None
+        kwargs = kwargs.copy()
+        kwargs['configuration'] = configuration
+        return func(self, *args, **kwargs)
+    return decorator
+
+
+# pylint: disable=abstract-method
+class BaseHandler(tornado.web.RequestHandler):
+    def is_authenticated(self):
+        if USING_HASSIO_AUTH or USING_PASSWORD:
+            return self.get_secure_cookie('authenticated') == cookie_authenticated_yes
+
+        return True
+
+
+# pylint: disable=abstract-method, arguments-differ
+class EsphomeCommandWebSocket(tornado.websocket.WebSocketHandler):
+    def __init__(self, application, request, **kwargs):
+        super(EsphomeCommandWebSocket, self).__init__(application, request, **kwargs)
+        self.proc = None
+        self.closed = False
+
+    def on_message(self, message):
+        if USING_HASSIO_AUTH or USING_PASSWORD:
+            if self.get_secure_cookie('authenticated') != cookie_authenticated_yes:
+                return
+        if self.proc is not None:
+            return
+        command = self.build_command(message)
+        _LOGGER.info(u"Running command '%s'", ' '.join(shlex_quote(x) for x in command))
+        self.proc = tornado.process.Subprocess(command,
+                                               stdout=tornado.process.Subprocess.STREAM,
+                                               stderr=subprocess.STDOUT)
+        self.proc.set_exit_callback(self.proc_on_exit)
+        tornado.ioloop.IOLoop.current().spawn_callback(self.redirect_stream)
+
+    @tornado.gen.coroutine
+    def redirect_stream(self):
+        while True:
+            try:
+                if IS_PY2:
+                    reg = '[\n\r]'
+                else:
+                    reg = b'[\n\r]'
+                data = yield self.proc.stdout.read_until_regex(reg)
+                if not IS_PY2:
+                    data = data.decode('utf-8', 'backslashreplace')
+            except tornado.iostream.StreamClosedError:
+                break
+            try:
+                self.write_message({'event': 'line', 'data': data})
+            except UnicodeDecodeError:
+                data = codecs.decode(data, 'utf8', 'replace')
+                self.write_message({'event': 'line', 'data': data})
+
+    def proc_on_exit(self, returncode):
+        if not self.closed:
+            _LOGGER.debug("Process exited with return code %s", returncode)
+            self.write_message({'event': 'exit', 'code': returncode})
+
+    def on_close(self):
+        self.closed = True
+        if self.proc is not None and self.proc.returncode is None:
+            _LOGGER.debug("Terminating process")
+            self.proc.proc.terminate()
+
+    def build_command(self, message):
+        raise NotImplementedError
+
+
+class EsphomeLogsHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = CONFIG_DIR + '/' + js['configuration']
+        return ["esphome", "--dashboard", config_file, "logs", '--serial-port', js["port"]]
+
+
+class EsphomeRunHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "run", '--upload-port', js["port"]]
+
+
+class EsphomeCompileHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "compile"]
+
+
+class EsphomeValidateHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "config"]
+
+
+class EsphomeCleanMqttHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "clean-mqtt"]
+
+
+class EsphomeCleanHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "clean"]
+
+
+class EsphomeHassConfigHandler(EsphomeCommandWebSocket):
+    def build_command(self, message):
+        js = json.loads(message)
+        config_file = os.path.join(CONFIG_DIR, js['configuration'])
+        return ["esphome", "--dashboard", config_file, "hass-config"]
+
+
+class SerialPortRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        ports = get_serial_ports()
+        data = []
+        for port, desc in ports:
+            if port == '/dev/ttyAMA0':
+                desc = 'UART pins on GPIO header'
+            split_desc = desc.split(' - ')
+            if len(split_desc) == 2 and split_desc[0] == split_desc[1]:
+                # Some serial ports repeat their values
+                desc = split_desc[0]
+            data.append({'port': port, 'desc': desc})
+        data.append({'port': 'OTA', 'desc': 'Over-The-Air'})
+        data.sort(key=lambda x: x['port'], reverse=True)
+        self.write(json.dumps(data))
+
+
+class WizardRequestHandler(BaseHandler):
+    @authenticated
+    def post(self):
+        from esphome import wizard
+
+        kwargs = {k: ''.join(v) for k, v in self.request.arguments.items()}
+        destination = os.path.join(CONFIG_DIR, kwargs['name'] + '.yaml')
+        wizard.wizard_write(path=destination, **kwargs)
+        self.redirect('/?begin=True')
+
+
+class DownloadBinaryRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def get(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        storage_path = ext_storage_path(CONFIG_DIR, configuration)
+        storage_json = StorageJSON.load(storage_path)
+        if storage_json is None:
+            self.send_error()
+            return
+
+        path = storage_json.firmware_bin_path
+        self.set_header('Content-Type', 'application/octet-stream')
+        filename = '{}.bin'.format(storage_json.name)
+        self.set_header("Content-Disposition", 'attachment; filename="{}"'.format(filename))
+        with open(path, 'rb') as f:
+            while True:
+                data = f.read(16384)
+                if not data:
+                    break
+                self.write(data)
+        self.finish()
+
+
+def _list_yaml_files():
+    files = []
+    for file in os.listdir(CONFIG_DIR):
+        if not file.endswith('.yaml'):
+            continue
+        if file.startswith('.'):
+            continue
+        if file == 'secrets.yaml':
+            continue
+        files.append(file)
+    files.sort()
+    return files
+
+
+def _list_dashboard_entries():
+    files = _list_yaml_files()
+    return [DashboardEntry(file) for file in files]
+
+
+class DashboardEntry(object):
+    def __init__(self, filename):
+        self.filename = filename
+        self._storage = None
+        self._loaded_storage = False
+
+    @property
+    def full_path(self):  # type: () -> str
+        return os.path.join(CONFIG_DIR, self.filename)
+
+    @property
+    def storage(self):  # type: () -> Optional[StorageJSON]
+        if not self._loaded_storage:
+            self._storage = StorageJSON.load(ext_storage_path(CONFIG_DIR, self.filename))
+            self._loaded_storage = True
+        return self._storage
+
+    @property
+    def address(self):
+        if self.storage is None:
+            return None
+        return self.storage.address
+
+    @property
+    def name(self):
+        if self.storage is None:
+            return self.filename[:-len('.yaml')]
+        return self.storage.name
+
+    @property
+    def esp_platform(self):
+        if self.storage is None:
+            return None
+        return self.storage.esp_platform
+
+    @property
+    def board(self):
+        if self.storage is None:
+            return None
+        return self.storage.board
+
+    @property
+    def update_available(self):
+        if self.storage is None:
+            return True
+        return self.update_old != self.update_new
+
+    @property
+    def update_old(self):
+        if self.storage is None:
+            return ''
+        return self.storage.esphome_version or ''
+
+    @property
+    def update_new(self):
+        return const.__version__
+
+
+class MainRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        begin = bool(self.get_argument('begin', False))
+        entries = _list_dashboard_entries()
+
+        self.render("templates/index.html", entries=entries, begin=begin,
+                    **template_args())
+
+
+def _ping_func(filename, address):
+    if os.name == 'nt':
+        command = ['ping', '-n', '1', address]
+    else:
+        command = ['ping', '-c', '1', address]
+    rc, _, _ = run_system_command(*command)
+    return filename, rc == 0
+
+
+class MDNSStatusThread(threading.Thread):
+    def run(self):
+        zc = Zeroconf()
+
+        def on_update(dat):
+            for key, b in dat.items():
+                PING_RESULT[key] = b
+
+        stat = DashboardStatus(zc, on_update)
+        stat.start()
+        while not STOP_EVENT.is_set():
+            entries = _list_dashboard_entries()
+            stat.request_query({entry.filename: entry.name + '.local.' for entry in entries})
+
+            PING_REQUEST.wait()
+            PING_REQUEST.clear()
+        stat.stop()
+        stat.join()
+        zc.close()
+
+
+class PingStatusThread(threading.Thread):
+    def run(self):
+        pool = multiprocessing.Pool(processes=8)
+        while not STOP_EVENT.is_set():
+            # Only do pings if somebody has the dashboard open
+
+            def callback(ret):
+                PING_RESULT[ret[0]] = ret[1]
+
+            entries = _list_dashboard_entries()
+            queue = collections.deque()
+            for entry in entries:
+                if entry.address is None:
+                    PING_RESULT[entry.filename] = None
+                    continue
+
+                result = pool.apply_async(_ping_func, (entry.filename, entry.address),
+                                          callback=callback)
+                queue.append(result)
+
+            while queue:
+                item = queue[0]
+                if item.ready():
+                    queue.popleft()
+                    continue
+
+                try:
+                    item.get(0.1)
+                except OSError:
+                    # ping not installed
+                    pass
+                except multiprocessing.TimeoutError:
+                    pass
+
+                if STOP_EVENT.is_set():
+                    pool.terminate()
+                    return
+
+            PING_REQUEST.wait()
+            PING_REQUEST.clear()
+
+
+class PingRequestHandler(BaseHandler):
+    @authenticated
+    def get(self):
+        PING_REQUEST.set()
+        self.write(json.dumps(PING_RESULT))
+
+
+def is_allowed(configuration):
+    return os.path.sep not in configuration
+
+
+class EditRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def get(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        with open(os.path.join(CONFIG_DIR, configuration), 'r') as f:
+            content = f.read()
+        self.write(content)
+
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        # pylint: disable=no-value-for-parameter
+        with open(os.path.join(CONFIG_DIR, configuration), 'wb') as f:
+            f.write(self.request.body)
+        self.set_status(200)
+
+
+class DeleteRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        storage_path = ext_storage_path(CONFIG_DIR, configuration)
+        storage_json = StorageJSON.load(storage_path)
+        if storage_json is None:
+            self.set_status(500)
+            return
+
+        name = storage_json.name
+        trash_path = trash_storage_path(CONFIG_DIR)
+        mkdir_p(trash_path)
+        shutil.move(config_file, os.path.join(trash_path, configuration))
+
+        # Delete build folder (if exists)
+        build_folder = os.path.join(CONFIG_DIR, name)
+        if build_folder is not None:
+            shutil.rmtree(build_folder, os.path.join(trash_path, name))
+
+
+class UndoDeleteRequestHandler(BaseHandler):
+    @authenticated
+    @bind_config
+    def post(self, configuration=None):
+        config_file = os.path.join(CONFIG_DIR, configuration)
+        trash_path = trash_storage_path(CONFIG_DIR)
+        shutil.move(os.path.join(trash_path, configuration), config_file)
+
+
+PING_RESULT = {}  # type: dict
+STOP_EVENT = threading.Event()
+PING_REQUEST = threading.Event()
+
+
+class LoginHandler(BaseHandler):
+    def get(self):
+        if USING_HASSIO_AUTH:
+            self.render_hassio_login()
+            return
+        self.write('<html><body><form action="' + RELATIVE_URL + 'login" method="post">'
+                   'Password: <input type="password" name="password">'
+                   '<input type="submit" value="Sign in">'
+                   '</form></body></html>')
+
+    def render_hassio_login(self, error=None):
+        self.render("templates/login.html", error=error, **template_args())
+
+    def post_hassio_login(self):
+        import requests
+
+        headers = {
+            'X-HASSIO-KEY': os.getenv('HASSIO_TOKEN'),
+        }
+        data = {
+            'username': str(self.get_argument('username', '')),
+            'password': str(self.get_argument('password', ''))
+        }
+        try:
+            req = requests.post('http://hassio/auth', headers=headers, data=data)
+            if req.status_code == 200:
+                self.set_secure_cookie("authenticated", cookie_authenticated_yes)
+                self.redirect('/')
+                return
+        except Exception as err:  # pylint: disable=broad-except
+            _LOGGER.warning("Error during Hass.io auth request: %s", err)
+            self.set_status(500)
+            self.render_hassio_login(error="Internal server error")
+            return
+        self.set_status(401)
+        self.render_hassio_login(error="Invalid username or password")
+
+    def post(self):
+        if USING_HASSIO_AUTH:
+            self.post_hassio_login()
+            return
+
+        password = str(self.get_argument("password", ''))
+        if IS_PY2:
+            password = hmac.new(password).digest()
+        else:
+            password = hmac.new(password.encode()).digest()
+        if hmac.compare_digest(PASSWORD_DIGEST, password):
+            self.set_secure_cookie("authenticated", cookie_authenticated_yes)
+        self.redirect("/")
+
+
+_STATIC_FILE_HASHES = {}
+
+
+def get_static_file_url(name):
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    if name in _STATIC_FILE_HASHES:
+        hash_ = _STATIC_FILE_HASHES[name]
+    else:
+        path = os.path.join(static_path, name)
+        with open(path, 'rb') as f_handle:
+            hash_ = hashlib.md5(f_handle.read()).hexdigest()[:8]
+        _STATIC_FILE_HASHES[name] = hash_
+    return RELATIVE_URL + u'static/{}?hash={}'.format(name, hash_)
+
+
+def make_app(debug=False):
+    def log_function(handler):
+        if handler.get_status() < 400:
+            log_method = access_log.info
+
+            if isinstance(handler, SerialPortRequestHandler) and not debug:
+                return
+            if isinstance(handler, PingRequestHandler) and not debug:
+                return
+        elif handler.get_status() < 500:
+            log_method = access_log.warning
+        else:
+            log_method = access_log.error
+
+        request_time = 1000.0 * handler.request.request_time()
+        # pylint: disable=protected-access
+        log_method("%d %s %.2fms", handler.get_status(),
+                   handler._request_summary(), request_time)
+
+    class StaticFileHandler(tornado.web.StaticFileHandler):
+        def set_extra_headers(self, path):
+            if debug:
+                self.set_header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
+
+    static_path = os.path.join(os.path.dirname(__file__), 'static')
+    settings = {
+        'debug': debug,
+        'cookie_secret': COOKIE_SECRET,
+        'log_function': log_function,
+        'websocket_ping_interval': 30.0,
+    }
+    app = tornado.web.Application([
+        (RELATIVE_URL + "", MainRequestHandler),
+        (RELATIVE_URL + "login", LoginHandler),
+        (RELATIVE_URL + "logs", EsphomeLogsHandler),
+        (RELATIVE_URL + "run", EsphomeRunHandler),
+        (RELATIVE_URL + "compile", EsphomeCompileHandler),
+        (RELATIVE_URL + "validate", EsphomeValidateHandler),
+        (RELATIVE_URL + "clean-mqtt", EsphomeCleanMqttHandler),
+        (RELATIVE_URL + "clean", EsphomeCleanHandler),
+        (RELATIVE_URL + "hass-config", EsphomeHassConfigHandler),
+        (RELATIVE_URL + "edit", EditRequestHandler),
+        (RELATIVE_URL + "download.bin", DownloadBinaryRequestHandler),
+        (RELATIVE_URL + "serial-ports", SerialPortRequestHandler),
+        (RELATIVE_URL + "ping", PingRequestHandler),
+        (RELATIVE_URL + "delete", DeleteRequestHandler),
+        (RELATIVE_URL + "undo-delete", UndoDeleteRequestHandler),
+        (RELATIVE_URL + "wizard.html", WizardRequestHandler),
+        (RELATIVE_URL + r"static/(.*)", StaticFileHandler, {'path': static_path}),
+    ], **settings)
+
+    if debug:
+        _STATIC_FILE_HASHES.clear()
+
+    return app
+
+
+def start_web_server(args):
+    global CONFIG_DIR
+    global PASSWORD_DIGEST
+    global USING_PASSWORD
+    global ON_HASSIO
+    global USING_HASSIO_AUTH
+    global COOKIE_SECRET
+
+    CONFIG_DIR = args.configuration
+    mkdir_p(CONFIG_DIR)
+    mkdir_p(os.path.join(CONFIG_DIR, ".esphome"))
+
+    ON_HASSIO = args.hassio
+    if ON_HASSIO:
+        USING_HASSIO_AUTH = not get_bool_env('DISABLE_HA_AUTHENTICATION')
+        USING_PASSWORD = False
+    else:
+        USING_HASSIO_AUTH = False
+        USING_PASSWORD = args.password
+
+    if USING_PASSWORD:
+        if IS_PY2:
+            PASSWORD_DIGEST = hmac.new(args.password).digest()
+        else:
+            PASSWORD_DIGEST = hmac.new(args.password.encode()).digest()
+
+    if USING_HASSIO_AUTH or USING_PASSWORD:
+        path = esphome_storage_path(CONFIG_DIR)
+        storage = EsphomeStorageJSON.load(path)
+        if storage is None:
+            storage = EsphomeStorageJSON.get_default()
+            storage.save(path)
+        COOKIE_SECRET = storage.cookie_secret
+
+    app = make_app(args.verbose)
+    if args.socket is not None:
+        _LOGGER.info("Starting dashboard web server on unix socket %s and configuration dir %s...",
+                     args.socket, CONFIG_DIR)
+        server = tornado.httpserver.HTTPServer(app)
+        socket = tornado.netutil.bind_unix_socket(args.socket, mode=0o666)
+        server.add_socket(socket)
+    else:
+        _LOGGER.info("Starting dashboard web server on port %s and configuration dir %s...",
+                     args.port, CONFIG_DIR)
+        app.listen(args.port)
+
+        if args.open_ui:
+            import webbrowser
+
+            webbrowser.open('localhost:{}'.format(args.port))
+
+    if STATUS_USE_PING:
+        status_thread = PingStatusThread()
+    else:
+        status_thread = MDNSStatusThread()
+    status_thread.start()
+    try:
+        tornado.ioloop.IOLoop.current().start()
+    except KeyboardInterrupt:
+        _LOGGER.info("Shutting down...")
+        STOP_EVENT.set()
+        PING_REQUEST.set()
+        status_thread.join()
+        if args.socket is not None:
+            os.remove(args.socket)