Fix deploy script

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: Create a report to help esphomelib improve
+about: Create a report to help us improve
 
 ---
 
@@ -9,9 +9,7 @@ about: Create a report to help esphomelib improve
   - 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! Otherwise the issue may be closed without a comment.
+- 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.):**
@@ -35,7 +33,7 @@ Please add the link to the documentation at https://esphomelib.com/esphomeyaml/i
 
 **Problem-relevant YAML-configuration entries:**
 ```yaml
-PASTE YAML FILE HERE
+
 ```
 
 **Traceback (if applicable):**

.github/ISSUE_TEMPLATE/feature_request.md

@@ -7,15 +7,16 @@ 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.
- 
-   DO NOT DELETE ANY TEXT from this template! Otherwise the issue may be closed without a comment.
 -->
 
-**Is your feature request related to a problem/use-case? Please describe.**
-<!-- A clear and concise description of what the problem is. -->
+**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. -->
+**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. -->
+**Additional context**
+Add any other context about the feature request here.

.github/ISSUE_TEMPLATE/new-integration.md

@@ -4,10 +4,17 @@ about: Suggest a new integration for esphomelib
 
 ---
 
-DO NOT POST NEW INTEGRATION REQUESTS HERE!
+<!-- 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.
+-->
 
-Please post all new integration requests in the esphomelib repository:
+**What new integration would you wish to have?**
+<!-- A name/description of the new integration/board. -->
 
-https://github.com/OttoWinter/esphomelib/issues
+**If possible, provide a link to an existing library for the integration:**
 
-Thank you!
+**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

@@ -6,9 +6,15 @@
 **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
+
+```
+
 ## 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).

.gitignore

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

.gitlab-ci.yml

@@ -11,8 +11,6 @@ stages:
 
 .lint: &lint
   stage: lint
-  before_script:
-    - pip install -e .
   tags:
     - python2.7
     - esphomeyaml-lint
@@ -26,6 +24,9 @@ stages:
     - esphomeyaml-test
   variables:
     TZ: UTC
+  cache:
+    paths:
+      - tests/build
 
 .docker-builder: &docker-builder
   before_script:
@@ -60,83 +61,44 @@ test2:
   <<: *docker-builder
   stage: build
   script:
-    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
-    - BUILD_FROM=hassioaddons/ubuntu-base-${ADDON_ARCH}:2.2.0
-    - ADDON_VERSION="${CI_COMMIT_TAG#v}"
-    - ADDON_VERSION="${ADDON_VERSION:-${CI_COMMIT_SHA:0:7}}"
-    - echo "Build from ${BUILD_FROM}"
-    - echo "Add-on version ${ADDON_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 "BUILD_DATE=$(date +"%Y-%m-%dT%H:%M:%SZ")" \
-        --build-arg "BUILD_ARCH=${ADDON_ARCH}" \
-        --build-arg "BUILD_REF=${CI_COMMIT_SHA}" \
-        --build-arg "BUILD_VERSION=${ADDON_VERSION}" \
-        --tag "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev" \
-        --tag "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        --file "docker/Dockerfile.hassio" \
-        .
+      hassio-builder.sh \
+           -t . \
+           -i ottowinter/esphomeyaml-hassio-${ADDON_ARCH} \
+           -d "$CI_REGISTRY" \
+           --${ADDON_ARCH}
     - |
-      if [ "${DO_PUSH:-true}" = true ]; then
-        echo "Pushing to CI registry"
-        docker push ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}
-        docker push ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev
-      fi
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:dev"
+  retry: 2
 
 # Generic deploy template
 .deploy-release: &deploy-release
   <<: *docker-builder
   stage: deploy
   script:
-    - version="${CI_COMMIT_TAG#v}"
+    - version=${CI_COMMIT_TAG:1}
     - echo "Publishing release version ${version}"
-    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
     - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
-
-    - echo "Tag ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
     - |
       docker tag \
         "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
         "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-
-    - echo "Tag ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
     - |
       docker tag \
         "${CI_REGISTRY}/ottowinter/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 \
         "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}" \
         "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
     - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:latest"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - |
-      docker tag \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}" \
-        "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
   only:
   - /^v\d+\.\d+\.\d+$/
   except:
@@ -146,37 +108,24 @@ test2:
   <<: *docker-builder
   stage: deploy
   script:
-    - version="${CI_COMMIT_TAG#v}"
+    - version=${CI_COMMIT_TAG:1}
     - echo "Publishing beta version ${version}"
-    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
     - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
-
-    - echo "Tag ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - |
-      docker tag \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
-        "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
-
-    - echo "Tag ${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker pull "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}"
     - |
       docker tag \
         "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${CI_COMMIT_SHA}" \
         "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
-
-    - echo "Tag ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
     - |
       docker tag \
         "${CI_REGISTRY}/ottowinter/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 \
         "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}" \
         "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:beta"
+    - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:${version}"
     - docker push "ottowinter/esphomeyaml-hassio-${ADDON_ARCH}:rc"
   only:
   - /^v\d+\.\d+\.\d+b\d+$/
@@ -189,60 +138,30 @@ build:normal:
   stage: build
   script:
     - docker build -t "${CI_REGISTRY}/ottowinter/esphomeyaml:dev" .
+    - |
+      docker tag \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml:dev" \
+        "${CI_REGISTRY}/ottowinter/esphomeyaml:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml:${CI_COMMIT_SHA}"
+    - docker push "${CI_REGISTRY}/ottowinter/esphomeyaml:dev"
 
-.build-hassio-edge: &build-hassio-edge
+build:armhf:
   <<: *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
 
-#build:hassio-aarch64-edge:
-#  <<: *build-hassio-edge
-#  variables:
-#    ADDON_ARCH: aarch64
-#    DO_PUSH: "false"
+#build:aarch64:
+#   <<: *build
+#   variables:
+#     ADDON_ARCH: aarch64
 
-#build:hassio-aarch64:
-#  <<: *build-hassio-release
-#  variables:
-#    ADDON_ARCH: aarch64
-
-build:hassio-i386-edge:
-  <<: *build-hassio-edge
-  variables:
-    ADDON_ARCH: i386
-    DO_PUSH: "false"
-
-build:hassio-i386:
-  <<: *build-hassio-release
+build:i386:
+  <<: *build-hassio
   variables:
     ADDON_ARCH: i386
 
-build:hassio-amd64-edge:
-  <<: *build-hassio-edge
-  variables:
-    ADDON_ARCH: amd64
-    DO_PUSH: "false"
-
-build:hassio-amd64:
-  <<: *build-hassio-release
+build:amd64:
+  <<: *build-hassio
   variables:
     ADDON_ARCH: amd64
 

.travis.yml

@@ -1,30 +1,20 @@
 sudo: false
 language: python
-
-matrix:
-  fast_finish: true
+python:
+  - "2.7"
+jobs:
   include:
-    - python: "2.7"
-      env: TARGET=Lint2.7
-      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
+    - name: "Lint"
+      install:
+        - pip install -r requirements.txt
+        - pip install flake8==3.5.0 pylint==1.9.3 tzlocal pillow
       script:
         - flake8 esphomeyaml
         - pylint esphomeyaml
-    - 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.2.2 pillow
-      script:
-        - flake8 esphomeyaml
-        - pylint esphomeyaml
-    - python: "2.7"
-      env: TARGET=Test2.7
-      install: pip install -e . && pip install flake8==3.6.0 pylint==1.9.4 pillow
-      script:
-        - esphomeyaml tests/test1.yaml compile
-        - esphomeyaml tests/test2.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.2.2 pillow
+    - name: "Test"
+      install:
+        - pip install -e .
+        - pip install tzlocal pillow
       script:
         - esphomeyaml tests/test1.yaml compile
         - esphomeyaml tests/test2.yaml compile

Dockerfile

@@ -1,27 +1,25 @@
-ARG BUILD_FROM=python:2.7
-FROM ${BUILD_FROM}
+FROM python:2.7
 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
+    && rm -rf /var/lib/apt/lists/*
 
 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
+RUN pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+COPY docker/platformio.ini /usr/src/app/
+RUN platformio settings set enable_telemetry No && \
+    platformio run -e espressif32 -e espressif8266; exit 0
 
 COPY . .
-RUN pip install --no-cache-dir --no-binary :all: -e .
+RUN pip install --no-cache-dir -e . && \
+    pip install --no-cache-dir tzlocal pillow
 
 WORKDIR /config
 ENTRYPOINT ["esphomeyaml"]

MANIFEST.in

@@ -1,17 +1,4 @@
 include README.md
 include esphomeyaml/dashboard/templates/index.html
-include esphomeyaml/dashboard/templates/login.html
-include esphomeyaml/dashboard/static/ace.js
-include esphomeyaml/dashboard/static/esphomeyaml.css
-include esphomeyaml/dashboard/static/esphomeyaml.js
-include esphomeyaml/dashboard/static/favicon.ico
-include esphomeyaml/dashboard/static/jquery.min.js
-include esphomeyaml/dashboard/static/jquery.validate.min.js
-include esphomeyaml/dashboard/static/jquery-ui.min.js
-include esphomeyaml/dashboard/static/materialize.min.css
-include esphomeyaml/dashboard/static/materialize.min.js
 include esphomeyaml/dashboard/static/materialize-stepper.min.css
 include esphomeyaml/dashboard/static/materialize-stepper.min.js
-include esphomeyaml/dashboard/static/mode-yaml.js
-include esphomeyaml/dashboard/static/theme-dreamweaver.js
-include esphomeyaml/dashboard/static/ext-searchbox.js

docker/Dockerfile.aarch64

@@ -0,0 +1,21 @@
+# Dockerfile for aarch64 version of HassIO add-on
+FROM arm64v8/ubuntu:bionic
+
+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/*rm -rf /var/lib/apt/lists/* /tmp/* && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+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
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.amd64

@@ -0,0 +1,21 @@
+# Dockerfile for amd64 version of HassIO add-on
+FROM ubuntu:bionic
+
+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/*rm -rf /var/lib/apt/lists/* /tmp/* && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+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
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.armhf

@@ -0,0 +1,31 @@
+# Dockerfile for armhf version of HassIO add-on
+FROM homeassistant/armhf-base:latest
+
+RUN apk add --no-cache \
+        python2 \
+        python2-dev \
+        py2-pip \
+        git \
+        gcc \
+        openssh \
+        libc6-compat \
+        jpeg-dev \
+        zlib-dev \
+        freetype-dev \
+        lcms2-dev \
+        openjpeg-dev \
+        tiff-dev \
+        libc-dev \
+        linux-headers \
+    && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+COPY docker/platformio-esp8266.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 pillow tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

docker/Dockerfile.builder

@@ -27,4 +27,6 @@ RUN apt-get update && apt-get install -y \
         binfmt-support \
     && rm -rf /var/lib/apt/lists/*
 
+COPY docker/hassio-builder.sh /usr/bin/
+
 WORKDIR /data

docker/Dockerfile.hassio

@@ -1,75 +0,0 @@
-ARG BUILD_FROM=hassioaddons/ubuntu-base:2.2.0
-# hadolint ignore=DL3006
-FROM ${BUILD_FROM}
-
-# Set shell
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-# Copy root filesystem
-COPY esphomeyaml-edge/rootfs /
-COPY setup.py setup.cfg MANIFEST.in /opt/esphomeyaml/
-COPY esphomeyaml /opt/esphomeyaml/esphomeyaml
-
-RUN \
-    # Temporarily move nginx.conf (otherwise dpkg fails)
-    mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bkp \
-    # Install add-on dependencies
-    && apt-get update \
-    && apt-get install -y --no-install-recommends \
-        # Python for esphomeyaml
-        python \
-        python-pip \
-        python-setuptools \
-        # Python Pillow for display component
-        python-pil \
-        # Git for esphomelib downloads
-        git \
-        # Ping for dashboard online/offline status
-        iputils-ping \
-        # NGINX proxy
-        nginx \
-    \
-    && mv /etc/nginx/nginx.conf.bkp /etc/nginx/nginx.conf \
-    \
-    && pip2 install --no-cache-dir --no-binary :all: -e /opt/esphomeyaml \
-    \
-    # Change some platformio settings
-    && 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 \
-    \
-    # Build an empty platformio project to force platformio to install all fw build dependencies
-    # The return-code will be non-zero since there's nothing to build.
-    && (platformio run -d /opt/pio; echo "Done") \
-    \
-    # Cleanup
-    && rm -fr \
-        /tmp/* \
-        /var/{cache,log}/* \
-        /var/lib/apt/lists/* \
-        /opt/pio/
-
-# Build arugments
-ARG BUILD_ARCH=amd64
-ARG BUILD_DATE
-ARG BUILD_REF
-ARG BUILD_VERSION
-
-# Labels
-LABEL \
-    io.hass.name="esphomeyaml" \
-    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
-    io.hass.arch="${BUILD_ARCH}" \
-    io.hass.type="addon" \
-    io.hass.version=${BUILD_VERSION} \
-    maintainer="Otto Winter <contact@otto-winter.com>" \
-    org.label-schema.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
-    org.label-schema.build-date=${BUILD_DATE} \
-    org.label-schema.name="esphomeyaml" \
-    org.label-schema.schema-version="1.0" \
-    org.label-schema.url="https://esphomelib.com" \
-    org.label-schema.usage="https://github.com/OttoWinter/esphomeyaml/tree/dev/esphomeyaml/README.md" \
-    org.label-schema.vcs-ref=${BUILD_REF} \
-    org.label-schema.vcs-url="https://github.com/OttoWinter/esphomeyaml" \
-    org.label-schema.vendor="esphomelib"

docker/Dockerfile.i386

@@ -0,0 +1,21 @@
+# Dockerfile for i386 version of HassIO add-on
+FROM i386/ubuntu:bionic
+
+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/*rm -rf /var/lib/apt/lists/* /tmp/* && \
+    pip install --no-cache-dir --no-binary :all: platformio && \
+    platformio settings set enable_telemetry No
+
+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
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

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.6.0 pylint==1.9.4 pillow
+    pip install flake8==3.5.0 pylint==1.9.3 tzlocal pillow

docker/Dockerfile.test

@@ -8,14 +8,12 @@ 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 check_libraries_interval 1000000 && \
-    platformio settings set check_platformio_interval 1000000 && \
-    platformio settings set check_platforms_interval 1000000
+    platformio settings set enable_telemetry No
 
 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
+RUN pip install --no-cache-dir -r /requirements.txt && \
+    pip install --no-cache-dir tzlocal pillow

docker/hassio-builder.sh

@@ -0,0 +1,318 @@
+#!/usr/bin/env bash
+# Based on Home Assistant's docker builder
+######################
+# Hass.io Build-env
+######################
+set -e
+
+echo -- "$@"
+
+#### Variable ####
+
+DOCKER_TIMEOUT=20
+DOCKER_PID=-1
+DOCKER_HUB=""
+DOCKER_CACHE="true"
+DOCKER_LOCAL="false"
+TARGET=""
+IMAGE=""
+BUILD_LIST=()
+BUILD_TASKS=()
+
+#### Misc functions ####
+
+function print_help() {
+    cat << EOF
+Hass.io build-env for ecosystem:
+docker run --rm homeassistant/{arch}-builder:latest [options]
+
+Options:
+  -h, --help
+        Display this help and exit.
+
+  Repository / Data
+    -t, --target <PATH_TO_BUILD>
+        Set local folder or path inside repository for build.
+
+  Version/Image handling
+    -i, --image <IMAGE_NAME>
+        Overwrite image name of build / support {arch}
+
+  Architecture
+    --armhf
+        Build for arm.
+    --amd64
+        Build for intel/amd 64bit.
+    --aarch64
+        Build for arm 64bit.
+    --i386
+        Build for intel/amd 32bit.
+    --all
+        Build all architecture.
+
+  Build handling
+    --no-cache
+       Disable cache for the build (from latest).
+    -d, --docker-hub <DOCKER_REPOSITORY>
+       Set or overwrite the docker repository.
+
+    Use the host docker socket if mapped into container:
+       /var/run/docker.sock
+
+EOF
+
+    exit 1
+}
+
+#### Docker functions ####
+
+function start_docker() {
+    local starttime
+    local endtime
+
+    if [ -S "/var/run/docker.sock" ]; then
+        echo "[INFO] Use host docker setup with '/var/run/docker.sock'"
+        DOCKER_LOCAL="true"
+        return 0
+    fi
+
+    echo "[INFO] Starting docker."
+    dockerd 2> /dev/null &
+    DOCKER_PID=$!
+
+    echo "[INFO] Waiting for docker to initialize..."
+    starttime="$(date +%s)"
+    endtime="$(date +%s)"
+    until docker info >/dev/null 2>&1; do
+        if [ $((endtime - starttime)) -le ${DOCKER_TIMEOUT} ]; then
+            sleep 1
+            endtime=$(date +%s)
+        else
+            echo "[ERROR] Timeout while waiting for docker to come up"
+            exit 1
+        fi
+    done
+    echo "[INFO] Docker was initialized"
+}
+
+
+function stop_docker() {
+    local starttime
+    local endtime
+
+    if [ "$DOCKER_LOCAL" == "true" ]; then
+        return 0
+    fi
+
+    echo "[INFO] Stopping in container docker..."
+    if [ "$DOCKER_PID" -gt 0 ] && kill -0 "$DOCKER_PID" 2> /dev/null; then
+        starttime="$(date +%s)"
+        endtime="$(date +%s)"
+
+        # Now wait for it to die
+        kill "$DOCKER_PID"
+        while kill -0 "$DOCKER_PID" 2> /dev/null; do
+            if [ $((endtime - starttime)) -le ${DOCKER_TIMEOUT} ]; then
+                sleep 1
+                endtime=$(date +%s)
+            else
+                echo "[ERROR] Timeout while waiting for container docker to die"
+                exit 1
+            fi
+        done
+    else
+        echo "[WARN] Your host might have been left with unreleased resources"
+    fi
+}
+
+function run_build() {
+    local build_dir=$1
+    local repository=$2
+    local image=$3
+    local version=$4
+    local build_arch=$5
+    local docker_cli=("${!6}")
+
+    local push_images=()
+
+    # Overwrites
+    if [ ! -z "$DOCKER_HUB" ]; then repository="$DOCKER_HUB"; fi
+    if [ ! -z "$IMAGE" ]; then image="$IMAGE"; fi
+
+    # Init Cache
+    if [ "$DOCKER_CACHE" == "true" ]; then
+        echo "[INFO] Init cache for $repository/$image:$version"
+        if docker pull "$repository/$image:latest" > /dev/null 2>&1; then
+            docker_cli+=("--cache-from" "$repository/$image:latest")
+        else
+            docker_cli+=("--no-cache")
+            echo "[WARN] No cache image found. Cache is disabled for build"
+        fi
+    else
+        docker_cli+=("--no-cache")
+    fi
+
+    # Build image
+    echo "[INFO] Run build for $repository/$image:$version"
+    docker build --pull -t "$repository/$image:$version" \
+        --label "io.hass.version=$version" \
+        --label "io.hass.arch=$build_arch" \
+        -f "$TARGET/docker/Dockerfile.$build_arch" \
+        "${docker_cli[@]}" \
+        "$build_dir"
+
+    echo "[INFO] Finish build for $repository/$image:$version"
+    docker tag "$repository/$image:$version" "$repository/$image:dev"
+}
+
+
+#### HassIO functions ####
+
+function build_addon() {
+    local build_arch=$1
+
+    local docker_cli=()
+    local image=""
+    local repository=""
+    local raw_image=""
+    local name=""
+    local description=""
+    local url=""
+    local args=""
+
+    # Read addon config.json
+    name="$(jq --raw-output '.name // empty' "$TARGET/esphomeyaml/config.json" | sed "s/'//g")"
+    description="$(jq --raw-output '.description // empty' "$TARGET/esphomeyaml/config.json" | sed "s/'//g")"
+    url="$(jq --raw-output '.url // empty' "$TARGET/esphomeyaml/config.json")"
+    version="$(jq --raw-output '.version' "$TARGET/esphomeyaml/config.json")"
+    raw_image="$(jq --raw-output '.image // empty' "$TARGET/esphomeyaml/config.json")"
+
+    # Read data from image
+    if [ ! -z "$raw_image" ]; then
+        repository="$(echo "$raw_image" | cut -f 1 -d '/')"
+        image="$(echo "$raw_image" | cut -f 2 -d '/')"
+    fi
+
+    # Set additional labels
+    docker_cli+=("--label" "io.hass.name=$name")
+    docker_cli+=("--label" "io.hass.description=$description")
+    docker_cli+=("--label" "io.hass.type=addon")
+
+    if [ ! -z "$url" ]; then
+        docker_cli+=("--label" "io.hass.url=$url")
+    fi
+
+    # Start build
+    run_build "$TARGET" "$repository" "$image" "$version" \
+        "$build_arch" docker_cli[@]
+}
+
+#### initialized cross-build ####
+
+function init_crosscompile() {
+    echo "[INFO] Setup crosscompiling feature"
+    (
+        mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
+        update-binfmts --enable qemu-arm
+        update-binfmts --enable qemu-aarch64
+    ) > /dev/null 2>&1 || echo "[WARN] Can't enable crosscompiling feature"
+}
+
+
+function clean_crosscompile() {
+    echo "[INFO] Clean crosscompiling feature"
+    if [ -f /proc/sys/fs/binfmt_misc ]; then
+        umount /proc/sys/fs/binfmt_misc || true
+    fi
+
+    (
+        update-binfmts --disable qemu-arm
+        update-binfmts --disable qemu-aarch64
+    ) > /dev/null 2>&1 || echo "[WARN] No crosscompiling feature found for cleanup"
+}
+
+#### Error handling ####
+
+function error_handling() {
+    stop_docker
+    clean_crosscompile
+
+    exit 1
+}
+trap 'error_handling' SIGINT SIGTERM
+
+#### Parse arguments ####
+
+while [[ $# -gt 0 ]]; do
+    key=$1
+    case ${key} in
+        -h|--help)
+            print_help
+            ;;
+        -t|--target)
+            TARGET=$2
+            shift
+            ;;
+        -i|--image)
+            IMAGE=$2
+            shift
+            ;;
+        --no-cache)
+            DOCKER_CACHE="false"
+            ;;
+        -d|--docker-hub)
+            DOCKER_HUB=$2
+            shift
+            ;;
+        --armhf)
+            BUILD_LIST+=("armhf")
+            ;;
+        --amd64)
+            BUILD_LIST+=("amd64")
+            ;;
+        --i386)
+            BUILD_LIST+=("i386")
+            ;;
+        --aarch64)
+            BUILD_LIST+=("aarch64")
+            ;;
+        --all)
+            BUILD_LIST=("armhf" "amd64" "i386" "aarch64")
+            ;;
+
+        *)
+            echo "[WARN] $0 : Argument '$1' unknown will be Ignoring"
+            ;;
+    esac
+    shift
+done
+
+# Check if an architecture is available
+if [ "${#BUILD_LIST[@]}" -eq 0 ]; then
+    echo "[ERROR] You need select an architecture for build!"
+    exit 1
+fi
+
+
+#### Main ####
+
+mkdir -p /data
+
+# Setup docker env
+init_crosscompile
+start_docker
+
+# Select arch build
+for arch in "${BUILD_LIST[@]}"; do
+    (build_addon "$arch") &
+    BUILD_TASKS+=($!)
+done
+
+# Wait until all build jobs are done
+wait "${BUILD_TASKS[@]}"
+
+# Cleanup docker env
+clean_crosscompile
+stop_docker
+
+exit 0

docker/platformio-esp8266.ini

@@ -5,8 +5,3 @@
 platform = espressif8266
 board = nodemcuv2
 framework = arduino
-
-[env:espressif32]
-platform = espressif32
-board = nodemcu-32s
-framework = arduino

esphomeyaml-beta/README.md

@@ -1,109 +0,0 @@
-# Esphomeyaml Hass.io Add-On
-
-[![esphomeyaml logo](https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/logo.png)](https://esphomelib.com/esphomeyaml/index.html)
-
-[![GitHub stars](https://img.shields.io/github/stars/OttoWinter/esphomelib.svg?style=social&label=Star&maxAge=2592000)](https://github.com/OttoWinter/esphomelib)
-[![GitHub Release][releases-shield]][releases]
-[![Discord][discord-shield]][discord]
-
-## About
-
-This add-on allows you to manage and program your ESP8266 and ESP32 based microcontrollers
-directly through Hass.io **with no programming experience required**. All you need to do
-is write YAML configuration files; the rest (over-the-air updates, compiling) is all
-handled by esphomeyaml.
-
-<p align="center">
-<img title="esphomeyaml dashboard screenshot" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/screenshot.png" width="700px"></img>
-</p>
-
-[_View the esphomeyaml documentation here_](https://esphomelib.com/esphomeyaml/index.html)
-
-## Example
-
-With esphomeyaml, you can go from a few lines of YAML straight to a custom-made
-firmware. For example, to include a [DHT22][dht22].
-temperature and humidity sensor, you just need to include 8 lines of YAML
-in your configuration file:
-
-<img title="esphomeyaml DHT configuration example" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/dht-example.png" width="500px"></img>
-
-Then just click UPLOAD and the sensor will magically appear in Home Assistant:
-
-<img title="esphomelib Home Assistant MQTT discovery" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/temperature-humidity.png" width="600px"></img>
-
-## Installation
-
-To install this Hass.io add-on you need to add the esphomeyaml add-on repository
-first:
-
-1. Add the epshomeyaml add-ons repository to your Hass.io instance. You can do this by navigating to the "Add-on Store" tab in the Hass.io panel and then entering https://github.com/OttoWinter/esphomeyaml in the "Add new repository by URL" field.
-2. Now scroll down and select the "esphomeyaml" add-on.
-3. Press install to download the add-on and unpack it on your machine. This can take some time.
-4. Optional: If you're using SSL certificates and want to encrypt your communication to this add-on, please enter `true` into the `ssl` field and set the `fullchain` and `certfile` options accordingly.
-5. Start the add-on, check the logs of the add-on to see if everything went well.
-6. Click "OPEN WEB UI" to open the esphomeyaml dashboard. You will be asked for your Home Assistant credentials - esphomeyaml uses Hass.io's authentication system to log you in.
-
-**NOTE**: Installation on RPis running in 64-bit mode is currently not possible. Please use the 32-bit variant of HassOS instead.
-
-You can view the esphomeyaml docs here: https://esphomelib.com/esphomeyaml/index.html
-
-## Configuration
-
-**Note**: _Remember to restart the add-on when the configuration is changed._
-
-Example add-on configuration:
-
-```json
-{
-  "ssl": false,
-  "certfile": "fullchain.pem",
-  "keyfile": "privkey.pem",
-  "port": 6052
-}
-```
-
-### Option: `port`
-
-The port to start the dashboard server on. Default is 6052.
-
-### Option: `ssl`
-
-Enables/Disables encrypted SSL (HTTPS) connections to the web server of this add-on.
-Set it to `true` to encrypt communications, `false` otherwise.
-Please note that if you set this to `true` you must also generate the key and certificate
-files for encryption. For example using [Let's Encrypt](https://www.home-assistant.io/addons/lets_encrypt/)
-or [Self-signed certificates](https://www.home-assistant.io/docs/ecosystem/certificates/tls_self_signed_certificate/).
-
-### Option: `certfile`
-
-The certificate file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `keyfile`
-
-The private key file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `leave_front_door_open`
-
-Adding this option to the add-on configuration allows you to disable
-authentication by setting it to `true`.
-
-### Option: `esphomeyaml_version`
-
-Manually override which esphomeyaml version to use in the addon.
-For example to install the latest development version, use `"esphomeyaml_version": "dev"`,
-or for version 1.10.0: `"esphomeyaml_version": "v1.10.0""`.
- 
-Please note that this does not always work and is only meant for testing, usually the
-esphomeyaml add-on and dashboard version must match to guarantee a working system.  
-
-[discord-shield]: https://img.shields.io/discord/429907082951524364.svg
-[dht22]: https://esphomelib.com/esphomeyaml/components/sensor/dht.html
-[discord]: https://discord.me/KhAMKrd
-[releases-shield]: https://img.shields.io/github/release/OttoWinter/esphomeyaml.svg
-[releases]: https://esphomelib.com/esphomeyaml/changelog/index.html
-[repository]: https://github.com/OttoWinter/esphomeyaml

esphomeyaml-beta/config.json

@@ -1,38 +1,33 @@
 {
   "name": "esphomeyaml-beta",
-  "version": "1.10.0",
+  "version": "1.9.0b1",
   "slug": "esphomeyaml-beta",
-  "description": "Beta version of esphomeyaml Hass.io add-on.",
-  "url": "https://beta.esphomelib.com/esphomeyaml/index.html",
-  "webui": "http://[HOST]:[PORT:6052]",
+  "description": "Beta version of esphomeyaml HassIO add-on.",
+  "url": "https://esphomelib.com/esphomeyaml/index.html",
   "startup": "application",
+  "webui": "http://[HOST]:[PORT:6052]",
+  "boot": "auto",
+  "ports": {
+    "6052/tcp": 6052,
+    "6053/tcp": 6053
+  },
+  "auto_uart": true,
+  "map": [
+    "config:rw"
+  ],
   "arch": [
     "amd64",
     "armhf",
     "i386"
   ],
-  "hassio_api": true,
-  "auth_api": true,
-  "hassio_role": "default",
-  "homeassistant_api": false,
-  "host_network": true,
-  "boot": "auto",
-  "map": [
-    "ssl",
-    "config:rw"
-  ],
+  "environment": {
+    "ESPHOMEYAML_OTA_HOST_PORT": "6053"
+  },
   "options": {
-    "ssl": false,
-    "certfile": "fullchain.pem",
-    "keyfile": "privkey.pem",
-    "port": 6052
+    "password": ""
   },
   "schema": {
-    "ssl": "bool",
-    "certfile": "str",
-    "keyfile": "str",
-    "port": "int",
-    "leave_front_door_open": "bool?",
-    "esphomeyaml_version": "str?"
-  }
+    "password": "str?"
+  },
+  "image": "ottowinter/esphomeyaml-hassio-{arch}"
 }

esphomeyaml-edge/Dockerfile

@@ -1,73 +1,59 @@
-ARG BUILD_FROM=hassioaddons/ubuntu-base:2.2.0
-# hadolint ignore=DL3006
+# Dockerfile for HassIO add-on
+ARG BUILD_FROM=ubuntu:bionic
 FROM ${BUILD_FROM}
 
-# Set shell
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+# Re-declare BUILD_FROM to fix weird docker issue
+ARG BUILD_FROM
 
-# Copy root filesystem
-COPY rootfs /
+# On amd64 and alike, using ubuntu as the base is better as building
+# for the ESP32 only works with glibc (and ubuntu). However, on armhf
+# the build toolchain frequently procudes segfaults under ubuntu.
+#  -> Use ubuntu for most architectures, except alpine for armhf
+#
+# * python and related required because this is a python project
+# * git required for platformio library dependencies downloads
+# * libc6-compat and openssh required on alpine for weird reasons
+# * disable platformio telemetry on install
+RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
+      apt-get update && apt-get install -y --no-install-recommends \
+        python python-pip python-setuptools python-pil git && \
+      rm -rf /var/lib/apt/lists/* /tmp/*; \
+    else \
+       apk add --no-cache \
+          python2 \
+          python2-dev \
+          py2-pip \
+          git \
+          gcc \
+          openssh \
+          libc6-compat \
+          jpeg-dev \
+          zlib-dev \
+          freetype-dev \
+          lcms2-dev \
+          openjpeg-dev \
+          tiff-dev \
+          libc-dev \
+          linux-headers; \
+    fi" && \
+    pip install --no-cache-dir platformio && \
+    platformio settings set enable_telemetry No
 
-RUN \
-    # Temporarily move nginx.conf (otherwise dpkg fails)
-    mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bkp \
-    # Install add-on dependencies
-    && apt-get update \
-    && apt-get install -y --no-install-recommends \
-        # Python for esphomeyaml
-        python \
-        python-pip \
-        python-setuptools \
-        # Python Pillow for display component
-        python-pil \
-        # Git for esphomelib downloads
-        git \
-        # Ping for dashboard online/offline status
-        iputils-ping \
-        # NGINX proxy
-        nginx \
-    \
-    && mv /etc/nginx/nginx.conf.bkp /etc/nginx/nginx.conf \
-    \
-    && pip2 install --no-cache-dir --no-binary :all: https://github.com/OttoWinter/esphomeyaml/archive/dev.zip \
-    \
-    # Change some platformio settings
-    && 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 \
-    \
-    # Build an empty platformio project to force platformio to install all fw build dependencies
-    # The return-code will be non-zero since there's nothing to build.
-    && (platformio run -d /opt/pio; echo "Done") \
-    \
-    # Cleanup
-    && rm -fr \
-        /tmp/* \
-        /var/{cache,log}/* \
-        /var/lib/apt/lists/* \
-        /opt/pio/
 
-# Build arugments
-ARG BUILD_ARCH=amd64
-ARG BUILD_DATE
-ARG BUILD_REF
-ARG BUILD_VERSION
+# Create fake project to make platformio install all depdencies.
+# * Ignore build errors from platformio - empty project
+# * On alpine, only install ESP8266 toolchain
+COPY platformio.ini /pio/platformio.ini
+RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
+      platformio run -e espressif32 -e espressif8266 -d /pio; exit 0; \
+    else \
+      echo \"\$(head -8 /pio/platformio.ini)\" >/pio/platformio.ini; \
+      platformio run -e espressif8266 -d /pio; exit 0; \
+    fi"
 
-# Labels
-LABEL \
-    io.hass.name="esphomeyaml-edge" \
-    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
-    io.hass.arch="${BUILD_ARCH}" \
-    io.hass.type="addon" \
-    io.hass.version=${BUILD_VERSION} \
-    maintainer="Otto Winter <contact@otto-winter.com>" \
-    org.label-schema.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
-    org.label-schema.build-date=${BUILD_DATE} \
-    org.label-schema.name="esphomeyaml-edge" \
-    org.label-schema.schema-version="1.0" \
-    org.label-schema.url="https://esphomelib.com" \
-    org.label-schema.usage="https://github.com/OttoWinter/esphomeyaml/tree/dev/esphomeyaml-edge/README.md" \
-    org.label-schema.vcs-ref=${BUILD_REF} \
-    org.label-schema.vcs-url="https://github.com/OttoWinter/esphomeyaml" \
-    org.label-schema.vendor="esphomelib"
+# Install latest esphomeyaml from git
+RUN pip install --no-cache-dir \
+      git+git://github.com/OttoWinter/esphomeyaml.git && \
+    pip install --no-cache-dir pillow tzlocal
+
+CMD ["esphomeyaml", "/config/esphomeyaml", "dashboard"]

esphomeyaml-edge/README.md

@@ -1,109 +0,0 @@
-# Esphomeyaml Hass.io Add-On
-
-[![esphomeyaml logo](https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/logo.png)](https://esphomelib.com/esphomeyaml/index.html)
-
-[![GitHub stars](https://img.shields.io/github/stars/OttoWinter/esphomelib.svg?style=social&label=Star&maxAge=2592000)](https://github.com/OttoWinter/esphomelib)
-[![GitHub Release][releases-shield]][releases]
-[![Discord][discord-shield]][discord]
-
-## About
-
-This add-on allows you to manage and program your ESP8266 and ESP32 based microcontrollers
-directly through Hass.io **with no programming experience required**. All you need to do
-is write YAML configuration files; the rest (over-the-air updates, compiling) is all
-handled by esphomeyaml.
-
-<p align="center">
-<img title="esphomeyaml dashboard screenshot" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/screenshot.png" width="700px"></img>
-</p>
-
-[_View the esphomeyaml documentation here_](https://esphomelib.com/esphomeyaml/index.html)
-
-## Example
-
-With esphomeyaml, you can go from a few lines of YAML straight to a custom-made
-firmware. For example, to include a [DHT22][dht22].
-temperature and humidity sensor, you just need to include 8 lines of YAML
-in your configuration file:
-
-<img title="esphomeyaml DHT configuration example" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/dht-example.png" width="500px"></img>
-
-Then just click UPLOAD and the sensor will magically appear in Home Assistant:
-
-<img title="esphomelib Home Assistant MQTT discovery" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/temperature-humidity.png" width="600px"></img>
-
-## Installation
-
-To install this Hass.io add-on you need to add the esphomeyaml add-on repository
-first:
-
-1. Add the epshomeyaml add-ons repository to your Hass.io instance. You can do this by navigating to the "Add-on Store" tab in the Hass.io panel and then entering https://github.com/OttoWinter/esphomeyaml in the "Add new repository by URL" field.
-2. Now scroll down and select the "esphomeyaml" add-on.
-3. Press install to download the add-on and unpack it on your machine. This can take some time.
-4. Optional: If you're using SSL certificates and want to encrypt your communication to this add-on, please enter `true` into the `ssl` field and set the `fullchain` and `certfile` options accordingly.
-5. Start the add-on, check the logs of the add-on to see if everything went well.
-6. Click "OPEN WEB UI" to open the esphomeyaml dashboard. You will be asked for your Home Assistant credentials - esphomeyaml uses Hass.io's authentication system to log you in.
-
-**NOTE**: Installation on RPis running in 64-bit mode is currently not possible. Please use the 32-bit variant of HassOS instead.
-
-You can view the esphomeyaml docs here: https://esphomelib.com/esphomeyaml/index.html
-
-## Configuration
-
-**Note**: _Remember to restart the add-on when the configuration is changed._
-
-Example add-on configuration:
-
-```json
-{
-  "ssl": false,
-  "certfile": "fullchain.pem",
-  "keyfile": "privkey.pem",
-  "port": 6052
-}
-```
-
-### Option: `port`
-
-The port to start the dashboard server on. Default is 6052.
-
-### Option: `ssl`
-
-Enables/Disables encrypted SSL (HTTPS) connections to the web server of this add-on.
-Set it to `true` to encrypt communications, `false` otherwise.
-Please note that if you set this to `true` you must also generate the key and certificate
-files for encryption. For example using [Let's Encrypt](https://www.home-assistant.io/addons/lets_encrypt/)
-or [Self-signed certificates](https://www.home-assistant.io/docs/ecosystem/certificates/tls_self_signed_certificate/).
-
-### Option: `certfile`
-
-The certificate file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `keyfile`
-
-The private key file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `leave_front_door_open`
-
-Adding this option to the add-on configuration allows you to disable
-authentication by setting it to `true`.
-
-### Option: `esphomeyaml_version`
-
-Manually override which esphomeyaml version to use in the addon.
-For example to install the latest development version, use `"esphomeyaml_version": "dev"`,
-or for version 1.10.0: `"esphomeyaml_version": "v1.10.0""`.
- 
-Please note that this does not always work and is only meant for testing, usually the
-esphomeyaml add-on and dashboard version must match to guarantee a working system.  
-
-[discord-shield]: https://img.shields.io/discord/429907082951524364.svg
-[dht22]: https://esphomelib.com/esphomeyaml/components/sensor/dht.html
-[discord]: https://discord.me/KhAMKrd
-[releases-shield]: https://img.shields.io/github/release/OttoWinter/esphomeyaml.svg
-[releases]: https://esphomelib.com/esphomeyaml/changelog/index.html
-[repository]: https://github.com/OttoWinter/esphomeyaml

esphomeyaml-edge/build.json

@@ -1,10 +1,10 @@
 {
-  "squash": false,
-  "build_from": {
-    "aarch64": "hassioaddons/ubuntu-base-aarch64:2.2.0",
-    "amd64": "hassioaddons/ubuntu-base-amd64:2.2.0",
-    "armhf": "hassioaddons/ubuntu-base-armhf:2.2.0",
-    "i386": "hassioaddons/ubuntu-base-i386:2.2.0"
-  },
-  "args": {}
+    "squash": false,
+    "build_from": {
+        "aarch64": "arm64v8/ubuntu:bionic",
+        "amd64": "ubuntu:bionic",
+        "armhf": "homeassistant/armhf-base:latest",
+        "i386": "i386/ubuntu:bionic"
+    },
+    "args": {}
 }

esphomeyaml-edge/config.json

@@ -2,38 +2,32 @@
   "name": "esphomeyaml-edge",
   "version": "dev",
   "slug": "esphomeyaml-edge",
-  "description": "Development Version! Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files",
-  "url": "https://github.com/OttoWinter/esphomeyaml/tree/dev/esphomeyaml-edge/README.md",
-  "webui": "http://[HOST]:[PORT:6052]",
+  "description": "Development build of the esphomeyaml HassIO add-on.",
+  "url": "https://esphomelib.com/esphomeyaml/index.html",
   "startup": "application",
+  "webui": "http://[HOST]:[PORT:6052]",
+  "boot": "auto",
+  "ports": {
+    "6052/tcp": 6052,
+    "6053/tcp": 6053
+  },
   "arch": [
     "aarch64",
     "amd64",
     "armhf",
     "i386"
   ],
-  "hassio_api": true,
-  "auth_api": true,
-  "hassio_role": "default",
-  "homeassistant_api": false,
-  "host_network": true,
-  "boot": "auto",
+  "auto_uart": true,
   "map": [
-    "ssl",
     "config:rw"
   ],
   "options": {
-    "ssl": false,
-    "certfile": "fullchain.pem",
-    "keyfile": "privkey.pem",
-    "port": 6052
+    "password": ""
   },
   "schema": {
-    "ssl": "bool",
-    "certfile": "str",
-    "keyfile": "str",
-    "port": "int",
-    "leave_front_door_open": "bool?",
-    "esphomeyaml_version": "str?"
+    "password": "str?"
+  },
+  "environment": {
+    "ESPHOMEYAML_OTA_HOST_PORT": "6053"
   }
 }

esphomeyaml-edge/rootfs/etc/cont-init.d/10-requirements.sh

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

esphomeyaml-edge/rootfs/etc/cont-init.d/20-nginx.sh

@@ -1,28 +0,0 @@
-#!/usr/bin/with-contenv bash
-# ==============================================================================
-# Community Hass.io Add-ons: esphomeyaml
-# Configures NGINX for use with esphomeyaml
-# ==============================================================================
-# shellcheck disable=SC1091
-source /usr/lib/hassio-addons/base.sh
-
-declare certfile
-declare keyfile
-declare port
-
-mkdir -p /var/log/nginx
-
-# Enable SSL
-if hass.config.true 'ssl'; then
-    rm /etc/nginx/nginx.conf
-    mv /etc/nginx/nginx-ssl.conf /etc/nginx/nginx.conf
-
-    certfile=$(hass.config.get 'certfile')
-    keyfile=$(hass.config.get 'keyfile')
-
-    sed -i "s/%%certfile%%/${certfile}/g" /etc/nginx/nginx.conf
-    sed -i "s/%%keyfile%%/${keyfile}/g" /etc/nginx/nginx.conf
-fi
-
-port=$(hass.config.get 'port')
-sed -i "s/%%port%%/${port}/g" /etc/nginx/nginx.conf

esphomeyaml-edge/rootfs/etc/cont-init.d/30-esphomeyaml.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/with-contenv bash
-# ==============================================================================
-# Community Hass.io Add-ons: esphomeyaml
-# This files installs the user esphomeyaml version if specified
-# ==============================================================================
-# shellcheck disable=SC1091
-source /usr/lib/hassio-addons/base.sh
-
-declare esphomeyaml_version
-
-if hass.config.has_value 'esphomeyaml_version'; then
-    esphomeyaml_version=$(hass.config.get 'esphomeyaml_version')
-    pip2 install --no-cache-dir --no-binary :all: "https://github.com/OttoWinter/esphomeyaml/archive/${esphomeyaml_version}.zip"
-fi

esphomeyaml-edge/rootfs/etc/nginx/nginx-ssl.conf

@@ -1,62 +0,0 @@
-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 esphomeyaml {
-        ip_hash;
-        server unix:/var/run/esphomeyaml.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://esphomeyaml;
-
-            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;
-        }
-    }
-}

esphomeyaml-edge/rootfs/etc/nginx/nginx.conf

@@ -1,46 +0,0 @@
-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 esphomeyaml {
-        ip_hash;
-        server unix:/var/run/esphomeyaml.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://esphomeyaml;
-
-            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;
-        }
-    }
-}

esphomeyaml-edge/rootfs/etc/services.d/esphomeyaml/finish

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

esphomeyaml-edge/rootfs/etc/services.d/esphomeyaml/run

@@ -1,14 +0,0 @@
-#!/usr/bin/with-contenv bash
-# ==============================================================================
-# Community Hass.io Add-ons: esphomeyaml
-# Runs the esphomeyaml dashboard
-# ==============================================================================
-# shellcheck disable=SC1091
-source /usr/lib/hassio-addons/base.sh
-
-if hass.config.true 'leave_front_door_open'; then
-    export DISABLE_HA_AUTHENTICATION=true
-fi
-
-hass.log.info "Starting esphomeyaml dashboard..."
-exec esphomeyaml /config/esphomeyaml dashboard --socket /var/run/esphomeyaml.sock --hassio

esphomeyaml-edge/rootfs/etc/services.d/nginx/finish

@@ -1,9 +0,0 @@
-#!/usr/bin/execlineb -S0
-# ==============================================================================
-# Community Hass.io Add-ons: esphomeyaml
-# 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

esphomeyaml-edge/rootfs/etc/services.d/nginx/run

@@ -1,10 +0,0 @@
-#!/usr/bin/with-contenv bash
-# ==============================================================================
-# Community Hass.io Add-ons: esphomeyaml
-# Runs the NGINX proxy
-# ==============================================================================
-# shellcheck disable=SC1091
-source /usr/lib/hassio-addons/base.sh
-
-hass.log.info "Starting NGINX..."
-exec nginx -g "daemon off;"

esphomeyaml/README.md

@@ -1,109 +0,0 @@
-# Esphomeyaml Hass.io Add-On
-
-[![esphomeyaml logo](https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/logo.png)](https://esphomelib.com/esphomeyaml/index.html)
-
-[![GitHub stars](https://img.shields.io/github/stars/OttoWinter/esphomelib.svg?style=social&label=Star&maxAge=2592000)](https://github.com/OttoWinter/esphomelib)
-[![GitHub Release][releases-shield]][releases]
-[![Discord][discord-shield]][discord]
-
-## About
-
-This add-on allows you to manage and program your ESP8266 and ESP32 based microcontrollers
-directly through Hass.io **with no programming experience required**. All you need to do
-is write YAML configuration files; the rest (over-the-air updates, compiling) is all
-handled by esphomeyaml.
-
-<p align="center">
-<img title="esphomeyaml dashboard screenshot" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/screenshot.png" width="700px"></img>
-</p>
-
-[_View the esphomeyaml documentation here_](https://esphomelib.com/esphomeyaml/index.html)
-
-## Example
-
-With esphomeyaml, you can go from a few lines of YAML straight to a custom-made
-firmware. For example, to include a [DHT22][dht22].
-temperature and humidity sensor, you just need to include 8 lines of YAML
-in your configuration file:
-
-<img title="esphomeyaml DHT configuration example" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/dht-example.png" width="500px"></img>
-
-Then just click UPLOAD and the sensor will magically appear in Home Assistant:
-
-<img title="esphomelib Home Assistant MQTT discovery" src="https://raw.githubusercontent.com/OttoWinter/esphomeyaml/dev/esphomeyaml-edge/images/temperature-humidity.png" width="600px"></img>
-
-## Installation
-
-To install this Hass.io add-on you need to add the esphomeyaml add-on repository
-first:
-
-1. Add the epshomeyaml add-ons repository to your Hass.io instance. You can do this by navigating to the "Add-on Store" tab in the Hass.io panel and then entering https://github.com/OttoWinter/esphomeyaml in the "Add new repository by URL" field.
-2. Now scroll down and select the "esphomeyaml" add-on.
-3. Press install to download the add-on and unpack it on your machine. This can take some time.
-4. Optional: If you're using SSL certificates and want to encrypt your communication to this add-on, please enter `true` into the `ssl` field and set the `fullchain` and `certfile` options accordingly.
-5. Start the add-on, check the logs of the add-on to see if everything went well.
-6. Click "OPEN WEB UI" to open the esphomeyaml dashboard. You will be asked for your Home Assistant credentials - esphomeyaml uses Hass.io's authentication system to log you in.
-
-**NOTE**: Installation on RPis running in 64-bit mode is currently not possible. Please use the 32-bit variant of HassOS instead.
-
-You can view the esphomeyaml docs here: https://esphomelib.com/esphomeyaml/index.html
-
-## Configuration
-
-**Note**: _Remember to restart the add-on when the configuration is changed._
-
-Example add-on configuration:
-
-```json
-{
-  "ssl": false,
-  "certfile": "fullchain.pem",
-  "keyfile": "privkey.pem",
-  "port": 6052
-}
-```
-
-### Option: `port`
-
-The port to start the dashboard server on. Default is 6052.
-
-### Option: `ssl`
-
-Enables/Disables encrypted SSL (HTTPS) connections to the web server of this add-on.
-Set it to `true` to encrypt communications, `false` otherwise.
-Please note that if you set this to `true` you must also generate the key and certificate
-files for encryption. For example using [Let's Encrypt](https://www.home-assistant.io/addons/lets_encrypt/)
-or [Self-signed certificates](https://www.home-assistant.io/docs/ecosystem/certificates/tls_self_signed_certificate/).
-
-### Option: `certfile`
-
-The certificate file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `keyfile`
-
-The private key file to use for SSL. If this file doesn't exist, the add-on start will fail.
-
-**Note**: The file MUST be stored in `/ssl/`, which is the default for Hass.io
-
-### Option: `leave_front_door_open`
-
-Adding this option to the add-on configuration allows you to disable
-authentication by setting it to `true`.
-
-### Option: `esphomeyaml_version`
-
-Manually override which esphomeyaml version to use in the addon.
-For example to install the latest development version, use `"esphomeyaml_version": "dev"`,
-or for version 1.10.0: `"esphomeyaml_version": "v1.10.0""`.
- 
-Please note that this does not always work and is only meant for testing, usually the
-esphomeyaml add-on and dashboard version must match to guarantee a working system.  
-
-[discord-shield]: https://img.shields.io/discord/429907082951524364.svg
-[dht22]: https://esphomelib.com/esphomeyaml/components/sensor/dht.html
-[discord]: https://discord.me/KhAMKrd
-[releases-shield]: https://img.shields.io/github/release/OttoWinter/esphomeyaml.svg
-[releases]: https://esphomelib.com/esphomeyaml/changelog/index.html
-[repository]: https://github.com/OttoWinter/esphomeyaml

esphomeyaml/__main__.py

@@ -1,30 +1,26 @@
 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_config, mqtt, platformio_api, wizard, writer, yaml_util
-from esphomeyaml.api.client import run_logs
-from esphomeyaml.config import get_component, iter_components, read_config, strip_default_ids
-from esphomeyaml.const import CONF_BAUD_RATE, CONF_ESPHOMEYAML, CONF_LOGGER, CONF_USE_CUSTOM_CODE, \
-    CONF_BROKER
-from esphomeyaml.core import CORE, EsphomeyamlError
-from esphomeyaml.cpp_generator import Expression, RawStatement, add, statement
-from esphomeyaml.helpers import color, indent
-from esphomeyaml.py_compat import safe_input, text_type, IS_PY2
-from esphomeyaml.storage_json import StorageJSON, esphomeyaml_storage_path, \
-    start_update_check_thread, storage_path
-from esphomeyaml.util import run_external_command, safe_print
+from esphomeyaml import const, core, core_config, mqtt, wizard, writer, yaml_util
+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, quote, statement, relative_path
+from esphomeyaml.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
 
-PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ethernet', 'ota', 'mqtt', 'web_server', 'api',
-                  'i2c']
+PRE_INITIALIZE = ['esphomeyaml', 'logger', 'wifi', 'ota', 'mqtt', 'web_server', 'i2c']
 
 
 def get_serial_ports():
@@ -36,64 +32,65 @@ 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_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))
+def choose_serial_port(config):
+    result = get_serial_ports()
 
+    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 = safe_input('(number): ')
-        if opt in options:
-            opt = options.index(opt)
+        opt = raw_input('(number): ')
+        if opt in result:
+            opt = result.index(opt)
             break
         try:
             opt = int(opt)
-            if opt < 1 or opt > len(options):
+            if opt < 0 or opt > len(result):
                 raise ValueError
             break
         except ValueError:
             safe_print(color('red', u"Invalid option: '{}'".format(opt)))
-    return options[opt - 1][1]
+    if opt == len(result):
+        return 'OTA'
+    return result[opt][0]
 
 
-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 run_platformio(*cmd, **kwargs):
+    def mock_exit(return_code):
+        raise SystemExit(return_code)
+
+    orig_argv = sys.argv
+    orig_exit = sys.exit  # mock sys.exit
+    full_cmd = u' '.join(quote(x) for x in cmd)
+    _LOGGER.info(u"Running:  %s", full_cmd)
+    try:
+        func = kwargs.get('main')
+        if func is None:
+            import platformio.__main__
+            func = platformio.__main__.main
+        sys.argv = list(cmd)
+        sys.exit = mock_exit
+        return func() or 0
+    except KeyboardInterrupt:
+        return 1
+    except SystemExit as err:
+        return err.args[0]
+    except Exception as err:  # pylint: disable=broad-except
+        _LOGGER.error(u"Running platformio failed: %s", err)
+        _LOGGER.error(u"Please try running %s locally.", full_cmd)
+    finally:
+        sys.argv = orig_argv
+        sys.exit = orig_exit
 
 
-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):
+def run_miniterm(config, port, escape=False):
     import serial
     if CONF_LOGGER not in config:
         _LOGGER.info("Logger is not enabled. Not starting UART logs.")
@@ -103,7 +100,6 @@ def run_miniterm(config, port):
         _LOGGER.info("UART logging is disabled (baud_rate=0). Not starting UART logs.")
     _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
 
-    backtrace_state = False
     with serial.Serial(port, baudrate=baud_rate) as ser:
         while True:
             try:
@@ -111,81 +107,110 @@ def run_miniterm(config, port):
             except serial.SerialException:
                 _LOGGER.error("Serial port closed!")
                 return
-            if IS_PY2:
-                line = raw.replace('\r', '').replace('\n', '')
-            else:
-                line = raw.replace(b'\r', b'').replace(b'\n', b'').decode('utf8',
-                                                                          'backslashreplace')
+            line = raw.replace('\r', '').replace('\n', '')
             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(
-                config, line, backtrace_state=backtrace_state)
-
 
 def write_cpp(config):
     _LOGGER.info("Generating C++ source...")
 
-    CORE.add_job(core_config.to_code, config[CONF_ESPHOMEYAML], domain='esphomeyaml')
+    add_job(core_config.to_code, config[CONF_ESPHOMEYAML], domain='esphomeyaml')
     for domain in PRE_INITIALIZE:
         if domain == CONF_ESPHOMEYAML or domain not in config:
             continue
-        CORE.add_job(get_component(domain).to_code, config[domain], domain=domain)
+        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
-        CORE.add_job(component.to_code, conf, domain=domain)
+        add_job(component.to_code, conf, domain=domain)
 
-    CORE.flush_tasks()
+    flush_tasks()
     add(RawStatement(''))
     add(RawStatement(''))
     all_code = []
-    for exp in CORE.expressions:
+    for exp in _EXPRESSIONS:
         if not config[CONF_ESPHOMEYAML][CONF_USE_CUSTOM_CODE]:
             if isinstance(exp, Expression) and not exp.required:
                 continue
-        all_code.append(text_type(statement(exp)))
+            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)))
 
-    writer.write_platformio_project()
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    writer.write_platformio_project(config, build_path)
 
     code_s = indent('\n'.join(line.rstrip() for line in all_code))
-    writer.write_cpp(code_s)
+    cpp_path = os.path.join(build_path, 'src', 'main.cpp')
+    writer.write_cpp(code_s, cpp_path)
     return 0
 
 
 def compile_program(args, config):
     _LOGGER.info("Compiling app...")
-    update_check = not os.getenv('ESPHOMEYAML_NO_UPDATE_CHECK', '')
-    if update_check:
-        thread = start_update_check_thread(esphomeyaml_storage_path(CORE.config_dir))
-    rc = platformio_api.run_compile(config, args.verbose)
-    if update_check:
-        thread.join()
-    return rc
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    command = ['platformio', 'run', '-d', build_path]
+    if args.verbose:
+        command.append('-v')
+    return run_platformio(*command)
+
+
+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
 
 
 def upload_using_esptool(config, port):
     import esptool
 
-    path = os.path.join(CORE.build_path, '.pioenvs', CORE.name, 'firmware.bin')
-    cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
-           '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+    path = os.path.join(build_path, '.pioenvs', core.NAME, 'firmware.bin')
     # pylint: disable=protected-access
-    return run_external_command(esptool._main, *cmd)
+    return run_platformio('esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
+                          '--chip', 'esp8266', '--port', port, 'write_flash', '0x0',
+                          path, main=esptool._main)
 
 
-def upload_program(config, args, host):
+def upload_program(config, args, port):
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
+
     # if upload is to a serial port use platformio, otherwise assume ota
-    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)
+    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)
+        command = ['platformio', 'run', '-d', build_path,
+                   '-t', 'upload', '--upload-port', port]
+        if args.verbose:
+            command.append('-v')
+        return run_platformio(*command)
+
+    if 'ota' not in config:
+        _LOGGER.error("No serial port found and OTA not enabled. Can't upload!")
+        return -1
+
+    # 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:
@@ -195,31 +220,20 @@ def upload_program(config, args, host):
     remote_port = ota.get_port(config)
     password = ota.get_auth(config)
 
-    storage = StorageJSON.load(storage_path())
-    res = espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
+    res = espota2.run_ota(host, remote_port, password, bin_file)
     if res == 0:
-        if storage is not None and storage.use_legacy_ota:
-            storage.use_legacy_ota = False
-            storage.save(storage_path())
         return res
-    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)
+    _LOGGER.warn("OTA v2 method failed. Trying with legacy OTA...")
+    return espota2.run_legacy_ota(verbose, host_port, host, remote_port, password, bin_file)
 
 
-def show_logs(config, args, port):
-    if get_port_type(port) == 'SERIAL':
-        run_miniterm(config, port)
+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)
         return 0
-    if get_port_type(port) == 'NETWORK':
-        return run_logs(config, port)
-    if get_port_type(port) == 'MQTT':
-        return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
-
-    raise ValueError
+    return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id,
+                          escape=escape)
 
 
 def clean_mqtt(config, args):
@@ -229,7 +243,7 @@ def clean_mqtt(config, args):
 def setup_log(debug=False):
     log_level = logging.DEBUG if debug else logging.INFO
     logging.basicConfig(level=log_level)
-    fmt = "%(levelname)s %(message)s"
+    fmt = "%(levelname)s [%(name)s] %(message)s"
     colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
     datefmt = '%H:%M:%S'
 
@@ -257,8 +271,26 @@ 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,8 +312,7 @@ def command_compile(args, config):
 
 
 def command_upload(args, config):
-    port = choose_upload_log_host(default=args.upload_port, check_default=None,
-                                  show_ota=True, show_mqtt=False, show_api=False)
+    port = args.upload_port or choose_serial_port(config)
     exit_code = upload_program(config, args, port)
     if exit_code != 0:
         return exit_code
@@ -290,9 +321,8 @@ def command_upload(args, config):
 
 
 def command_logs(args, config):
-    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)
+    port = args.serial_port or choose_serial_port(config)
+    return show_logs(config, args, port, escape=args.escape)
 
 
 def command_run(args, config):
@@ -303,17 +333,14 @@ def command_run(args, config):
     if exit_code != 0:
         return exit_code
     _LOGGER.info(u"Successfully compiled program.")
-    port = choose_upload_log_host(default=args.upload_port, check_default=None,
-                                  show_ota=True, show_mqtt=False, show_api=True)
+    port = args.upload_port or choose_serial_port(config)
     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
-    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)
+    return show_logs(config, args, port, escape=args.escape)
 
 
 def command_clean_mqtt(args, config):
@@ -330,8 +357,9 @@ def command_version(args):
 
 
 def command_clean(args, config):
+    build_path = relative_path(config[CONF_ESPHOMEYAML][CONF_BUILD_PATH])
     try:
-        writer.clean_build()
+        writer.clean_build(build_path)
     except OSError as err:
         _LOGGER.error("Error deleting build files: %s", err)
         return 1
@@ -339,28 +367,6 @@ 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
 
@@ -382,7 +388,6 @@ POST_CONFIG_ACTIONS = {
     'clean-mqtt': command_clean_mqtt,
     'mqtt-fingerprint': command_mqtt_fingerprint,
     'clean': command_clean,
-    'hass-config': command_hass_config,
 }
 
 
@@ -390,8 +395,6 @@ def parse_args(argv):
     parser = argparse.ArgumentParser(prog='esphomeyaml')
     parser.add_argument('-v', '--verbose', help="Enable verbose esphomeyaml 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')
@@ -409,6 +412,9 @@ 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.')
@@ -418,6 +424,8 @@ 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.')
@@ -430,6 +438,11 @@ 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.")
@@ -449,49 +462,36 @@ def parse_args(argv):
 
     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. Defaults to 6052.",
-                           type=int, default=6052)
+    dashboard.add_argument("--port", help="The HTTP port to open connections on.", 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')
-    dashboard.add_argument("--hassio",
-                           help="Internal flag used to tell esphomeyaml 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)
-
-    subparsers.add_parser('hass-config',
-                          help="Dump the configuration entries that should be added "
-                               "to Home Assistant when not using MQTT discovery.")
 
     return parser.parse_args(argv[1:])
 
 
 def run_esphomeyaml(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 ESPHomeYAMLError as e:
             _LOGGER.error(e)
             return 1
 
-    CORE.config_path = args.configuration
+    core.CONFIG_PATH = args.configuration
 
-    config = read_config(args.verbose)
+    config = read_config(core.CONFIG_PATH)
     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 ESPHomeYAMLError as e:
             _LOGGER.error(e)
             return 1
     safe_print(u"Unknown command {}".format(args.command))
@@ -501,7 +501,7 @@ def run_esphomeyaml(argv):
 def main():
     try:
         return run_esphomeyaml(sys.argv)
-    except EsphomeyamlError as e:
+    except ESPHomeYAMLError as e:
         _LOGGER.error(e)
         return 1
     except KeyboardInterrupt:

esphomeyaml/api/api.proto

@@ -1,330 +0,0 @@
-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 esphomeyaml, 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;
-}
-

esphomeyaml/api/client.py

@@ -1,490 +0,0 @@
-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 esphomeyaml import const
-import esphomeyaml.api.api_pb2 as pb
-from esphomeyaml.const import CONF_PASSWORD, CONF_PORT
-from esphomeyaml.core import EsphomeyamlError
-from esphomeyaml.helpers import resolve_ip_address, indent, color
-from esphomeyaml.py_compat import text_type, IS_PY2, byte_to_bytes, char_to_byte, format_bytes
-from esphomeyaml.util import safe_print
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class APIConnectionError(EsphomeyamlError):
-    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 EsphomeyamlError 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://esphomelib.com/esphomeyaml/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 = 'esphomeyaml 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 esphomelib API", address)
-
-    cli = APIClient(address, port, password)
-    stopping = False
-    retry_timer = []
-
-    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)
-        _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)
-
-    has_connects = []
-
-    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

esphomeyaml/automation.py

@@ -2,15 +2,15 @@ import copy
 
 import voluptuous as vol
 
+from esphomeyaml import core
 import esphomeyaml.config_validation as cv
 from esphomeyaml.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_WHILE
-from esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import ArrayInitializer, Pvariable, TemplateArguments, add, \
-    get_variable, process_lambda, templatable
-from esphomeyaml.cpp_types import Action, App, Component, PollingComponent, Trigger, \
-    esphomelib_ns, float_, uint32, void, bool_
+    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
+from esphomeyaml.core import ESPHomeYAMLError
+from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, TemplateArguments, add, add_job, \
+    esphomelib_ns, float_, process_lambda, templatable, uint32, get_variable
 from esphomeyaml.util import ServiceRegistry
 
 
@@ -26,98 +26,63 @@ def maybe_simple_id(*validators):
 
 
 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])
-        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
+    return CONDITIONS_SCHEMA(value)
 
 
 def validate_recursive_action(value):
-    is_list = isinstance(value, list)
-    if not is_list:
-        value = [value]
+    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"Action must consist of key-value mapping! Got {}".format(item),
-                              path)
+            raise vol.Invalid(u"Action must consist of key-value mapping! Got {}".format(item))
         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)
+            raise vol.Invalid(u"Key missing from action! Got {}".format(item))
         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])
+                              u"".format(key))
         item.setdefault(CONF_ACTION_ID, None)
-        key2 = next((x for x in item if x not in (CONF_ACTION_ID, key)), None)
+        key2 = next((x for x in item if x != CONF_ACTION_ID and x != 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)
+            raise vol.Invalid(u"Cannot have two actions in one item. Key {} overrides {}!"
+                              u"".format(key, key2))
         validator = ACTION_REGISTRY[key][0]
-        try:
-            action = validator(item[key])
-        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,
+            CONF_ACTION_ID: cv.declare_variable_id(None)(item[CONF_ACTION_ID]),
+            key: validator(item[key])
         }
     return value
 
 
 ACTION_REGISTRY = ServiceRegistry()
-CONDITION_REGISTRY = ServiceRegistry()
 
 # pylint: disable=invalid-name
-DelayAction = esphomelib_ns.class_('DelayAction', Action, Component)
-LambdaAction = esphomelib_ns.class_('LambdaAction', Action)
-IfAction = esphomelib_ns.class_('IfAction', Action)
-WhileAction = esphomelib_ns.class_('WhileAction', Action)
-UpdateComponentAction = esphomelib_ns.class_('UpdateComponentAction', Action)
-Automation = esphomelib_ns.class_('Automation')
+DelayAction = esphomelib_ns.DelayAction
+LambdaAction = esphomelib_ns.LambdaAction
+IfAction = esphomelib_ns.IfAction
+UpdateComponentAction = esphomelib_ns.UpdateComponentAction
+Automation = esphomelib_ns.Automation
 
-Condition = esphomelib_ns.class_('Condition')
-AndCondition = esphomelib_ns.class_('AndCondition', Condition)
-OrCondition = esphomelib_ns.class_('OrCondition', Condition)
-RangeCondition = esphomelib_ns.class_('RangeCondition', Condition)
-LambdaCondition = esphomelib_ns.class_('LambdaCondition', Condition)
+CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [cv.templatable({
+    cv.GenerateID(CONF_CONDITION_ID): cv.declare_variable_id(None),
+    vol.Optional(CONF_AND): validate_recursive_condition,
+    vol.Optional(CONF_OR): validate_recursive_condition,
+    vol.Optional(CONF_RANGE): vol.All(vol.Schema({
+        vol.Optional(CONF_ABOVE): vol.Coerce(float),
+        vol.Optional(CONF_BELOW): vol.Coerce(float),
+    }), cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
+    vol.Optional(CONF_LAMBDA): cv.lambda_,
+})])
+
+# pylint: disable=invalid-name
+AndCondition = esphomelib_ns.AndCondition
+OrCondition = esphomelib_ns.OrCondition
+RangeCondition = esphomelib_ns.RangeCondition
+LambdaCondition = esphomelib_ns.LambdaCondition
 
 
 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)
+    schema = AUTOMATION_SCHEMA.extend(extra_schema or {})
 
     def validator_(value):
         if isinstance(value, list):
@@ -129,8 +94,6 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
                 try:
                     return vol.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:
@@ -153,65 +116,65 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
 
 
 AUTOMATION_SCHEMA = vol.Schema({
-    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(Trigger),
-    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(Automation),
-    vol.Optional(CONF_IF): validate_recursive_condition,
+    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(None),
+    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_variable_id(None),
+    vol.Optional(CONF_IF): CONDITIONS_SCHEMA,
     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, arg_type, template_arg):
-    for conditions in build_conditions(config, arg_type):
-        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, arg_type, template_arg):
-    for conditions in build_conditions(config, arg_type):
-        yield
-    rhs = OrCondition.new(template_arg, conditions)
-    type = OrCondition.template(template_arg)
-    yield Pvariable(condition_id, rhs, type=type)
-
-
-RANGE_CONDITION_SCHEMA = vol.All(vol.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, arg_type, template_arg):
-    for conditions in build_conditions(config, arg_type):
-        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], arg_type, float_):
+def build_condition(config, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    if isinstance(config, core.Lambda):
+        lambda_ = None
+        for lambda_ in process_lambda(config, [(arg_type, 'x')]):
             yield
-        condition.set_min(template_)
-    if CONF_BELOW in config:
-        for template_ in templatable(config[CONF_BELOW], arg_type, float_):
+        yield LambdaCondition.new(template_arg, lambda_)
+    elif CONF_AND in config:
+        yield AndCondition.new(template_arg, build_conditions(config[CONF_AND], template_arg))
+    elif CONF_OR in config:
+        yield OrCondition.new(template_arg, build_conditions(config[CONF_OR], template_arg))
+    elif CONF_LAMBDA in config:
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(arg_type, 'x')]):
             yield
-        condition.set_max(template_)
-    yield condition
+        yield LambdaCondition.new(template_arg, lambda_)
+    elif CONF_RANGE in config:
+        conf = config[CONF_RANGE]
+        rhs = RangeCondition.new(template_arg)
+        type = RangeCondition.template(template_arg)
+        condition = Pvariable(config[CONF_CONDITION_ID], rhs, type=type)
+        if CONF_ABOVE in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_ABOVE], arg_type, float_):
+                yield
+            condition.set_min(template_)
+        if CONF_BELOW in conf:
+            template_ = None
+            for template_ in templatable(conf[CONF_BELOW], arg_type, float_):
+                yield
+            condition.set_max(template_)
+        yield condition
+    else:
+        raise ESPHomeYAMLError(u"Unsupported condition {}".format(config))
+
+
+def build_conditions(config, arg_type):
+    conditions = []
+    for conf in config:
+        condition = None
+        for condition in build_condition(conf, arg_type):
+            yield None
+        conditions.append(condition)
+    yield ArrayInitializer(*conditions)
 
 
 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, arg_type, template_arg):
+def delay_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     rhs = App.register_component(DelayAction.new(template_arg))
     type = DelayAction.template(template_arg)
     action = Pvariable(action_id, rhs, type=type)
@@ -229,7 +192,8 @@ IF_ACTION_SCHEMA = vol.All({
 
 
 @ACTION_REGISTRY.register(CONF_IF, IF_ACTION_SCHEMA)
-def if_action_to_code(config, action_id, arg_type, template_arg):
+def if_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for conditions in build_conditions(config[CONF_CONDITION], arg_type):
         yield None
     rhs = IfAction.new(template_arg, conditions)
@@ -246,60 +210,31 @@ def if_action_to_code(config, action_id, arg_type, template_arg):
     yield action
 
 
-WHILE_ACTION_SCHEMA = vol.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, arg_type, template_arg):
-    for conditions in build_conditions(config[CONF_CONDITION], arg_type):
-        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], arg_type):
-        yield None
-    add(action.add_then(actions))
-    yield action
-
-
 LAMBDA_ACTION_SCHEMA = cv.lambda_
 
 
 @ACTION_REGISTRY.register(CONF_LAMBDA, LAMBDA_ACTION_SCHEMA)
-def lambda_action_to_code(config, action_id, arg_type, template_arg):
-    for lambda_ in process_lambda(config, [(arg_type, 'x')], return_type=void):
+def lambda_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
+    for lambda_ in process_lambda(config, [(arg_type, 'x')]):
         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, arg_type, template_arg):
-    for lambda_ in process_lambda(config, [(arg_type, 'x')], 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),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @ACTION_REGISTRY.register(CONF_COMPONENT_UPDATE, COMPONENT_UPDATE_ACTION_SCHEMA)
-def component_update_action_to_code(config, action_id, arg_type, template_arg):
+def component_update_action_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
-    rhs = UpdateComponentAction.new(template_arg, var)
+    rhs = UpdateComponentAction.new(var)
     type = UpdateComponentAction.template(template_arg)
     yield Pvariable(action_id, rhs, type=type)
 
@@ -309,8 +244,7 @@ def build_action(full_config, arg_type):
     key, config = next((k, v) for k, v in full_config.items() if k in ACTION_REGISTRY)
 
     builder = ACTION_REGISTRY[key][1]
-    template_arg = TemplateArguments(arg_type)
-    for result in builder(config, action_id, arg_type, template_arg):
+    for result in builder(config, action_id, arg_type):
         yield None
     yield result
 
@@ -325,26 +259,6 @@ def build_actions(config, arg_type):
     yield ArrayInitializer(*actions, multiline=False)
 
 
-def build_condition(full_config, arg_type):
-    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]
-    template_arg = TemplateArguments(arg_type)
-    for result in builder(config, action_id, arg_type, template_arg):
-        yield None
-    yield result
-
-
-def build_conditions(config, arg_type):
-    conditions = []
-    for conf in config:
-        for condition in build_condition(conf, arg_type):
-            yield None
-        conditions.append(condition)
-    yield ArrayInitializer(*conditions, multiline=False)
-
-
 def build_automation_(trigger, arg_type, config):
     rhs = App.make_automation(TemplateArguments(arg_type), trigger)
     type = Automation.template(arg_type)
@@ -362,4 +276,4 @@ def build_automation_(trigger, arg_type, config):
 
 
 def build_automation(trigger, arg_type, config):
-    CORE.add_job(build_automation_, trigger, arg_type, config)
+    add_job(build_automation_, trigger, arg_type, config)

esphomeyaml/components/ads1115.py

@@ -1,27 +1,30 @@
 import voluptuous as vol
 
-from esphomeyaml.components import i2c, sensor
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_ID
-from esphomeyaml.cpp_generator import Pvariable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_RATE
+from esphomeyaml.helpers import App, Pvariable
 
 DEPENDENCIES = ['i2c']
-MULTI_CONF = True
 
-ADS1115Component = sensor.sensor_ns.class_('ADS1115Component', Component, i2c.I2CDevice)
+ADS1115Component = sensor.sensor_ns.ADS1115Component
 
-CONFIG_SCHEMA = vol.Schema({
+RATE_REMOVE_MESSAGE = """The rate option has been removed in 1.5.0 and is no longer required."""
+
+ADS1115_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(ADS1115Component),
     vol.Required(CONF_ADDRESS): cv.i2c_address,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+
+    vol.Optional(CONF_RATE): cv.invalid(RATE_REMOVE_MESSAGE)
+})
+
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [ADS1115_SCHEMA])
 
 
 def to_code(config):
-    rhs = App.make_ads1115_component(config[CONF_ADDRESS])
-    var = Pvariable(config[CONF_ID], rhs)
-    setup_component(var, config)
+    for conf in config:
+        rhs = App.make_ads1115_component(conf[CONF_ADDRESS])
+        Pvariable(conf[CONF_ID], rhs)
 
 
 BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'

esphomeyaml/components/apds9960.py

@@ -1,33 +0,0 @@
-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_UPDATE_INTERVAL
-from esphomeyaml.cpp_generator import Pvariable, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.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 = vol.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'

esphomeyaml/components/api.py

@@ -1,88 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml.automation import ACTION_REGISTRY
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
-    CONF_SERVICE, CONF_VARIABLES, CONF_REBOOT_TIMEOUT
-from esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import ArrayInitializer, Pvariable, add, get_variable, process_lambda
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import Action, App, Component, StoringController, esphomelib_ns
-
-api_ns = esphomelib_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')
-
-CONFIG_SCHEMA = vol.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,
-}).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]))
-
-    setup_component(api, config)
-
-
-BUILD_FLAGS = '-DUSE_API'
-
-
-def lib_deps(config):
-    if CORE.is_esp32:
-        return 'AsyncTCP@1.0.1'
-    if CORE.is_esp8266:
-        return 'ESPAsyncTCP@1.1.3'
-    raise NotImplementedError
-
-
-CONF_HOMEASSISTANT_SERVICE = 'homeassistant.service'
-HOMEASSISTANT_SERVIC_ACTION_SCHEMA = vol.Schema({
-    cv.GenerateID(): cv.use_variable_id(APIServer),
-    vol.Required(CONF_SERVICE): cv.string,
-    vol.Optional(CONF_DATA): vol.Schema({
-        cv.string: cv.string,
-    }),
-    vol.Optional(CONF_DATA_TEMPLATE): vol.Schema({
-        cv.string: cv.string,
-    }),
-    vol.Optional(CONF_VARIABLES): vol.Schema({
-        cv.string: cv.lambda_,
-    }),
-})
-
-
-@ACTION_REGISTRY.register(CONF_HOMEASSISTANT_SERVICE, HOMEASSISTANT_SERVIC_ACTION_SCHEMA)
-def homeassistant_service_to_code(config, action_id, arg_type, template_arg):
-    for var in get_variable(config[CONF_ID]):
-        yield None
-    rhs = var.make_home_assistant_service_call_action(template_arg)
-    type = HomeAssistantServiceCallAction.template(arg_type)
-    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(ArrayInitializer(*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(ArrayInitializer(*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(ArrayInitializer(*datas)))
-    yield act

esphomeyaml/components/binary_sensor/__init__.py

@@ -1,21 +1,13 @@
 import voluptuous as vol
 
-from esphomeyaml import automation, core
-from esphomeyaml.automation import maybe_simple_id, CONDITION_REGISTRY, Condition
-from esphomeyaml.components import mqtt
-from esphomeyaml.components.mqtt import setup_mqtt_component
 import esphomeyaml.config_validation as cv
-from esphomeyaml.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, CONF_ON_STATE
-from esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import process_lambda, ArrayInitializer, add, Pvariable, \
-    StructInitializer, get_variable
-from esphomeyaml.cpp_types import esphomelib_ns, Nameable, Trigger, NoArg, Component, App, bool_, \
-    optional
-from esphomeyaml.py_compat import string_types
+from esphomeyaml import automation
+from esphomeyaml.const import CONF_DEVICE_CLASS, CONF_ID, CONF_INTERNAL, CONF_INVERTED, \
+    CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_MQTT_ID, CONF_ON_CLICK, CONF_ON_DOUBLE_CLICK, \
+    CONF_ON_PRESS, CONF_ON_RELEASE, CONF_TRIGGER_ID, CONF_FILTERS, CONF_INVERT, CONF_DELAYED_ON, \
+    CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT
+from esphomeyaml.helpers import App, NoArg, Pvariable, add, add_job, esphomelib_ns, \
+    setup_mqtt_component, bool_, process_lambda, ArrayInitializer
 
 DEVICE_CLASSES = [
     '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
@@ -29,138 +21,33 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 })
 
 binary_sensor_ns = esphomelib_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)
-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')
-DelayedOnFilter = binary_sensor_ns.class_('DelayedOnFilter', Filter, Component)
-DelayedOffFilter = binary_sensor_ns.class_('DelayedOffFilter', Filter, Component)
-HeartbeatFilter = binary_sensor_ns.class_('HeartbeatFilter', Filter, Component)
-InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
-LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
-
+PressTrigger = binary_sensor_ns.PressTrigger
+ReleaseTrigger = binary_sensor_ns.ReleaseTrigger
+ClickTrigger = binary_sensor_ns.ClickTrigger
+DoubleClickTrigger = binary_sensor_ns.DoubleClickTrigger
+BinarySensor = binary_sensor_ns.BinarySensor
+InvertFilter = binary_sensor_ns.InvertFilter
+LambdaFilter = binary_sensor_ns.LambdaFilter
+DelayedOnFilter = binary_sensor_ns.DelayedOnFilter
+DelayedOffFilter = binary_sensor_ns.DelayedOffFilter
+HeartbeatFilter = binary_sensor_ns.HeartbeatFilter
+MQTTBinarySensorComponent = binary_sensor_ns.MQTTBinarySensorComponent
 
 FILTER_KEYS = [CONF_INVERT, CONF_DELAYED_ON, CONF_DELAYED_OFF, CONF_LAMBDA, CONF_HEARTBEAT]
 
-FILTERS_SCHEMA = cv.ensure_list({
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.All({
     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_STATE): cv.boolean,
-    vol.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds,
-    vol.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds,
-})
-
-
-def parse_multi_click_timing_str(value):
-    if not isinstance(value, string_types):
-        return value
-
-    parts = value.lower().split(' ')
-    if len(parts) != 5:
-        raise vol.Invalid("Multi click timing grammar consists of exactly 5 words, not {}"
-                          "".format(len(parts)))
-    try:
-        state = cv.boolean(parts[0])
-    except vol.Invalid:
-        raise vol.Invalid(u"First word must either be ON or OFF, not {}".format(parts[0]))
-
-    if parts[1] != 'for':
-        raise vol.Invalid(u"Second word must be 'for', got {}".format(parts[1]))
-
-    if parts[2] == 'at':
-        if parts[3] == 'least':
-            key = CONF_MIN_LENGTH
-        elif parts[3] == 'most':
-            key = CONF_MAX_LENGTH
-        else:
-            raise vol.Invalid(u"Third word after at must either be 'least' or 'most', got {}"
-                              u"".format(parts[3]))
-        try:
-            length = cv.positive_time_period_milliseconds(parts[4])
-        except vol.Invalid as err:
-            raise vol.Invalid(u"Multi Click Grammar Parsing length failed: {}".format(err))
-        return {
-            CONF_STATE: state,
-            key: str(length)
-        }
-
-    if parts[3] != 'to':
-        raise vol.Invalid("Multi click grammar: 4th word must be 'to'")
-
-    try:
-        min_length = cv.positive_time_period_milliseconds(parts[2])
-    except vol.Invalid as err:
-        raise vol.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
-
-    try:
-        max_length = cv.positive_time_period_milliseconds(parts[4])
-    except vol.Invalid as err:
-        raise vol.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
-
-    return {
-        CONF_STATE: state,
-        CONF_MIN_LENGTH: str(min_length),
-        CONF_MAX_LENGTH: str(max_length)
-    }
-
-
-def validate_multi_click_timing(value):
-    if not isinstance(value, list):
-        raise vol.Invalid("Timing option must be a *list* of times!")
-    timings = []
-    state = None
-    for i, v_ in enumerate(value):
-        v_ = MULTI_CLICK_TIMING_SCHEMA(v_)
-        min_length = v_.get(CONF_MIN_LENGTH)
-        max_length = v_.get(CONF_MAX_LENGTH)
-        if min_length is None and max_length is None:
-            raise vol.Invalid("At least one of min_length and max_length is required!")
-        if min_length is None and max_length is not None:
-            min_length = core.TimePeriodMilliseconds(milliseconds=0)
-
-        new_state = v_.get(CONF_STATE, not state)
-        if new_state == state:
-            raise vol.Invalid("Timings must have alternating state. Indices {} and {} have "
-                              "the same state {}".format(i, i + 1, state))
-        if max_length is not None and max_length < min_length:
-            raise vol.Invalid("Max length ({}) must be larger than min length ({})."
-                              "".format(max_length, min_length))
-
-        state = new_state
-        tim = {
-            CONF_STATE: new_state,
-            CONF_MIN_LENGTH: min_length,
-        }
-        if max_length is not None:
-            tim[CONF_MAX_LENGTH] = max_length
-        timings.append(tim)
-    return timings
-
+}, cv.has_exactly_one_key(*FILTER_KEYS))])
 
 BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
     cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTBinarySensorComponent),
+    cv.GenerateID(): cv.declare_variable_id(BinarySensor),
 
-    vol.Optional(CONF_DEVICE_CLASS): cv.one_of(*DEVICE_CLASSES, lower=True),
+    vol.Optional(CONF_DEVICE_CLASS): vol.All(vol.Lower, cv.one_of(*DEVICE_CLASSES)),
     vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
     vol.Optional(CONF_ON_PRESS): automation.validate_automation({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(PressTrigger),
@@ -178,15 +65,6 @@ BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
         vol.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MultiClickTrigger),
-        vol.Required(CONF_TIMING): vol.All([parse_multi_click_timing_str],
-                                           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 "
@@ -208,8 +86,8 @@ def setup_filter(config):
     elif CONF_HEARTBEAT in config:
         yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
     elif CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')],
-                                      return_type=optional.template(bool_)):
+        lambda_ = None
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(bool_, 'x')]):
             yield None
         yield LambdaFilter.new(lambda_)
 
@@ -258,27 +136,6 @@ def setup_binary_sensor_core_(binary_sensor_var, mqtt_var, config):
         trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
         automation.build_automation(trigger, NoArg, conf)
 
-    for conf in config.get(CONF_ON_MULTI_CLICK, []):
-        timings = []
-        for tim in conf[CONF_TIMING]:
-            timings.append(StructInitializer(
-                MultiClickTriggerEvent,
-                ('state', tim[CONF_STATE]),
-                ('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)
-
-    for conf in config.get(CONF_ON_STATE, []):
-        rhs = binary_sensor_var.make_state_trigger()
-        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
-        automation.build_automation(trigger, bool_, conf)
-
     setup_mqtt_component(mqtt_var, config)
 
 
@@ -287,54 +144,14 @@ def setup_binary_sensor(binary_sensor_obj, mqtt_obj, config):
                                   has_side_effects=False)
     mqtt_var = Pvariable(config[CONF_MQTT_ID], mqtt_obj,
                          has_side_effects=False)
-    CORE.add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, config)
+    add_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_var, 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)
-    CORE.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_job(setup_binary_sensor_core_, binary_sensor_var, mqtt_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),
-})
-
-
-@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_ON, BINARY_SENSOR_IS_ON_CONDITION_SCHEMA)
-def binary_sensor_is_on_to_code(config, condition_id, arg_type, template_arg):
-    for var in get_variable(config[CONF_ID]):
-        yield None
-    rhs = var.make_binary_sensor_is_on_condition(template_arg)
-    type = BinarySensorCondition.template(arg_type)
-    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),
-})
-
-
-@CONDITION_REGISTRY.register(CONF_BINARY_SENSOR_IS_OFF, BINARY_SENSOR_IS_OFF_CONDITION_SCHEMA)
-def binary_sensor_is_off_to_code(config, condition_id, arg_type, template_arg):
-    for var in get_variable(config[CONF_ID]):
-        yield None
-    rhs = var.make_binary_sensor_is_off_condition(template_arg)
-    type = BinarySensorCondition.template(arg_type)
-    yield Pvariable(condition_id, rhs, type=type)

esphomeyaml/components/binary_sensor/apds9960.py

@@ -1,36 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml.components import binary_sensor, sensor
-from esphomeyaml.components.apds9960 import APDS9960, CONF_APDS9960_ID
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DIRECTION, CONF_NAME
-from esphomeyaml.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)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/custom.py

@@ -1,37 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml.components import binary_sensor
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
-from esphomeyaml.cpp_generator import process_lambda, variable
-from esphomeyaml.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, sens in enumerate(config[CONF_BINARY_SENSORS]):
-        binary_sensor.register_binary_sensor(custom.get_binary_sensor(i), sens)
-
-
-BUILD_FLAGS = '-DUSE_CUSTOM_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return [binary_sensor.core_to_hass_config(data, sens) for sens in config[CONF_BINARY_SENSORS]]

esphomeyaml/components/binary_sensor/esp32_ble_tracker.py

@@ -1,18 +1,15 @@
 import voluptuous as vol
 
+import esphomeyaml.config_validation as cv
 from esphomeyaml.components import binary_sensor
 from esphomeyaml.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.cpp_generator import get_variable
-from esphomeyaml.cpp_types import esphomelib_ns
+from esphomeyaml.helpers import get_variable
 
 DEPENDENCIES = ['esp32_ble_tracker']
-ESP32BLEPresenceDevice = esphomelib_ns.class_('ESP32BLEPresenceDevice', binary_sensor.BinarySensor)
 
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(ESP32BLEPresenceDevice),
     vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
     cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker)
 }))
@@ -24,7 +21,3 @@ def to_code(config):
         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)

esphomeyaml/components/binary_sensor/esp32_touch.py

@@ -4,8 +4,7 @@ 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.cpp_generator import get_variable
-from esphomeyaml.cpp_types import global_ns
+from esphomeyaml.helpers import get_variable, global_ns
 from esphomeyaml.pins import validate_gpio_pin
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
@@ -35,11 +34,7 @@ def validate_touch_pad(value):
     return value
 
 
-ESP32TouchBinarySensor = binary_sensor.binary_sensor_ns.class_('ESP32TouchBinarySensor',
-                                                               binary_sensor.BinarySensor)
-
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(ESP32TouchBinarySensor),
     vol.Required(CONF_PIN): validate_touch_pad,
     vol.Required(CONF_THRESHOLD): cv.uint16_t,
     cv.GenerateID(CONF_ESP32_TOUCH_ID): cv.use_variable_id(ESP32TouchComponent),
@@ -56,7 +51,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)

esphomeyaml/components/binary_sensor/gpio.py

@@ -4,20 +4,14 @@ 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.cpp_generator import variable
-from esphomeyaml.cpp_helpers import gpio_input_pin_expression, setup_component
-from esphomeyaml.cpp_types import Application, Component, App
+from esphomeyaml.helpers import App, gpio_input_pin_expression, variable, Application
 
-MakeGPIOBinarySensor = Application.struct('MakeGPIOBinarySensor')
-GPIOBinarySensorComponent = binary_sensor.binary_sensor_ns.class_('GPIOBinarySensorComponent',
-                                                                  binary_sensor.BinarySensor,
-                                                                  Component)
+MakeGPIOBinarySensor = Application.MakeGPIOBinarySensor
 
 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))
+}))
 
 
 def to_code(config):
@@ -27,11 +21,6 @@ def to_code(config):
     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)
 
 
 BUILD_FLAGS = '-DUSE_GPIO_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/nextion.py

@@ -1,20 +1,16 @@
 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.components import binary_sensor
+from esphomeyaml.components.display.nextion import Nextion
 from esphomeyaml.const import CONF_COMPONENT_ID, CONF_NAME, CONF_PAGE_ID
-from esphomeyaml.cpp_generator import get_variable
+from esphomeyaml.helpers import get_variable
 
 DEPENDENCIES = ['display']
 
 CONF_NEXTION_ID = 'nextion_id'
 
-NextionTouchComponent = display.display_ns.class_('NextionTouchComponent',
-                                                  binary_sensor.BinarySensor)
-
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(NextionTouchComponent),
     vol.Required(CONF_PAGE_ID): cv.uint8_t,
     vol.Required(CONF_COMPONENT_ID): cv.uint8_t,
     cv.GenerateID(CONF_NEXTION_ID): cv.use_variable_id(Nextion)
@@ -22,12 +18,9 @@ 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)

esphomeyaml/components/binary_sensor/pn532.py

@@ -5,7 +5,7 @@ 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.cpp_generator import get_variable, ArrayInitializer
+from esphomeyaml.helpers import ArrayInitializer, get_variable
 
 DEPENDENCIES = ['pn532']
 
@@ -27,23 +27,16 @@ def validate_uid(value):
     return value
 
 
-PN532BinarySensor = binary_sensor.binary_sensor_ns.class_('PN532BinarySensor',
-                                                          binary_sensor.BinarySensor)
-
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(PN532BinarySensor),
     vol.Required(CONF_UID): validate_uid,
     cv.GenerateID(CONF_PN532_ID): cv.use_variable_id(PN532Component)
 }))
 
 
 def to_code(config):
+    hub = None
     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))
     binary_sensor.register_binary_sensor(rhs, config)
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/rdm6300.py

@@ -3,28 +3,21 @@ 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.cpp_generator import get_variable
+from esphomeyaml.helpers import get_variable
 
 DEPENDENCIES = ['rdm6300']
 
 CONF_RDM6300_ID = 'rdm6300_id'
 
-RDM6300BinarySensor = binary_sensor.binary_sensor_ns.class_('RDM6300BinarySensor',
-                                                            binary_sensor.BinarySensor)
-
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(RDM6300BinarySensor),
     vol.Required(CONF_UID): cv.uint32_t,
     cv.GenerateID(CONF_RDM6300_ID): cv.use_variable_id(rdm6300.RDM6300Component)
 }))
 
 
 def to_code(config):
+    hub = None
     for hub in get_variable(config[CONF_RDM6300_ID]):
         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)

esphomeyaml/components/binary_sensor/remote_receiver.py

@@ -11,7 +11,7 @@ from esphomeyaml.const import CONF_ADDRESS, CONF_CHANNEL, CONF_CODE, CONF_COMMAN
     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.cpp_generator import ArrayInitializer, get_variable, Pvariable
+from esphomeyaml.helpers import ArrayInitializer, Pvariable, get_variable
 
 DEPENDENCIES = ['remote_receiver']
 
@@ -22,24 +22,23 @@ REMOTE_KEYS = [CONF_NEC, CONF_LG, CONF_SONY, CONF_PANASONIC, CONF_SAMSUNG, CONF_
 CONF_REMOTE_RECEIVER_ID = 'remote_receiver_id'
 CONF_RECEIVER_ID = 'receiver_id'
 
-RemoteReceiver = remote_ns.class_('RemoteReceiver', binary_sensor.BinarySensor)
-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)
-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)
+RemoteReceiver = remote_ns.RemoteReceiver
+LGReceiver = remote_ns.LGReceiver
+NECReceiver = remote_ns.NECReceiver
+PanasonicReceiver = remote_ns.PanasonicReceiver
+RawReceiver = remote_ns.RawReceiver
+SamsungReceiver = remote_ns.SamsungReceiver
+SonyReceiver = remote_ns.SonyReceiver
+RCSwitchRawReceiver = remote_ns.RCSwitchRawReceiver
+RCSwitchTypeAReceiver = remote_ns.RCSwitchTypeAReceiver
+RCSwitchTypeBReceiver = remote_ns.RCSwitchTypeBReceiver
+RCSwitchTypeCReceiver = remote_ns.RCSwitchTypeCReceiver
+RCSwitchTypeDReceiver = remote_ns.RCSwitchTypeDReceiver
 
 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.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
+        vol.Optional(CONF_NBITS, default=28): vol.All(vol.Coerce(int), cv.one_of(28, 32)),
     }),
     vol.Optional(CONF_NEC): vol.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
@@ -50,7 +49,7 @@ PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend
     }),
     vol.Optional(CONF_SONY): vol.Schema({
         vol.Required(CONF_DATA): cv.hex_uint32_t,
-        vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
+        vol.Optional(CONF_NBITS, default=12): vol.All(vol.Coerce(int), cv.one_of(12, 15, 20)),
     }),
     vol.Optional(CONF_PANASONIC): vol.Schema({
         vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
@@ -73,43 +72,44 @@ def receiver_base(full_config):
     key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
     if key == CONF_LG:
         return LGReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
-    if key == CONF_NEC:
+    elif key == CONF_NEC:
         return NECReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    if key == CONF_PANASONIC:
+    elif key == CONF_PANASONIC:
         return PanasonicReceiver.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
-    if key == CONF_SAMSUNG:
+    elif key == CONF_SAMSUNG:
         return SamsungReceiver.new(name, config[CONF_DATA])
-    if key == CONF_SONY:
+    elif key == CONF_SONY:
         return SonyReceiver.new(name, config[CONF_DATA], config[CONF_NBITS])
-    if key == CONF_RAW:
+    elif key == CONF_RAW:
         data = ArrayInitializer(*config, multiline=False)
         return RawReceiver.new(name, data)
-    if key == CONF_RC_SWITCH_RAW:
+    elif 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]))
-    if key == CONF_RC_SWITCH_TYPE_A:
+    elif 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])
-    if key == CONF_RC_SWITCH_TYPE_B:
+    elif 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])
-    if key == CONF_RC_SWITCH_TYPE_C:
+    elif 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])
-    if key == CONF_RC_SWITCH_TYPE_D:
+    elif 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])
-
-    raise NotImplementedError("Unknown receiver type {}".format(config))
+    else:
+        raise NotImplementedError("Unknown receiver type {}".format(config))
 
 
 def to_code(config):
+    remote = None
     for remote in get_variable(config[CONF_REMOTE_RECEIVER_ID]):
         yield
     rhs = receiver_base(config)
@@ -119,7 +119,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)

esphomeyaml/components/binary_sensor/status.py

@@ -1,31 +1,21 @@
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import binary_sensor
 from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME
-from esphomeyaml.cpp_generator import variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import Application, Component, App
+from esphomeyaml.helpers import App, Application, variable
 
+DEPENDENCIES = ['mqtt']
 
-MakeStatusBinarySensor = Application.struct('MakeStatusBinarySensor')
-StatusBinarySensor = binary_sensor.binary_sensor_ns.class_('StatusBinarySensor',
-                                                           binary_sensor.BinarySensor,
-                                                           Component)
+MakeStatusBinarySensor = Application.MakeStatusBinarySensor
 
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeStatusBinarySensor),
-    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 = variable(config[CONF_MAKE_ID], rhs)
     binary_sensor.setup_binary_sensor(status.Pstatus, status.Pmqtt, config)
-    setup_component(status.Pstatus, config)
 
 
 BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/binary_sensor/template.py

@@ -1,29 +1,22 @@
 import voluptuous as vol
 
-from esphomeyaml.components import binary_sensor
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import binary_sensor
 from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME
-from esphomeyaml.cpp_generator import variable, process_lambda, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import Application, Component, App, optional, bool_
+from esphomeyaml.helpers import App, Application, process_lambda, variable, optional, bool_, add
 
-MakeTemplateBinarySensor = Application.struct('MakeTemplateBinarySensor')
-TemplateBinarySensor = binary_sensor.binary_sensor_ns.class_('TemplateBinarySensor',
-                                                             binary_sensor.BinarySensor,
-                                                             Component)
+MakeTemplateBinarySensor = Application.MakeTemplateBinarySensor
 
 PLATFORM_SCHEMA = cv.nameable(binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(TemplateBinarySensor),
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateBinarySensor),
     vol.Required(CONF_LAMBDA): cv.lambda_,
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
     rhs = App.make_template_binary_sensor(config[CONF_NAME])
     make = variable(config[CONF_MAKE_ID], rhs)
     binary_sensor.setup_binary_sensor(make.Ptemplate_, make.Pmqtt, config)
-    setup_component(make.Ptemplate_, config)
 
     template_ = None
     for template_ in process_lambda(config[CONF_LAMBDA], [],
@@ -33,7 +26,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_TEMPLATE_BINARY_SENSOR'
-
-
-def to_hass_config(data, config):
-    return binary_sensor.core_to_hass_config(data, config)

esphomeyaml/components/cover/__init__.py

@@ -1,30 +1,24 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
-from esphomeyaml.components import mqtt
-from esphomeyaml.components.mqtt import setup_mqtt_component
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID
-from esphomeyaml.cpp_generator import Pvariable, add, get_variable
-from esphomeyaml.cpp_types import Action, Nameable, esphomelib_ns
+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
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
 cover_ns = esphomelib_ns.namespace('cover')
-
-Cover = cover_ns.class_('Cover', Nameable)
-MQTTCoverComponent = cover_ns.class_('MQTTCoverComponent', mqtt.MQTTComponent)
-
-CoverState = cover_ns.class_('CoverState')
+Cover = cover_ns.Cover
+MQTTCoverComponent = cover_ns.MQTTCoverComponent
+CoverState = cover_ns.CoverState
 COVER_OPEN = cover_ns.COVER_OPEN
 COVER_CLOSED = cover_ns.COVER_CLOSED
-
-# Actions
-OpenAction = cover_ns.class_('OpenAction', Action)
-CloseAction = cover_ns.class_('CloseAction', Action)
-StopAction = cover_ns.class_('StopAction', Action)
+OpenAction = cover_ns.OpenAction
+CloseAction = cover_ns.CloseAction
+StopAction = cover_ns.StopAction
 
 COVER_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(Cover),
@@ -50,12 +44,13 @@ BUILD_FLAGS = '-DUSE_COVER'
 
 CONF_COVER_OPEN = 'cover.open'
 COVER_OPEN_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @ACTION_REGISTRY.register(CONF_COVER_OPEN, COVER_OPEN_ACTION_SCHEMA)
-def cover_open_to_code(config, action_id, arg_type, template_arg):
+def cover_open_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_open_action(template_arg)
@@ -65,12 +60,13 @@ def cover_open_to_code(config, action_id, arg_type, template_arg):
 
 CONF_COVER_CLOSE = 'cover.close'
 COVER_CLOSE_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @ACTION_REGISTRY.register(CONF_COVER_CLOSE, COVER_CLOSE_ACTION_SCHEMA)
-def cover_close_to_code(config, action_id, arg_type, template_arg):
+def cover_close_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_close_action(template_arg)
@@ -80,21 +76,15 @@ def cover_close_to_code(config, action_id, arg_type, template_arg):
 
 CONF_COVER_STOP = 'cover.stop'
 COVER_STOP_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(Cover),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @ACTION_REGISTRY.register(CONF_COVER_STOP, COVER_STOP_ACTION_SCHEMA)
-def cover_stop_to_code(config, action_id, arg_type, template_arg):
+def cover_stop_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_stop_action(template_arg)
     type = StopAction.template(arg_type)
     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

esphomeyaml/components/cover/template.py

@@ -5,22 +5,18 @@ from esphomeyaml import automation
 from esphomeyaml.components import cover
 from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \
     CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC
-from esphomeyaml.cpp_generator import variable, process_lambda, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import Application, App, optional, NoArg
+from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable, optional
 
-MakeTemplateCover = Application.struct('MakeTemplateCover')
-TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
+MakeTemplateCover = Application.MakeTemplateCover
 
 PLATFORM_SCHEMA = cv.nameable(cover.COVER_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeTemplateCover),
-    cv.GenerateID(): cv.declare_variable_id(TemplateCover),
     vol.Optional(CONF_LAMBDA): cv.lambda_,
     vol.Optional(CONF_OPTIMISTIC): 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), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
+}), cv.has_at_least_one_key(CONF_LAMBDA, CONF_OPTIMISTIC))
 
 
 def to_code(config):
@@ -28,9 +24,9 @@ def to_code(config):
     make = variable(config[CONF_MAKE_ID], rhs)
 
     cover.setup_cover(make.Ptemplate_, make.Pmqtt, config)
-    setup_component(make.Ptemplate_, config)
 
     if CONF_LAMBDA in config:
+        template_ = None
         for template_ in process_lambda(config[CONF_LAMBDA], [],
                                         return_type=optional.template(cover.CoverState)):
             yield
@@ -49,12 +45,3 @@ def to_code(config):
 
 
 BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'
-
-
-def to_hass_config(data, config):
-    ret = cover.core_to_hass_config(data, config)
-    if ret is None:
-        return None
-    if CONF_OPTIMISTIC in config:
-        ret['optimistic'] = config[CONF_OPTIMISTIC]
-    return ret

esphomeyaml/components/custom_component.py

@@ -1,32 +0,0 @@
-import voluptuous as vol
-
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_COMPONENTS
-from esphomeyaml.cpp_generator import process_lambda, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import Component, ComponentPtr, esphomelib_ns, std_vector
-
-CustomComponentConstructor = esphomelib_ns.class_('CustomComponentConstructor')
-MULTI_CONF = True
-
-CONFIG_SCHEMA = vol.Schema({
-    cv.GenerateID(): cv.declare_variable_id(CustomComponentConstructor),
-    vol.Required(CONF_LAMBDA): cv.lambda_,
-    vol.Optional(CONF_COMPONENTS): cv.ensure_list(vol.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 in enumerate(config.get(CONF_COMPONENTS, [])):
-        setup_component(custom.get_component(i), comp)
-
-
-BUILD_FLAGS = '-DUSE_CUSTOM_COMPONENT'

esphomeyaml/components/dallas.py

@@ -1,27 +1,24 @@
 import voluptuous as vol
 
+import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import sensor
-import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
-from esphomeyaml.cpp_generator import Pvariable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, PollingComponent
+from esphomeyaml.helpers import App, Pvariable
 
-DallasComponent = sensor.sensor_ns.class_('DallasComponent', PollingComponent)
-MULTI_CONF = True
+DallasComponent = sensor.sensor_ns.DallasComponent
 
-CONFIG_SCHEMA = vol.Schema({
+CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(DallasComponent),
-    vol.Required(CONF_PIN): pins.input_pullup_pin,
+    vol.Required(CONF_PIN): pins.input_output_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)
+    for conf in config:
+        rhs = App.make_dallas_component(conf[CONF_PIN], conf.get(CONF_UPDATE_INTERVAL))
+        Pvariable(conf[CONF_ID], rhs)
 
 
 BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'

esphomeyaml/components/debug.py

@@ -1,7 +1,6 @@
 import voluptuous as vol
 
-from esphomeyaml.cpp_generator import add
-from esphomeyaml.cpp_types import App
+from esphomeyaml.helpers import App, add
 
 DEPENDENCIES = ['logger']
 

esphomeyaml/components/deep_sleep.py

@@ -1,12 +1,11 @@
 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_MODE, CONF_NUMBER, CONF_PINS, CONF_RUN_CYCLES, \
-    CONF_RUN_DURATION, CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
-from esphomeyaml.cpp_generator import Pvariable, StructInitializer, add, get_variable
-from esphomeyaml.cpp_helpers import gpio_input_pin_expression, setup_component
-from esphomeyaml.cpp_types import Action, App, Component, esphomelib_ns, global_ns
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
+    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_input_pin_expression, esphomelib_ns, \
+    TemplateArguments, get_variable
 
 
 def validate_pin_number(value):
@@ -17,41 +16,28 @@ 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 = esphomelib_ns.DeepSleepComponent
+EnterDeepSleepAction = esphomelib_ns.EnterDeepSleepAction
+PreventDeepSleepAction = esphomelib_ns.PreventDeepSleepAction
 
-WakeupPinMode = esphomelib_ns.enum('WakeupPinMode')
 WAKEUP_PIN_MODES = {
-    'IGNORE': WakeupPinMode.WAKEUP_PIN_MODE_IGNORE,
-    'KEEP_AWAKE': WakeupPinMode.WAKEUP_PIN_MODE_KEEP_AWAKE,
-    'INVERT_WAKEUP': WakeupPinMode.WAKEUP_PIN_MODE_INVERT_WAKEUP,
-}
-
-esp_sleep_ext1_wakeup_mode_t = global_ns.enum('esp_sleep_ext1_wakeup_mode_t')
-Ext1Wakeup = esphomelib_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,
+    'IGNORE': esphomelib_ns.WAKEUP_PIN_MODE_IGNORE,
+    'KEEP_AWAKE': esphomelib_ns.WAKEUP_PIN_MODE_KEEP_AWAKE,
+    'INVERT_WAKEUP': esphomelib_ns.WAKEUP_PIN_MODE_INVERT_WAKEUP,
 }
 
 CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
-CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
 
 CONFIG_SCHEMA = vol.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,
-                                                cv.one_of(*WAKEUP_PIN_MODES), upper=True),
-    vol.Optional(CONF_ESP32_EXT1_WAKEUP): vol.All(cv.only_on_esp32, vol.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_WAKEUP_PIN_MODE): vol.All(cv.only_on_esp32, vol.Upper,
+                                                cv.one_of(*WAKEUP_PIN_MODES)),
     vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
     vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
@@ -60,6 +46,7 @@ def to_code(config):
     if CONF_SLEEP_DURATION in config:
         add(deep_sleep.set_sleep_duration(config[CONF_SLEEP_DURATION]))
     if CONF_WAKEUP_PIN in config:
+        pin = None
         for pin in gpio_input_pin_expression(config[CONF_WAKEUP_PIN]):
             yield
         add(deep_sleep.set_wakeup_pin(pin))
@@ -70,23 +57,10 @@ def to_code(config):
     if CONF_RUN_DURATION in config:
         add(deep_sleep.set_run_duration(config[CONF_RUN_DURATION]))
 
-    if CONF_ESP32_EXT1_WAKEUP in config:
-        conf = config[CONF_ESP32_EXT1_WAKEUP]
-        mask = 0
-        for pin in conf[CONF_PINS]:
-            mask |= 1 << pin[CONF_NUMBER]
-        struct = StructInitializer(
-            Ext1Wakeup,
-            ('mask', mask),
-            ('wakeup_mode', EXT1_WAKEUP_MODES[conf[CONF_MODE]])
-        )
-        add(deep_sleep.set_ext1_wakeup(struct))
-
-    setup_component(deep_sleep, config)
-
 
 BUILD_FLAGS = '-DUSE_DEEP_SLEEP'
 
+
 CONF_DEEP_SLEEP_ENTER = 'deep_sleep.enter'
 DEEP_SLEEP_ENTER_ACTION_SCHEMA = maybe_simple_id({
     vol.Required(CONF_ID): cv.use_variable_id(DeepSleepComponent),
@@ -94,7 +68,8 @@ 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):
+def deep_sleep_enter_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_enter_deep_sleep_action(template_arg)
@@ -109,7 +84,8 @@ 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):
+def deep_sleep_prevent_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_prevent_deep_sleep_action(template_arg)

esphomeyaml/components/display/__init__.py

@@ -3,16 +3,14 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_LAMBDA, CONF_ROTATION, CONF_UPDATE_INTERVAL
-from esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import add
-from esphomeyaml.cpp_types import esphomelib_ns
+from esphomeyaml.helpers import add, add_job, esphomelib_ns
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
 display_ns = esphomelib_ns.namespace('display')
-DisplayBuffer = display_ns.class_('DisplayBuffer')
+DisplayBuffer = display_ns.DisplayBuffer
 DisplayBufferRef = DisplayBuffer.operator('ref')
 
 DISPLAY_ROTATIONS = {
@@ -52,7 +50,7 @@ def setup_display_core_(display_var, config):
 
 
 def setup_display(display_var, config):
-    CORE.add_job(setup_display_core_, display_var, config)
+    add_job(setup_display_core_, display_var, config)
 
 
 BUILD_FLAGS = '-DUSE_DISPLAY'

esphomeyaml/components/display/lcd_gpio.py

@@ -1,17 +1,15 @@
 import voluptuous as vol
 
+import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import display
-import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_DATA_PINS, CONF_DIMENSIONS, CONF_ENABLE_PIN, CONF_ID, \
     CONF_LAMBDA, CONF_RS_PIN, CONF_RW_PIN
-from esphomeyaml.cpp_generator import Pvariable, add, process_lambda
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression, setup_component
-from esphomeyaml.cpp_types import App, PollingComponent, void
+from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression, process_lambda
 
-LCDDisplay = display.display_ns.class_('LCDDisplay', PollingComponent)
+GPIOLCDDisplay = display.display_ns.GPIOLCDDisplay
+LCDDisplay = display.display_ns.LCDDisplay
 LCDDisplayRef = LCDDisplay.operator('ref')
-GPIOLCDDisplay = display.display_ns.class_('GPIOLCDDisplay', LCDDisplay)
 
 
 def validate_lcd_dimensions(value):
@@ -38,7 +36,7 @@ PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
     vol.Required(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
     vol.Required(CONF_RS_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_RW_PIN): pins.gpio_output_pin_schema,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
@@ -64,13 +62,11 @@ 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')],
-                                      return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')]):
             yield
         add(lcd.set_writer(lambda_))
 
     display.setup_display(lcd, config)
-    setup_component(lcd, config)
 
 
 BUILD_FLAGS = '-DUSE_LCD_DISPLAY'

esphomeyaml/components/display/lcd_pcf8574.py

@@ -1,23 +1,20 @@
 import voluptuous as vol
 
-from esphomeyaml.components import display, i2c
-from esphomeyaml.components.display.lcd_gpio import LCDDisplay, LCDDisplayRef, \
-    validate_lcd_dimensions
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import display
+from esphomeyaml.components.display.lcd_gpio import LCDDisplayRef, validate_lcd_dimensions
 from esphomeyaml.const import CONF_ADDRESS, CONF_DIMENSIONS, CONF_ID, CONF_LAMBDA
-from esphomeyaml.cpp_generator import Pvariable, add, process_lambda
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, void
+from esphomeyaml.helpers import App, Pvariable, add, process_lambda
 
 DEPENDENCIES = ['i2c']
 
-PCF8574LCDDisplay = display.display_ns.class_('PCF8574LCDDisplay', LCDDisplay, i2c.I2CDevice)
+PCF8574LCDDisplay = display.display_ns.PCF8574LCDDisplay
 
 PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(PCF8574LCDDisplay),
     vol.Required(CONF_DIMENSIONS): validate_lcd_dimensions,
     vol.Optional(CONF_ADDRESS): cv.i2c_address,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
@@ -28,13 +25,11 @@ 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')],
-                                      return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(LCDDisplayRef, 'it')]):
             yield
         add(lcd.set_writer(lambda_))
 
     display.setup_display(lcd, config)
-    setup_component(lcd, config)
 
 
 BUILD_FLAGS = ['-DUSE_LCD_DISPLAY', '-DUSE_LCD_DISPLAY_PCF8574']

esphomeyaml/components/display/max7219.py

@@ -1,18 +1,17 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components import display, spi
-from esphomeyaml.components.spi import SPIComponent
 import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import display
+from esphomeyaml.components.spi import SPIComponent
 from esphomeyaml.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
     CONF_SPI_ID
-from esphomeyaml.cpp_generator import Pvariable, add, get_variable, process_lambda
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression, setup_component
-from esphomeyaml.cpp_types import App, PollingComponent, void
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_output_pin_expression, \
+    process_lambda
 
 DEPENDENCIES = ['spi']
 
-MAX7219Component = display.display_ns.class_('MAX7219Component', PollingComponent, spi.SPIDevice)
+MAX7219Component = display.display_ns.MAX7219Component
 MAX7219ComponentRef = MAX7219Component.operator('ref')
 
 PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
@@ -22,15 +21,15 @@ PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
 
     vol.Optional(CONF_NUM_CHIPS): vol.All(cv.uint8_t, vol.Range(min=1)),
     vol.Optional(CONF_INTENSITY): vol.All(cv.uint8_t, vol.Range(min=0, max=15)),
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
-    for spi_ in get_variable(config[CONF_SPI_ID]):
+    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_max7219(spi_, cs)
+    rhs = App.make_max7219(spi, cs)
     max7219 = Pvariable(config[CONF_ID], rhs)
 
     if CONF_NUM_CHIPS in config:
@@ -39,13 +38,11 @@ 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')],
-                                      return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(MAX7219ComponentRef, 'it')]):
             yield
         add(max7219.set_writer(lambda_))
 
     display.setup_display(max7219, config)
-    setup_component(max7219, config)
 
 
 BUILD_FLAGS = '-DUSE_MAX7219'

esphomeyaml/components/display/nextion.py

@@ -1,36 +1,32 @@
-from esphomeyaml.components import display, uart
-from esphomeyaml.components.uart import UARTComponent
 import esphomeyaml.config_validation as cv
+from esphomeyaml.components import display
+from esphomeyaml.components.uart import UARTComponent
 from esphomeyaml.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
-from esphomeyaml.cpp_generator import Pvariable, add, get_variable, process_lambda
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, PollingComponent, void
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, process_lambda
 
 DEPENDENCIES = ['uart']
 
-Nextion = display.display_ns.class_('Nextion', PollingComponent, uart.UARTDevice)
+Nextion = display.display_ns.Nextion
 NextionRef = Nextion.operator('ref')
 
 PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(Nextion),
     cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
-    for uart_ in get_variable(config[CONF_UART_ID]):
+    for uart in get_variable(config[CONF_UART_ID]):
         yield
-    rhs = App.make_nextion(uart_)
+    rhs = App.make_nextion(uart)
     nextion = Pvariable(config[CONF_ID], rhs)
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(NextionRef, 'it')],
-                                      return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(NextionRef, 'it')]):
             yield
         add(nextion.set_writer(lambda_))
 
     display.setup_display(nextion, config)
-    setup_component(nextion, config)
 
 
 BUILD_FLAGS = '-DUSE_NEXTION'

esphomeyaml/components/display/ssd1306_i2c.py

@@ -1,18 +1,17 @@
 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
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ADDRESS, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, CONF_MODEL, \
-    CONF_RESET_PIN
-from esphomeyaml.cpp_generator import Pvariable, add, process_lambda
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression, setup_component
-from esphomeyaml.cpp_types import App, void
+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
 
 DEPENDENCIES = ['i2c']
 
-I2CSSD1306 = display.display_ns.class_('I2CSSD1306', ssd1306_spi.SSD1306)
+I2CSSD1306 = display.display_ns.I2CSSD1306
 
 PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(I2CSSD1306),
@@ -20,7 +19,7 @@ PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     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)
+})
 
 
 def to_code(config):
@@ -37,12 +36,11 @@ 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')], return_type=void):
+                                      [(display.DisplayBufferRef, 'it')]):
             yield
         add(ssd.set_writer(lambda_))
 
     display.setup_display(ssd, config)
-    setup_component(ssd, config)
 
 
 BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/ssd1306_spi.py

@@ -1,33 +1,31 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
-from esphomeyaml.components import display, spi
-from esphomeyaml.components.spi import SPIComponent
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_CS_PIN, CONF_DC_PIN, CONF_EXTERNAL_VCC, CONF_ID, CONF_LAMBDA, \
-    CONF_MODEL, CONF_RESET_PIN, CONF_SPI_ID
-from esphomeyaml.cpp_generator import Pvariable, add, get_variable, process_lambda
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression, setup_component
-from esphomeyaml.cpp_types import App, PollingComponent, void
+from esphomeyaml import pins
+from esphomeyaml.components import display
+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
 
 DEPENDENCIES = ['spi']
 
-SSD1306 = display.display_ns.class_('SSD1306', PollingComponent, display.DisplayBuffer)
-SPISSD1306 = display.display_ns.class_('SPISSD1306', SSD1306, spi.SPIDevice)
-SSD1306Model = display.display_ns.enum('SSD1306Model')
+SPISSD1306 = display.display_ns.SPISSD1306
 
 MODELS = {
-    'SSD1306_128X32': SSD1306Model.SSD1306_MODEL_128_32,
-    'SSD1306_128X64': SSD1306Model.SSD1306_MODEL_128_64,
-    'SSD1306_96X16': SSD1306Model.SSD1306_MODEL_96_16,
-    'SSD1306_64X48': SSD1306Model.SSD1306_MODEL_64_48,
-    'SH1106_128X32': SSD1306Model.SH1106_MODEL_128_32,
-    'SH1106_128X64': SSD1306Model.SH1106_MODEL_128_64,
-    'SH1106_96X16': SSD1306Model.SH1106_MODEL_96_16,
-    'SH1106_64X48': SSD1306Model.SH1106_MODEL_64_48,
+    'SSD1306_128X32': display.display_ns.SSD1306_MODEL_128_32,
+    'SSD1306_128X64': display.display_ns.SSD1306_MODEL_128_64,
+    'SSD1306_96X16': display.display_ns.SSD1306_MODEL_96_16,
+    'SSD1306_64X48': display.display_ns.SSD1306_MODEL_64_48,
+    'SH1106_128X32': display.display_ns.SH1106_MODEL_128_32,
+    'SH1106_128X64': display.display_ns.SH1106_MODEL_128_64,
+    'SH1106_96X16': display.display_ns.SH1106_MODEL_96_16,
+    'SH1106_64X48': display.display_ns.SH1106_MODEL_64_48,
 }
 
-SSD1306_MODEL = cv.one_of(*MODELS, upper=True, space="_")
+SSD1306_MODEL = vol.All(vol.Upper, vol.Replace(' ', '_'), cv.one_of(*MODELS))
 
 PLATFORM_SCHEMA = display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
     cv.GenerateID(): cv.declare_variable_id(SPISSD1306),
@@ -37,18 +35,18 @@ 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)
+})
 
 
 def to_code(config):
-    for spi_ in get_variable(config[CONF_SPI_ID]):
+    for spi in get_variable(config[CONF_SPI_ID]):
         yield
     for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
         yield
     for dc in gpio_output_pin_expression(config[CONF_DC_PIN]):
         yield
 
-    rhs = App.make_spi_ssd1306(spi_, cs, dc)
+    rhs = App.make_spi_ssd1306(spi, cs, dc)
     ssd = Pvariable(config[CONF_ID], rhs)
     add(ssd.set_model(MODELS[config[CONF_MODEL]]))
 
@@ -60,12 +58,11 @@ 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')], return_type=void):
+                                      [(display.DisplayBufferRef, 'it')]):
             yield
         add(ssd.set_writer(lambda_))
 
     display.setup_display(ssd, config)
-    setup_component(ssd, config)
 
 
 BUILD_FLAGS = '-DUSE_SSD1306'

esphomeyaml/components/display/waveshare_epaper.py

@@ -2,32 +2,25 @@ import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
-from esphomeyaml.components import display, spi
+from esphomeyaml.components import display
 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.cpp_generator import get_variable, Pvariable, process_lambda, add
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression, gpio_input_pin_expression, \
-    setup_component
-from esphomeyaml.cpp_types import PollingComponent, App, void
+from esphomeyaml.helpers import App, Pvariable, add, get_variable, gpio_input_pin_expression, \
+    gpio_output_pin_expression, process_lambda
 
 DEPENDENCIES = ['spi']
 
 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')
+WaveshareEPaper = display.display_ns.WaveshareEPaper
 
 MODELS = {
-    '1.54in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_1_54_IN),
-    '2.13in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_13_IN),
-    '2.90in': ('a', WaveshareEPaperTypeAModel.WAVESHARE_EPAPER_2_9_IN),
-    '2.70in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_2_7_IN),
-    '4.20in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_4_2_IN),
-    '7.50in': ('b', WaveshareEPaperTypeBModel.WAVESHARE_EPAPER_7_5_IN),
+    '1.54in': ('a', display.display_ns.WAVESHARE_EPAPER_1_54_IN),
+    '2.13in': ('a', display.display_ns.WAVESHARE_EPAPER_2_13_IN),
+    '2.90in': ('a', display.display_ns.WAVESHARE_EPAPER_2_9_IN),
+    '2.70in': ('b', display.display_ns.WAVESHARE_EPAPER_2_7_IN),
+    '4.20in': ('b', display.display_ns.WAVESHARE_EPAPER_4_2_IN),
+    '7.50in': ('b', display.display_ns.WAVESHARE_EPAPER_7_5_IN),
 }
 
 
@@ -41,19 +34,19 @@ def validate_full_update_every_only_type_a(value):
 
 
 PLATFORM_SCHEMA = vol.All(display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(WaveshareEPaper),
+    cv.GenerateID(): cv.declare_variable_id(None),
     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): cv.one_of(*MODELS, lower=True),
+    vol.Required(CONF_MODEL): vol.All(vol.Lower, cv.one_of(*MODELS)),
     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)
+}), validate_full_update_every_only_type_a)
 
 
 def to_code(config):
-    for spi_ in get_variable(config[CONF_SPI_ID]):
+    for spi in get_variable(config[CONF_SPI_ID]):
         yield
     for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
         yield
@@ -62,17 +55,16 @@ def to_code(config):
 
     model_type, model = MODELS[config[CONF_MODEL]]
     if model_type == 'a':
-        rhs = App.make_waveshare_epaper_type_a(spi_, cs, dc, model)
+        rhs = App.make_waveshare_epaper_type_a(spi, cs, dc, model)
         epaper = Pvariable(config[CONF_ID], rhs, type=WaveshareEPaperTypeA)
     elif model_type == 'b':
-        rhs = App.make_waveshare_epaper_type_b(spi_, cs, dc, model)
+        rhs = App.make_waveshare_epaper_type_b(spi, cs, dc, model)
         epaper = Pvariable(config[CONF_ID], rhs, type=WaveshareEPaper)
     else:
         raise NotImplementedError()
 
     if CONF_LAMBDA in config:
-        for lambda_ in process_lambda(config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')],
-                                      return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(display.DisplayBufferRef, 'it')]):
             yield
         add(epaper.set_writer(lambda_))
     if CONF_RESET_PIN in config:
@@ -87,7 +79,6 @@ def to_code(config):
         add(epaper.set_full_update_every(config[CONF_FULL_UPDATE_EVERY]))
 
     display.setup_display(epaper, config)
-    setup_component(epaper, config)
 
 
 BUILD_FLAGS = '-DUSE_WAVESHARE_EPAPER'

esphomeyaml/components/esp32_ble.py

@@ -0,0 +1,5 @@
+from esphomeyaml import config_validation as cv
+
+CONFIG_SCHEMA = cv.invalid("The 'esp32_ble' component has been renamed to the 'esp32_ble_tracker' "
+                           "component in order to avoid confusion with the new 'esp32_ble_beacon' "
+                           "component.")

esphomeyaml/components/esp32_ble_beacon.py

@@ -1,31 +1,29 @@
 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.cpp_generator import ArrayInitializer, Pvariable, RawExpression, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component, esphomelib_ns
+from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32, CONF_UUID, CONF_TYPE
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, RawExpression, ArrayInitializer
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
-ESP32BLEBeacon = esphomelib_ns.class_('ESP32BLEBeacon', Component)
+ESP32BLEBeacon = esphomelib_ns.ESP32BLEBeacon
 
 CONF_MAJOR = 'major'
 CONF_MINOR = 'minor'
 
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon),
-    vol.Required(CONF_TYPE): cv.one_of('IBEACON', upper=True),
+    vol.Required(CONF_TYPE): vol.All(vol.Upper, cv.one_of('IBEACON')),
     vol.Required(CONF_UUID): cv.uuid,
     vol.Optional(CONF_MAJOR): cv.uint16_t,
     vol.Optional(CONF_MINOR): cv.uint16_t,
     vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
-}).extend(cv.COMPONENT_SCHEMA.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)]
+    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))
     ble = Pvariable(config[CONF_ID], rhs)
     if CONF_MAJOR in config:
@@ -33,7 +31,5 @@ def to_code(config):
     if CONF_MINOR in config:
         add(ble.set_minor(config[CONF_MINOR]))
 
-    setup_component(ble, config)
-
 
 BUILD_FLAGS = '-DUSE_ESP32_BLE_BEACON'

esphomeyaml/components/esp32_ble_tracker.py

@@ -1,27 +1,19 @@
 import voluptuous as vol
 
 from esphomeyaml import config_validation as cv
-from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
 from esphomeyaml.core import HexInt
-from esphomeyaml.cpp_generator import ArrayInitializer, Pvariable, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component, esphomelib_ns
+from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, ArrayInitializer
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
 CONF_ESP32_BLE_ID = 'esp32_ble_id'
-ESP32BLETracker = esphomelib_ns.class_('ESP32BLETracker', Component)
-XiaomiSensor = esphomelib_ns.class_('XiaomiSensor', sensor.Sensor)
-XiaomiDevice = esphomelib_ns.class_('XiaomiDevice')
-XIAOMI_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_variable_id(XiaomiSensor)
-})
+ESP32BLETracker = esphomelib_ns.ESP32BLETracker
 
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(ESP32BLETracker),
     vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds,
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def make_address_array(address):
@@ -35,7 +27,5 @@ def to_code(config):
     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'

esphomeyaml/components/esp32_touch.py

@@ -2,13 +2,11 @@ import voluptuous as vol
 
 from esphomeyaml import config_validation as cv
 from esphomeyaml.components import binary_sensor
-from esphomeyaml.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 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.cpp_generator import Pvariable, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component, global_ns
+from esphomeyaml.helpers import App, Pvariable, add, global_ns
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
 
@@ -21,7 +19,6 @@ def validate_voltage(values):
         if not value.endswith('V'):
             value += 'V'
         return cv.one_of(*values)(value)
-
     return validator
 
 
@@ -44,7 +41,7 @@ VOLTAGE_ATTENUATION = {
     '0V': global_ns.TOUCH_HVOLT_ATTEN_0V,
 }
 
-ESP32TouchComponent = binary_sensor.binary_sensor_ns.class_('ESP32TouchComponent', Component)
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.ESP32TouchComponent
 
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(ESP32TouchComponent),
@@ -57,7 +54,7 @@ CONFIG_SCHEMA = vol.Schema({
     vol.Optional(CONF_LOW_VOLTAGE_REFERENCE): validate_voltage(LOW_VOLTAGE_REFERENCE),
     vol.Optional(CONF_HIGH_VOLTAGE_REFERENCE): validate_voltage(HIGH_VOLTAGE_REFERENCE),
     vol.Optional(CONF_VOLTAGE_ATTENUATION): validate_voltage(VOLTAGE_ATTENUATION),
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
@@ -83,7 +80,5 @@ def to_code(config):
         value = VOLTAGE_ATTENUATION[config[CONF_VOLTAGE_ATTENUATION]]
         add(touch.set_voltage_attenuation(value))
 
-    setup_component(touch, config)
-
 
 BUILD_FLAGS = '-DUSE_ESP32_TOUCH_BINARY_SENSOR'

esphomeyaml/components/ethernet.py

@@ -1,73 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml import pins
-from esphomeyaml.components import wifi
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_DOMAIN, CONF_HOSTNAME, CONF_ID, CONF_MANUAL_IP, CONF_TYPE, \
-    ESP_PLATFORM_ESP32
-from esphomeyaml.cpp_generator import Pvariable, add
-from esphomeyaml.cpp_helpers import gpio_output_pin_expression
-from esphomeyaml.cpp_types import App, Component, esphomelib_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 = esphomelib_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 = esphomelib_ns.class_('EthernetComponent', Component)
-
-CONFIG_SCHEMA = vol.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_HOSTNAME): cv.hostname,
-    vol.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
-})
-
-
-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]]))
-
-    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_HOSTNAME in config:
-        add(eth.set_hostname(config[CONF_HOSTNAME]))
-
-    if CONF_MANUAL_IP in config:
-        add(eth.set_manual_ip(wifi.manual_ip(config[CONF_MANUAL_IP])))
-
-
-REQUIRED_BUILD_FLAGS = '-DUSE_ETHERNET'

esphomeyaml/components/fan/__init__.py

@@ -1,46 +1,40 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
-from esphomeyaml.components import mqtt
-from esphomeyaml.components.mqtt import setup_mqtt_component
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_INTERNAL, CONF_MQTT_ID, CONF_NAME, CONF_OSCILLATING, \
-    CONF_OSCILLATION_COMMAND_TOPIC, CONF_OSCILLATION_OUTPUT, CONF_OSCILLATION_STATE_TOPIC, \
-    CONF_SPEED, CONF_SPEED_COMMAND_TOPIC, CONF_SPEED_STATE_TOPIC
-from esphomeyaml.cpp_generator import add, Pvariable, get_variable, templatable
-from esphomeyaml.cpp_types import Application, Component, Nameable, esphomelib_ns, Action, bool_
+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
+from esphomeyaml.helpers import Application, Pvariable, add, esphomelib_ns, setup_mqtt_component, \
+    TemplateArguments, get_variable, templatable, bool_
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
 fan_ns = esphomelib_ns.namespace('fan')
-FanState = fan_ns.class_('FanState', Nameable, Component)
-MQTTFanComponent = fan_ns.class_('MQTTFanComponent', mqtt.MQTTComponent)
-MakeFan = Application.struct('MakeFan')
-
-# Actions
-TurnOnAction = fan_ns.class_('TurnOnAction', Action)
-TurnOffAction = fan_ns.class_('TurnOffAction', Action)
-ToggleAction = fan_ns.class_('ToggleAction', Action)
-
-FanSpeed = fan_ns.enum('FanSpeed')
-FAN_SPEED_OFF = FanSpeed.FAN_SPEED_OFF
-FAN_SPEED_LOW = FanSpeed.FAN_SPEED_LOW
-FAN_SPEED_MEDIUM = FanSpeed.FAN_SPEED_MEDIUM
-FAN_SPEED_HIGH = FanSpeed.FAN_SPEED_HIGH
+FanState = fan_ns.FanState
+MQTTFanComponent = fan_ns.MQTTFanComponent
+MakeFan = Application.MakeFan
+TurnOnAction = fan_ns.TurnOnAction
+TurnOffAction = fan_ns.TurnOffAction
+ToggleAction = fan_ns.ToggleAction
+FanSpeed = fan_ns.FanSpeed
+FAN_SPEED_OFF = fan_ns.FAN_SPEED_OFF
+FAN_SPEED_LOW = fan_ns.FAN_SPEED_LOW
+FAN_SPEED_MEDIUM = fan_ns.FAN_SPEED_MEDIUM
+FAN_SPEED_HIGH = fan_ns.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): vol.All(cv.requires_component('mqtt'),
-                                                        cv.publish_topic),
-    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): vol.All(cv.requires_component('mqtt'),
-                                                          cv.subscribe_topic),
+    vol.Optional(CONF_OSCILLATION_STATE_TOPIC): cv.publish_topic,
+    vol.Optional(CONF_OSCILLATION_COMMAND_TOPIC): cv.subscribe_topic,
 })
 
 FAN_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(FAN_SCHEMA.schema)
 
+
 FAN_SPEEDS = {
     'OFF': FAN_SPEED_OFF,
     'LOW': FAN_SPEED_LOW,
@@ -49,6 +43,10 @@ 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):
     if CONF_INTERNAL in config:
         add(fan_var.set_internal(config[CONF_INTERNAL]))
@@ -72,14 +70,16 @@ def setup_fan(fan_obj, mqtt_obj, 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),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @ACTION_REGISTRY.register(CONF_FAN_TOGGLE, FAN_TOGGLE_ACTION_SCHEMA)
-def fan_toggle_to_code(config, action_id, arg_type, template_arg):
+def fan_toggle_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_toggle_action(template_arg)
@@ -89,12 +89,13 @@ def fan_toggle_to_code(config, action_id, arg_type, template_arg):
 
 CONF_FAN_TURN_OFF = 'fan.turn_off'
 FAN_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(FanState),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
 })
 
 
 @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):
+def fan_turn_off_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_off_action(template_arg)
@@ -104,14 +105,15 @@ def fan_turn_off_to_code(config, action_id, arg_type, template_arg):
 
 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.Required(CONF_ID): cv.use_variable_id(None),
     vol.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean),
-    vol.Optional(CONF_SPEED): cv.templatable(cv.one_of(*FAN_SPEEDS, upper=True)),
+    vol.Optional(CONF_SPEED): cv.templatable(validate_fan_speed),
 })
 
 
 @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):
+def fan_turn_on_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_on_action(template_arg)
@@ -126,15 +128,3 @@ def fan_turn_on_to_code(config, action_id, arg_type, template_arg):
             yield None
         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

esphomeyaml/components/fan/binary.py

@@ -1,34 +1,29 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan, output
+from esphomeyaml.components import fan
 from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OSCILLATION_OUTPUT, CONF_OUTPUT
-from esphomeyaml.cpp_generator import get_variable, variable, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.helpers import App, add, get_variable, variable
 
 PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
-    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
-    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(output.BinaryOutput),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(None),
+    vol.Optional(CONF_OSCILLATION_OUTPUT): cv.use_variable_id(None),
+}))
 
 
 def to_code(config):
-    for output_ in get_variable(config[CONF_OUTPUT]):
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
         yield
 
     rhs = App.make_fan(config[CONF_NAME])
     fan_struct = variable(config[CONF_MAKE_ID], rhs)
-    add(fan_struct.Poutput.set_binary(output_))
+    add(fan_struct.Poutput.set_binary(output))
     if CONF_OSCILLATION_OUTPUT in config:
+        oscillation_output = None
         for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
             yield
         add(fan_struct.Poutput.set_oscillation(oscillation_output))
 
     fan.setup_fan(fan_struct.Pstate, fan_struct.Pmqtt, config)
-    setup_component(fan_struct.Poutput, config)
-
-
-def to_hass_config(data, config):
-    return fan.core_to_hass_config(data, config)

esphomeyaml/components/fan/speed.py

@@ -1,55 +1,45 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import fan, mqtt, output
+from esphomeyaml.components import fan
 from esphomeyaml.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.cpp_generator import get_variable, variable, add
-from esphomeyaml.cpp_types import App
+from esphomeyaml.helpers import App, add, get_variable, variable
 
 PLATFORM_SCHEMA = cv.nameable(fan.FAN_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(fan.MakeFan),
-    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(None),
     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_OSCILLATION_OUTPUT): cv.use_variable_id(None),
     vol.Optional(CONF_SPEED): vol.Schema({
         vol.Required(CONF_LOW): cv.percentage,
         vol.Required(CONF_MEDIUM): cv.percentage,
         vol.Required(CONF_HIGH): cv.percentage,
     }),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
-    for output_ in get_variable(config[CONF_OUTPUT]):
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
         yield
     rhs = App.make_fan(config[CONF_NAME])
     fan_struct = variable(config[CONF_MAKE_ID], rhs)
     if CONF_SPEED in config:
         speeds = config[CONF_SPEED]
-        add(fan_struct.Poutput.set_speed(output_,
+        add(fan_struct.Poutput.set_speed(output,
                                          speeds[CONF_LOW],
                                          speeds[CONF_MEDIUM],
                                          speeds[CONF_HIGH]))
     else:
-        add(fan_struct.Poutput.set_speed(output_))
+        add(fan_struct.Poutput.set_speed(output))
 
     if CONF_OSCILLATION_OUTPUT in config:
+        oscillation_output = None
         for oscillation_output in get_variable(config[CONF_OSCILLATION_OUTPUT]):
             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

esphomeyaml/components/font.py

@@ -1,20 +1,18 @@
 # coding=utf-8
 import voluptuous as vol
 
+import esphomeyaml.config_validation as cv
 from esphomeyaml import core
 from esphomeyaml.components import display
-import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_FILE, CONF_GLYPHS, CONF_ID, CONF_SIZE
-from esphomeyaml.core import CORE, HexInt
-from esphomeyaml.cpp_generator import ArrayInitializer, MockObj, Pvariable, RawExpression, add
-from esphomeyaml.cpp_types import App
-from esphomeyaml.py_compat import sort_by_cmp
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    relative_path
 
 DEPENDENCIES = ['display']
-MULTI_CONF = True
 
-Font = display.display_ns.class_('Font')
-Glyph = display.display_ns.class_('Glyph')
+Font = display.display_ns.Font
+Glyph = display.display_ns.Glyph
 
 
 def validate_glyphs(value):
@@ -34,11 +32,12 @@ def validate_glyphs(value):
 
         if len(x_) < len(y_):
             return -1
-        if len(x_) > len(y_):
+        elif len(x_) > len(y_):
             return 1
-        raise vol.Invalid(u"Found duplicate glyph {}".format(x))
+        else:
+            raise vol.Invalid(u"Found duplicate glyph {}".format(x))
 
-    sort_by_cmp(value, comparator)
+    value.sort(cmp=comparator)
     return value
 
 
@@ -47,11 +46,11 @@ def validate_pillow_installed(value):
         import PIL
     except ImportError:
         raise vol.Invalid("Please install the pillow python package to use this feature. "
-                          "(pip install pillow)")
+                          "(pip2 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)")
+                          "(pip2 install -U pillow)")
 
     return value
 
@@ -77,45 +76,46 @@ FONT_SCHEMA = vol.Schema({
     cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(None),
 })
 
-CONFIG_SCHEMA = vol.All(validate_pillow_installed, FONT_SCHEMA)
+CONFIG_SCHEMA = vol.All(validate_pillow_installed, cv.ensure_list, [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.EsphomeyamlError(u"Could not load truetype file {}: {}".format(path, e))
+    for conf in config:
+        path = relative_path(conf[CONF_FILE])
+        try:
+            font = ImageFont.truetype(path, conf[CONF_SIZE])
+        except Exception as e:
+            raise core.ESPHomeYAMLError(u"Could not load truetype file {}: {}".format(path, e))
 
-    ascent, descent = font.getmetrics()
+        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
+        glyph_args = {}
+        data = []
+        for glyph in conf[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
 
-    raw_data = MockObj(config[CONF_RAW_DATA_ID])
-    add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
-        raw_data, len(data),
-        ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
+        raw_data = MockObj(conf[CONF_RAW_DATA_ID])
+        add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
+            raw_data, len(data),
+            ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
 
-    glyphs = []
-    for glyph in config[CONF_GLYPHS]:
-        glyphs.append(Glyph(glyph, raw_data, *glyph_args[glyph]))
+        glyphs = []
+        for glyph in conf[CONF_GLYPHS]:
+            glyphs.append(Glyph(glyph, raw_data, *glyph_args[glyph]))
 
-    rhs = App.make_font(ArrayInitializer(*glyphs), ascent, ascent + descent)
-    Pvariable(config[CONF_ID], rhs)
+        rhs = App.make_font(ArrayInitializer(*glyphs), ascent, ascent + descent)
+        Pvariable(conf[CONF_ID], rhs)

esphomeyaml/components/globals.py

@@ -1,35 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml import config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_INITIAL_VALUE, CONF_RESTORE_VALUE, CONF_TYPE
-from esphomeyaml.cpp_generator import Pvariable, RawExpression, TemplateArguments, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component, esphomelib_ns
-
-GlobalVariableComponent = esphomelib_ns.class_('GlobalVariableComponent', Component)
-
-MULTI_CONF = True
-
-CONFIG_SCHEMA = vol.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)

esphomeyaml/components/i2c.py

@@ -1,27 +1,24 @@
 import voluptuous as vol
 
-from esphomeyaml import pins
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_FREQUENCY, CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_SCAN, CONF_SCL, \
-    CONF_SDA
-from esphomeyaml.cpp_generator import Pvariable, add
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Component, esphomelib_ns
+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
 
-I2CComponent = esphomelib_ns.class_('I2CComponent', Component)
-I2CDevice = pins.I2CDevice
+I2CComponent = esphomelib_ns.I2CComponent
 
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(I2CComponent),
-    vol.Optional(CONF_SDA, default='SDA'): pins.input_pullup_pin,
-    vol.Optional(CONF_SCL, default='SCL'): pins.input_pullup_pin,
+    vol.Required(CONF_SDA, default='SDA'): pins.input_output_pin,
+    vol.Required(CONF_SCL, default='SCL'): pins.input_output_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_RECEIVE_TIMEOUT): cv.invalid("The receive_timeout option has been removed "
                                                    "because timeouts are already handled by the "
                                                    "low-level i2c interface.")
-}).extend(cv.COMPONENT_SCHEMA.schema)
+})
 
 
 def to_code(config):
@@ -30,8 +27,6 @@ def to_code(config):
     if CONF_FREQUENCY in config:
         add(i2c.set_frequency(config[CONF_FREQUENCY]))
 
-    setup_component(i2c, config)
-
 
 BUILD_FLAGS = '-DUSE_I2C'
 

esphomeyaml/components/image.py

@@ -3,20 +3,19 @@ import logging
 
 import voluptuous as vol
 
+import esphomeyaml.config_validation as cv
 from esphomeyaml import core
 from esphomeyaml.components import display, font
-import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_FILE, CONF_ID, CONF_RESIZE
-from esphomeyaml.core import CORE, HexInt
-from esphomeyaml.cpp_generator import ArrayInitializer, MockObj, Pvariable, RawExpression, add
-from esphomeyaml.cpp_types import App
+from esphomeyaml.core import HexInt
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    relative_path
 
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['display']
-MULTI_CONF = True
 
-Image_ = display.display_ns.class_('Image')
+Image_ = display.display_ns.Image
 
 CONF_RAW_DATA_ID = 'raw_data_id'
 
@@ -27,39 +26,40 @@ IMAGE_SCHEMA = vol.Schema({
     cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_variable_id(None),
 })
 
-CONFIG_SCHEMA = vol.All(font.validate_pillow_installed, IMAGE_SCHEMA)
+CONFIG_SCHEMA = vol.All(font.validate_pillow_installed, cv.ensure_list, [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.EsphomeyamlError(u"Could not load image file {}: {}".format(path, e))
+    for conf in config:
+        path = relative_path(conf[CONF_FILE])
+        try:
+            image = Image.open(path)
+        except Exception as e:
+            raise core.ESPHomeYAMLError(u"Could not load image file {}: {}".format(path, e))
 
-    if CONF_RESIZE in config:
-        image.thumbnail(config[CONF_RESIZE])
+        if CONF_RESIZE in conf:
+            image.thumbnail(conf[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)
+        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)
 
-    raw_data = MockObj(config[CONF_RAW_DATA_ID])
-    add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
-        raw_data, len(data),
-        ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
+        raw_data = MockObj(conf[CONF_RAW_DATA_ID])
+        add(RawExpression('static const uint8_t {}[{}] PROGMEM = {}'.format(
+            raw_data, len(data),
+            ArrayInitializer(*[HexInt(x) for x in data], multiline=False))))
 
-    rhs = App.make_image(raw_data, width, height)
-    Pvariable(config[CONF_ID], rhs)
+        rhs = App.make_image(raw_data, width, height)
+        Pvariable(conf[CONF_ID], rhs)

esphomeyaml/components/interval.py

@@ -1,24 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml import automation
-import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ID, CONF_INTERVAL
-from esphomeyaml.cpp_generator import Pvariable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, NoArg, PollingComponent, Trigger, esphomelib_ns
-
-IntervalTrigger = esphomelib_ns.class_('IntervalTrigger', Trigger.template(NoArg), PollingComponent)
-
-CONFIG_SCHEMA = automation.validate_automation(vol.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_automation(trigger, NoArg, conf)

esphomeyaml/components/ir_transmitter.py

@@ -0,0 +1,6 @@
+import voluptuous as vol
+
+
+def CONFIG_SCHEMA(config):
+    raise vol.Invalid("The ir_transmitter component has been renamed to "
+                      "remote_transmitter because of 433MHz signal support.")

esphomeyaml/components/light/__init__.py

@@ -1,8 +1,6 @@
 import voluptuous as vol
 
-from esphomeyaml.automation import ACTION_REGISTRY, maybe_simple_id
-from esphomeyaml.components import mqtt
-from esphomeyaml.components.mqtt import setup_mqtt_component
+from esphomeyaml.automation import maybe_simple_id, ACTION_REGISTRY
 import esphomeyaml.config_validation as cv
 from esphomeyaml.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLORS, \
     CONF_DEFAULT_TRANSITION_LENGTH, CONF_DURATION, CONF_EFFECTS, CONF_EFFECT_ID, \
@@ -10,64 +8,49 @@ from esphomeyaml.const import CONF_ALPHA, CONF_BLUE, CONF_BRIGHTNESS, CONF_COLOR
     CONF_NUM_LEDS, CONF_RANDOM, CONF_RED, CONF_SPEED, CONF_STATE, CONF_TRANSITION_LENGTH, \
     CONF_UPDATE_INTERVAL, CONF_WHITE, CONF_WIDTH, CONF_FLASH_LENGTH, CONF_COLOR_TEMPERATURE, \
     CONF_EFFECT
-from esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import process_lambda, Pvariable, add, StructInitializer, \
-    ArrayInitializer, get_variable, templatable
-from esphomeyaml.cpp_types import esphomelib_ns, Application, Component, Nameable, Action, uint32, \
-    float_, std_string, void
+from esphomeyaml.helpers import Application, ArrayInitializer, Pvariable, RawExpression, \
+    StructInitializer, add, add_job, esphomelib_ns, process_lambda, setup_mqtt_component, \
+    get_variable, TemplateArguments, templatable, uint32, float_, std_string
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
-# Base
 light_ns = esphomelib_ns.namespace('light')
-LightState = light_ns.class_('LightState', Nameable, Component)
-MakeLight = Application.struct('MakeLight')
-LightOutput = light_ns.class_('LightOutput')
-AddressableLight = light_ns.class_('AddressableLight')
-AddressableLightRef = AddressableLight.operator('ref')
-
-# Actions
-ToggleAction = light_ns.class_('ToggleAction', Action)
-TurnOffAction = light_ns.class_('TurnOffAction', Action)
-TurnOnAction = light_ns.class_('TurnOnAction', Action)
-
-LightColorValues = light_ns.class_('LightColorValues')
-
-MQTTJSONLightComponent = light_ns.class_('MQTTJSONLightComponent', mqtt.MQTTComponent)
-
-# Effects
-LightEffect = light_ns.class_('LightEffect')
-RandomLightEffect = light_ns.class_('RandomLightEffect', LightEffect)
-LambdaLightEffect = light_ns.class_('LambdaLightEffect', LightEffect)
-StrobeLightEffect = light_ns.class_('StrobeLightEffect', LightEffect)
-StrobeLightEffectColor = light_ns.class_('StrobeLightEffectColor', LightEffect)
-FlickerLightEffect = light_ns.class_('FlickerLightEffect', LightEffect)
-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)
+LightState = light_ns.LightState
+LightColorValues = light_ns.LightColorValues
+MQTTJSONLightComponent = light_ns.MQTTJSONLightComponent
+ToggleAction = light_ns.ToggleAction
+TurnOffAction = light_ns.TurnOffAction
+TurnOnAction = light_ns.TurnOnAction
+MakeLight = Application.MakeLight
+RandomLightEffect = light_ns.RandomLightEffect
+LambdaLightEffect = light_ns.LambdaLightEffect
+StrobeLightEffect = light_ns.StrobeLightEffect
+StrobeLightEffectColor = light_ns.StrobeLightEffectColor
+FlickerLightEffect = light_ns.FlickerLightEffect
+FastLEDLambdaLightEffect = light_ns.FastLEDLambdaLightEffect
+FastLEDRainbowLightEffect = light_ns.FastLEDRainbowLightEffect
+FastLEDColorWipeEffect = light_ns.FastLEDColorWipeEffect
+FastLEDColorWipeEffectColor = light_ns.FastLEDColorWipeEffectColor
+FastLEDScanEffect = light_ns.FastLEDScanEffect
+FastLEDScanEffectColor = light_ns.FastLEDScanEffectColor
+FastLEDTwinkleEffect = light_ns.FastLEDTwinkleEffect
+FastLEDRandomTwinkleEffect = light_ns.FastLEDRandomTwinkleEffect
+FastLEDFireworksEffect = light_ns.FastLEDFireworksEffect
+FastLEDFlickerEffect = light_ns.FastLEDFlickerEffect
+FastLEDLightOutputComponent = light_ns.FastLEDLightOutputComponent
 
 CONF_STROBE = 'strobe'
 CONF_FLICKER = '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_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_ADD_LED_INTERVAL = 'add_led_interval'
 CONF_REVERSE = 'reverse'
@@ -82,10 +65,10 @@ CONF_INTENSITY = 'intensity'
 BINARY_EFFECTS = [CONF_LAMBDA, CONF_STROBE]
 MONOCHROMATIC_EFFECTS = BINARY_EFFECTS + [CONF_FLICKER]
 RGB_EFFECTS = MONOCHROMATIC_EFFECTS + [CONF_RANDOM]
-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]
+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]
 
 EFFECTS_SCHEMA = vol.Schema({
     vol.Optional(CONF_LAMBDA): vol.Schema({
@@ -102,7 +85,7 @@ EFFECTS_SCHEMA = vol.Schema({
     vol.Optional(CONF_STROBE): vol.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.Schema({
+        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.All(vol.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,
@@ -111,7 +94,7 @@ 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({
         cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FlickerLightEffect),
@@ -119,59 +102,58 @@ EFFECTS_SCHEMA = vol.Schema({
         vol.Optional(CONF_ALPHA): cv.percentage,
         vol.Optional(CONF_INTENSITY): cv.percentage,
     }),
-    vol.Optional(CONF_ADDRESSABLE_LAMBDA): vol.Schema({
+    vol.Optional(CONF_FASTLED_LAMBDA): vol.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_ADDRESSABLE_RAINBOW): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRainbowLightEffect),
+    vol.Optional(CONF_FASTLED_RAINBOW): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRainbowLightEffect),
         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_ADDRESSABLE_COLOR_WIPE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableColorWipeEffect),
+    vol.Optional(CONF_FASTLED_COLOR_WIPE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDColorWipeEffect),
         vol.Optional(CONF_NAME, default="Color Wipe"): cv.string,
-        vol.Optional(CONF_COLORS): cv.ensure_list({
+        vol.Optional(CONF_COLORS): vol.All(cv.ensure_list, [vol.Schema({
             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_ADDRESSABLE_SCAN): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableScanEffect),
+    vol.Optional(CONF_FASTLED_SCAN): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDScanEffect),
         vol.Optional(CONF_NAME, default="Scan"): cv.string,
         vol.Optional(CONF_MOVE_INTERVAL): cv.positive_time_period_milliseconds,
     }),
-    vol.Optional(CONF_ADDRESSABLE_TWINKLE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableTwinkleEffect),
+    vol.Optional(CONF_FASTLED_TWINKLE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDTwinkleEffect),
         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_ADDRESSABLE_RANDOM_TWINKLE): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableRandomTwinkleEffect),
+    vol.Optional(CONF_FASTLED_RANDOM_TWINKLE): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDRandomTwinkleEffect),
         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_ADDRESSABLE_FIREWORKS): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFireworksEffect),
+    vol.Optional(CONF_FASTLED_FIREWORKS): vol.Schema({
+        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(FastLEDFireworksEffect),
         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_ADDRESSABLE_FLICKER): vol.Schema({
-        cv.GenerateID(CONF_EFFECT_ID): cv.declare_variable_id(AddressableFlickerEffect),
-        vol.Optional(CONF_NAME, default="Addressable Flicker"): cv.string,
+    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_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
         vol.Optional(CONF_INTENSITY): cv.percentage,
     }),
@@ -180,64 +162,28 @@ EFFECTS_SCHEMA = vol.Schema({
 
 def validate_effects(allowed_effects):
     def validator(value):
-        is_list = isinstance(value, list)
-        if not is_list:
-            value = [value]
+        value = cv.ensure_list(value)
         names = set()
         ret = []
-        errors = []
         for i, effect in enumerate(value):
-            path = [i] if is_list else []
             if not isinstance(effect, dict):
-                errors.append(
-                    vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)),
-                                path)
-                )
-                continue
+                raise vol.Invalid("Each effect must be a dictionary, not {}".format(type(value)))
             if len(effect) > 1:
-                errors.append(
-                    vol.Invalid("Each entry in the 'effects:' option must be a single effect.",
-                                path)
-                )
-                continue
+                raise vol.Invalid("Each entry in the 'effects:' option must be a single effect.")
             if not effect:
-                errors.append(
-                    vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i),
-                                path)
-                )
-                continue
+                raise vol.Invalid("Found no effect for the {}th entry in 'effects:'!".format(i))
             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:
-                errors.append(
-                    vol.Invalid("The effect '{}' does not exist or is not allowed for this "
-                                "light type".format(key), path)
-                )
-                continue
+                raise vol.Invalid("The effect '{}' does not exist or is not allowed for this "
+                                  "light type".format(key))
             effect[key] = effect[key] or {}
-            try:
-                conf = EFFECTS_SCHEMA(effect)
-            except vol.Invalid as err:
-                err.prepend(path)
-                errors.append(err)
-                continue
+            conf = EFFECTS_SCHEMA(effect)
             name = conf[key][CONF_NAME]
             if name in names:
-                errors.append(
-                    vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
-                                u"unique names".format(name), [i])
-                )
-                continue
+                raise vol.Invalid(u"Found the effect name '{}' twice. All effects must have "
+                                  u"unique names".format(name))
             names.add(name)
             ret.append(conf)
-        if errors:
-            raise vol.MultipleInvalid(errors)
         return ret
 
     return validator
@@ -255,7 +201,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], [], return_type=void):
+        for lambda_ in process_lambda(config[CONF_LAMBDA], []):
             yield None
         yield LambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
     elif key == CONF_RANDOM:
@@ -289,22 +235,22 @@ def build_effect(full_config):
         if CONF_INTENSITY in config:
             add(effect.set_intensity(config[CONF_INTENSITY]))
         yield effect
-    elif key == CONF_ADDRESSABLE_LAMBDA:
-        args = [(AddressableLightRef, 'it')]
-        for lambda_ in process_lambda(config[CONF_LAMBDA], args, return_type=void):
+    elif key == CONF_FASTLED_LAMBDA:
+        lambda_ = None
+        args = [(RawExpression('FastLEDLightOutputComponent &'), 'it')]
+        for lambda_ in process_lambda(config[CONF_LAMBDA], args):
             yield None
-        yield AddressableLambdaLightEffect.new(config[CONF_NAME], lambda_,
-                                               config[CONF_UPDATE_INTERVAL])
-    elif key == CONF_ADDRESSABLE_RAINBOW:
-        rhs = AddressableRainbowLightEffect.new(config[CONF_NAME])
+        yield FastLEDLambdaLightEffect.new(config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL])
+    elif key == CONF_FASTLED_RAINBOW:
+        rhs = FastLEDRainbowLightEffect.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_ADDRESSABLE_COLOR_WIPE:
-        rhs = AddressableColorWipeEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_COLOR_WIPE:
+        rhs = FastLEDColorWipeEffect.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]))
@@ -313,41 +259,40 @@ def build_effect(full_config):
         colors = []
         for color in config.get(CONF_COLORS, []):
             colors.append(StructInitializer(
-                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))),
+                FastLEDColorWipeEffectColor,
+                ('r', color[CONF_RED]),
+                ('g', color[CONF_GREEN]),
+                ('b', color[CONF_BLUE]),
                 ('random', color[CONF_RANDOM]),
                 ('num_leds', color[CONF_NUM_LEDS]),
             ))
         if colors:
             add(effect.set_colors(ArrayInitializer(*colors)))
         yield effect
-    elif key == CONF_ADDRESSABLE_SCAN:
-        rhs = AddressableScanEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_SCAN:
+        rhs = FastLEDScanEffect.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_ADDRESSABLE_TWINKLE:
-        rhs = AddressableTwinkleEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_TWINKLE:
+        rhs = FastLEDTwinkleEffect.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_ADDRESSABLE_RANDOM_TWINKLE:
-        rhs = AddressableRandomTwinkleEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_RANDOM_TWINKLE:
+        rhs = FastLEDRandomTwinkleEffect.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_ADDRESSABLE_FIREWORKS:
-        rhs = AddressableFireworksEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_FIREWORKS:
+        rhs = FastLEDFireworksEffect.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]))
@@ -358,8 +303,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_ADDRESSABLE_FLICKER:
-        rhs = AddressableFlickerEffect.new(config[CONF_NAME])
+    elif key == CONF_FASTLED_FLICKER:
+        rhs = FastLEDFlickerEffect.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]))
@@ -391,20 +336,22 @@ def setup_light_core_(light_var, mqtt_var, config):
 def setup_light(light_obj, mqtt_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)
-    CORE.add_job(setup_light_core_, light_var, mqtt_var, config)
+    add_job(setup_light_core_, light_var, mqtt_var, config)
 
 
 BUILD_FLAGS = '-DUSE_LIGHT'
 
+
 CONF_LIGHT_TOGGLE = 'light.toggle'
 LIGHT_TOGGLE_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
     vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
 })
 
 
 @ACTION_REGISTRY.register(CONF_LIGHT_TOGGLE, LIGHT_TOGGLE_ACTION_SCHEMA)
-def light_toggle_to_code(config, action_id, arg_type, template_arg):
+def light_toggle_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_toggle_action(template_arg)
@@ -419,13 +366,14 @@ def light_toggle_to_code(config, action_id, arg_type, template_arg):
 
 CONF_LIGHT_TURN_OFF = 'light.turn_off'
 LIGHT_TURN_OFF_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
     vol.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
 })
 
 
 @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):
+def light_turn_off_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_off_action(template_arg)
@@ -440,7 +388,7 @@ def light_turn_off_to_code(config, action_id, arg_type, template_arg):
 
 CONF_LIGHT_TURN_ON = 'light.turn_on'
 LIGHT_TURN_ON_ACTION_SCHEMA = maybe_simple_id({
-    vol.Required(CONF_ID): cv.use_variable_id(LightState),
+    vol.Required(CONF_ID): cv.use_variable_id(None),
     vol.Exclusive(CONF_TRANSITION_LENGTH, 'transformer'):
         cv.templatable(cv.positive_time_period_milliseconds),
     vol.Exclusive(CONF_FLASH_LENGTH, 'transformer'):
@@ -456,7 +404,8 @@ 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):
+def light_turn_on_to_code(config, action_id, arg_type):
+    template_arg = TemplateArguments(arg_type)
     for var in get_variable(config[CONF_ID]):
         yield None
     rhs = var.make_turn_on_action(template_arg)
@@ -499,24 +448,3 @@ def light_turn_on_to_code(config, action_id, arg_type, template_arg):
             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)
-    if ret is None:
-        return None
-    ret['schema'] = 'json'
-    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

esphomeyaml/components/light/binary.py

@@ -1,28 +1,21 @@
 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.cpp_generator import get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
-    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.BinaryOutput),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(None),
     vol.Optional(CONF_EFFECTS): light.validate_effects(light.BINARY_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
-    for output_ in get_variable(config[CONF_OUTPUT]):
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
         yield
-    rhs = App.make_binary_light(config[CONF_NAME], output_)
+    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)
-    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)

esphomeyaml/components/light/cwww.py

@@ -1,27 +1,25 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.components import light, output
+from esphomeyaml.components import light
 from esphomeyaml.components.light.rgbww import validate_cold_white_colder, \
     validate_color_temperature
 from esphomeyaml.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.cpp_generator import get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
-    vol.Required(CONF_COLD_WHITE): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_COLD_WHITE): cv.use_variable_id(None),
+    vol.Required(CONF_WARM_WHITE): cv.use_variable_id(None),
     vol.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
     vol.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): validate_color_temperature,
 
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_EFFECTS): light.validate_effects(light.MONOCHROMATIC_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema), validate_cold_white_colder)
+}), validate_cold_white_colder)
 
 
 def to_code(config):
@@ -34,9 +32,3 @@ def to_code(config):
                               cold_white, warm_white)
     light_struct = variable(config[CONF_MAKE_ID], rhs)
     light.setup_light(light_struct.Pstate, light_struct.Pmqtt, 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)

esphomeyaml/components/light/fastled_clockless.py

@@ -1,15 +1,14 @@
 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
-import esphomeyaml.config_validation as cv
-from esphomeyaml.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 esphomeyaml.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Application
+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
 
 TYPES = [
     'NEOPIXEL',
@@ -54,24 +53,24 @@ def validate(value):
     return value
 
 
-MakeFastLEDLight = Application.struct('MakeFastLEDLight')
+MakeFastLEDLight = Application.MakeFastLEDLight
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
 
-    vol.Required(CONF_CHIPSET): cv.one_of(*TYPES, upper=True),
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*TYPES)),
     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): cv.one_of(*RGB_ORDERS, upper=True),
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
 
     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.ADDRESSABLE_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema), validate)
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.FASTLED_EFFECTS),
+}), validate)
 
 
 def to_code(config):
@@ -90,6 +89,7 @@ def to_code(config):
         add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
 
     if CONF_POWER_SUPPLY in config:
+        power_supply = None
         for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
             yield
         add(fast_led.set_power_supply(power_supply))
@@ -99,14 +99,6 @@ def to_code(config):
         add(fast_led.set_correction(r, g, b))
 
     light.setup_light(make.Pstate, make.Pmqtt, config)
-    setup_component(fast_led, config)
 
 
 BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
-
-LIB_DEPS = 'FastLED@3.2.0'
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=False)

esphomeyaml/components/light/fastled_spi.py

@@ -1,15 +1,14 @@
 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
-import esphomeyaml.config_validation as cv
-from esphomeyaml.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 esphomeyaml.cpp_generator import RawExpression, TemplateArguments, add, get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App, Application
+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
 
 CHIPSETS = [
     'LPD8806',
@@ -31,25 +30,25 @@ RGB_ORDERS = [
     'BGR',
 ]
 
-MakeFastLEDLight = Application.struct('MakeFastLEDLight')
+MakeFastLEDLight = Application.MakeFastLEDLight
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeFastLEDLight),
 
-    vol.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
+    vol.Required(CONF_CHIPSET): vol.All(vol.Upper, cv.one_of(*CHIPSETS)),
     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): cv.one_of(*RGB_ORDERS, upper=True),
+    vol.Optional(CONF_RGB_ORDER): vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
     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.ADDRESSABLE_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+    vol.Optional(CONF_EFFECTS): light.validate_effects(light.FASTLED_EFFECTS),
+}))
 
 
 def to_code(config):
@@ -70,6 +69,7 @@ def to_code(config):
         add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
 
     if CONF_POWER_SUPPLY in config:
+        power_supply = None
         for power_supply in get_variable(config[CONF_POWER_SUPPLY]):
             yield
         add(fast_led.set_power_supply(power_supply))
@@ -79,14 +79,6 @@ def to_code(config):
         add(fast_led.set_correction(r, g, b))
 
     light.setup_light(make.Pstate, make.Pmqtt, config)
-    setup_component(fast_led, config)
 
 
 BUILD_FLAGS = '-DUSE_FAST_LED_LIGHT'
-
-LIB_DEPS = 'FastLED@3.2.0'
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value=False)

esphomeyaml/components/light/monochromatic.py

@@ -1,31 +1,24 @@
 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, \
-    CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
-from esphomeyaml.cpp_generator import get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.components import light
+from esphomeyaml.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_MAKE_ID, \
+    CONF_NAME, CONF_OUTPUT, CONF_EFFECTS
+from esphomeyaml.helpers import App, get_variable, variable
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
-    vol.Required(CONF_OUTPUT): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_OUTPUT): cv.use_variable_id(None),
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_EFFECTS): light.validate_effects(light.MONOCHROMATIC_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
-    for output_ in get_variable(config[CONF_OUTPUT]):
+    output = None
+    for output in get_variable(config[CONF_OUTPUT]):
         yield
-    rhs = App.make_monochromatic_light(config[CONF_NAME], output_)
+    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)
-    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)

esphomeyaml/components/light/neopixelbus.py

@@ -1,170 +0,0 @@
-import voluptuous as vol
-
-from esphomeyaml import pins
-from esphomeyaml.components import light
-from esphomeyaml.components.light import AddressableLight
-from esphomeyaml.components.power_supply import PowerSupplyComponent
-import esphomeyaml.config_validation as cv
-from esphomeyaml.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 esphomeyaml.core import CORE
-from esphomeyaml.cpp_generator import TemplateArguments, add, get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.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
-
-
-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(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)
-
-
-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, make.Pmqtt, config)
-    setup_component(output, config)
-
-
-BUILD_FLAGS = '-DUSE_NEO_PIXEL_BUS_LIGHT'
-
-LIB_DEPS = 'NeoPixelBus@2.4.1'
-
-
-def to_hass_config(data, config):
-    return light.core_to_hass_config(data, config, brightness=True, rgb=True, color_temp=False,
-                                     white_value='W' in config[CONF_TYPE])

esphomeyaml/components/light/rgb.py

@@ -1,37 +1,32 @@
 import voluptuous as vol
 
-from esphomeyaml.components import light, output
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_BLUE, CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, \
-    CONF_GAMMA_CORRECT, CONF_GREEN, CONF_MAKE_ID, CONF_NAME, CONF_RED
-from esphomeyaml.cpp_generator import get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.components import light
+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
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
-    vol.Required(CONF_RED): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_GREEN): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_BLUE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_RED): cv.use_variable_id(None),
+    vol.Required(CONF_GREEN): cv.use_variable_id(None),
+    vol.Required(CONF_BLUE): cv.use_variable_id(None),
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_EFFECTS): light.validate_effects(light.RGB_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
+    red = None
     for red in get_variable(config[CONF_RED]):
         yield
+    green = None
     for green in get_variable(config[CONF_GREEN]):
         yield
+    blue = None
     for blue in get_variable(config[CONF_BLUE]):
         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)
-    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)

esphomeyaml/components/light/rgbw.py

@@ -1,40 +1,36 @@
 import voluptuous as vol
 
-from esphomeyaml.components import light, output
 import esphomeyaml.config_validation as cv
-from esphomeyaml.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 esphomeyaml.cpp_generator import get_variable, variable
-from esphomeyaml.cpp_helpers import setup_component
-from esphomeyaml.cpp_types import App
+from esphomeyaml.components import light
+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
 
 PLATFORM_SCHEMA = cv.nameable(light.LIGHT_PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(light.MakeLight),
-    vol.Required(CONF_RED): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_GREEN): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_BLUE): cv.use_variable_id(output.FloatOutput),
-    vol.Required(CONF_WHITE): cv.use_variable_id(output.FloatOutput),
+    vol.Required(CONF_RED): cv.use_variable_id(None),
+    vol.Required(CONF_GREEN): cv.use_variable_id(None),
+    vol.Required(CONF_BLUE): cv.use_variable_id(None),
+    vol.Required(CONF_WHITE): cv.use_variable_id(None),
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_EFFECTS): light.validate_effects(light.RGB_EFFECTS),
-}).extend(cv.COMPONENT_SCHEMA.schema))
+}))
 
 
 def to_code(config):
+    red = None
     for red in get_variable(config[CONF_RED]):
         yield
+    green = None
     for green in get_variable(config[CONF_GREEN]):
         yield
+    blue = None
     for blue in get_variable(config[CONF_BLUE]):
         yield
+    white = None
     for white in get_variable(config[CONF_WHITE]):
         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)
-    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)