Merge pull request #5833 from home-assistant/release-038

Release 0.38

.coveragerc

@@ -5,6 +5,7 @@ omit =
     homeassistant/__main__.py
     homeassistant/scripts/*.py
     homeassistant/helpers/typing.py
+    homeassistant/helpers/signal.py
 
     # omit pieces of code that rely on external devices being present
     homeassistant/components/apcupsd.py
@@ -13,6 +14,9 @@ omit =
     homeassistant/components/arduino.py
     homeassistant/components/*/arduino.py
 
+    homeassistant/components/bbb_gpio.py
+    homeassistant/components/*/bbb_gpio.py
+
     homeassistant/components/bloomsky.py
     homeassistant/components/*/bloomsky.py
 
@@ -28,17 +32,23 @@ omit =
     homeassistant/components/envisalink.py
     homeassistant/components/*/envisalink.py
 
+    homeassistant/components/google.py
+    homeassistant/components/*/google.py
+
     homeassistant/components/insteon_hub.py
     homeassistant/components/*/insteon_hub.py
 
+    homeassistant/components/insteon_local.py
+    homeassistant/components/*/insteon_local.py
+
     homeassistant/components/ios.py
     homeassistant/components/*/ios.py
 
     homeassistant/components/isy994.py
     homeassistant/components/*/isy994.py
 
-    homeassistant/components/litejet.py
-    homeassistant/components/*/litejet.py
+    homeassistant/components/lutron.py
+    homeassistant/components/*/lutron.py
 
     homeassistant/components/modbus.py
     homeassistant/components/*/modbus.py
@@ -98,30 +108,39 @@ omit =
     homeassistant/components/netatmo.py
     homeassistant/components/*/netatmo.py
 
+    homeassistant/components/neato.py
+    homeassistant/components/*/neato.py
+
     homeassistant/components/homematic.py
     homeassistant/components/*/homematic.py
 
     homeassistant/components/knx.py
     homeassistant/components/*/knx.py
 
-    homeassistant/components/ffmpeg.py
-    homeassistant/components/*/ffmpeg.py
-
     homeassistant/components/zoneminder.py
     homeassistant/components/*/zoneminder.py
 
     homeassistant/components/mochad.py
     homeassistant/components/*/mochad.py
 
+    homeassistant/components/zabbix.py
+    homeassistant/components/*/zabbix.py
+
     homeassistant/components/alarm_control_panel/alarmdotcom.py
     homeassistant/components/alarm_control_panel/concord232.py
     homeassistant/components/alarm_control_panel/nx584.py
     homeassistant/components/alarm_control_panel/simplisafe.py
+    homeassistant/components/apiai.py
     homeassistant/components/binary_sensor/arest.py
     homeassistant/components/binary_sensor/concord232.py
+    homeassistant/components/binary_sensor/flic.py
+    homeassistant/components/binary_sensor/hikvision.py
+    homeassistant/components/binary_sensor/iss.py
     homeassistant/components/binary_sensor/rest.py
     homeassistant/components/browser.py
+    homeassistant/components/camera/amcrest.py
     homeassistant/components/camera/bloomsky.py
+    homeassistant/components/camera/ffmpeg.py
     homeassistant/components/camera/foscam.py
     homeassistant/components/camera/mjpeg.py
     homeassistant/components/camera/rpi_camera.py
@@ -132,7 +151,7 @@ omit =
     homeassistant/components/climate/knx.py
     homeassistant/components/climate/proliphix.py
     homeassistant/components/climate/radiotherm.py
-    homeassistant/components/cover/garadget.py    
+    homeassistant/components/cover/garadget.py
     homeassistant/components/cover/homematic.py
     homeassistant/components/cover/rpi_gpio.py
     homeassistant/components/cover/scsgate.py
@@ -144,20 +163,30 @@ omit =
     homeassistant/components/device_tracker/bluetooth_le_tracker.py
     homeassistant/components/device_tracker/bluetooth_tracker.py
     homeassistant/components/device_tracker/bt_home_hub_5.py
+    homeassistant/components/device_tracker/cisco_ios.py
     homeassistant/components/device_tracker/fritz.py
+    homeassistant/components/device_tracker/gpslogger.py
     homeassistant/components/device_tracker/icloud.py
+    homeassistant/components/device_tracker/linksys_ap.py
     homeassistant/components/device_tracker/luci.py
     homeassistant/components/device_tracker/netgear.py
     homeassistant/components/device_tracker/nmap_tracker.py
+    homeassistant/components/device_tracker/ping.py
+    homeassistant/components/device_tracker/sky_hub.py
     homeassistant/components/device_tracker/snmp.py
+    homeassistant/components/device_tracker/swisscom.py
     homeassistant/components/device_tracker/thomson.py
     homeassistant/components/device_tracker/tomato.py
+    homeassistant/components/device_tracker/tado.py
     homeassistant/components/device_tracker/tplink.py
+    homeassistant/components/device_tracker/trackr.py
     homeassistant/components/device_tracker/ubus.py
     homeassistant/components/device_tracker/volvooncall.py
+    homeassistant/components/device_tracker/xiaomi.py
     homeassistant/components/discovery.py
     homeassistant/components/downloader.py
     homeassistant/components/emoncms_history.py
+    homeassistant/components/emulated_hue/upnp.py
     homeassistant/components/fan/mqtt.py
     homeassistant/components/feedreader.py
     homeassistant/components/foursquare.py
@@ -166,29 +195,43 @@ omit =
     homeassistant/components/joaoapps_join.py
     homeassistant/components/keyboard.py
     homeassistant/components/keyboard_remote.py
+    homeassistant/components/light/avion.py
     homeassistant/components/light/blinksticklight.py
+    homeassistant/components/light/decora.py
     homeassistant/components/light/flux_led.py
     homeassistant/components/light/hue.py
     homeassistant/components/light/hyperion.py
     homeassistant/components/light/lifx.py
     homeassistant/components/light/limitlessled.py
     homeassistant/components/light/osramlightify.py
+    homeassistant/components/light/tikteck.py
     homeassistant/components/light/x10.py
     homeassistant/components/light/yeelight.py
+    homeassistant/components/light/piglow.py
+    homeassistant/components/light/zengge.py
     homeassistant/components/lirc.py
+    homeassistant/components/lock/nuki.py
+    homeassistant/components/media_player/anthemav.py
+    homeassistant/components/media_player/apple_tv.py
+    homeassistant/components/media_player/aquostv.py
     homeassistant/components/media_player/braviatv.py
     homeassistant/components/media_player/cast.py
     homeassistant/components/media_player/cmus.py
     homeassistant/components/media_player/denon.py
+    homeassistant/components/media_player/denonavr.py
     homeassistant/components/media_player/directv.py
+    homeassistant/components/media_player/dunehd.py
     homeassistant/components/media_player/emby.py
     homeassistant/components/media_player/firetv.py
     homeassistant/components/media_player/gpmdp.py
+    homeassistant/components/media_player/hdmi_cec.py
     homeassistant/components/media_player/itunes.py
     homeassistant/components/media_player/kodi.py
     homeassistant/components/media_player/lg_netcast.py
+    homeassistant/components/media_player/liveboxplaytv.py
     homeassistant/components/media_player/mpchc.py
     homeassistant/components/media_player/mpd.py
+    homeassistant/components/media_player/nad.py
     homeassistant/components/media_player/onkyo.py
     homeassistant/components/media_player/panasonic_viera.py
     homeassistant/components/media_player/pandora.py
@@ -201,17 +244,22 @@ omit =
     homeassistant/components/media_player/snapcast.py
     homeassistant/components/media_player/sonos.py
     homeassistant/components/media_player/squeezebox.py
+    homeassistant/components/media_player/vlc.py
     homeassistant/components/media_player/yamaha.py
     homeassistant/components/notify/aws_lambda.py
     homeassistant/components/notify/aws_sns.py
     homeassistant/components/notify/aws_sqs.py
+    homeassistant/components/notify/discord.py
+    homeassistant/components/notify/facebook.py
     homeassistant/components/notify/free_mobile.py
     homeassistant/components/notify/gntp.py
     homeassistant/components/notify/group.py
     homeassistant/components/notify/instapush.py
     homeassistant/components/notify/joaoapps_join.py
     homeassistant/components/notify/kodi.py
+    homeassistant/components/notify/lannouncer.py
     homeassistant/components/notify/llamalab_automate.py
+    homeassistant/components/notify/mailgun.py
     homeassistant/components/notify/matrix.py
     homeassistant/components/notify/message_bird.py
     homeassistant/components/notify/nfandroidtv.py
@@ -228,16 +276,20 @@ omit =
     homeassistant/components/notify/telegram.py
     homeassistant/components/notify/telstra.py
     homeassistant/components/notify/twilio_sms.py
+    homeassistant/components/notify/twilio_call.py
     homeassistant/components/notify/twitter.py
     homeassistant/components/notify/xmpp.py
     homeassistant/components/nuimo_controller.py
-    homeassistant/components/openalpr.py
+    homeassistant/components/remote/harmony.py
     homeassistant/components/scene/hunterdouglas_powerview.py
+    homeassistant/components/sensor/amcrest.py
     homeassistant/components/sensor/arest.py
     homeassistant/components/sensor/arwn.py
     homeassistant/components/sensor/bbox.py
     homeassistant/components/sensor/bitcoin.py
     homeassistant/components/sensor/bom.py
+    homeassistant/components/sensor/broadlink.py
+    homeassistant/components/sensor/dublin_bus_transport.py
     homeassistant/components/sensor/coinmarketcap.py
     homeassistant/components/sensor/cpuspeed.py
     homeassistant/components/sensor/cups.py
@@ -261,6 +313,7 @@ omit =
     homeassistant/components/sensor/haveibeenpwned.py
     homeassistant/components/sensor/hddtemp.py
     homeassistant/components/sensor/hp_ilo.py
+    homeassistant/components/sensor/hydroquebec.py
     homeassistant/components/sensor/imap.py
     homeassistant/components/sensor/imap_email_content.py
     homeassistant/components/sensor/influxdb.py
@@ -270,18 +323,27 @@ omit =
     homeassistant/components/sensor/mhz19.py
     homeassistant/components/sensor/miflora.py
     homeassistant/components/sensor/mqtt_room.py
+    homeassistant/components/sensor/netdata.py
     homeassistant/components/sensor/neurio_energy.py
+    homeassistant/components/sensor/nut.py
     homeassistant/components/sensor/nzbget.py
     homeassistant/components/sensor/ohmconnect.py
     homeassistant/components/sensor/onewire.py
+    homeassistant/components/sensor/openevse.py
     homeassistant/components/sensor/openexchangerates.py
     homeassistant/components/sensor/openweathermap.py
     homeassistant/components/sensor/pi_hole.py
     homeassistant/components/sensor/plex.py
+    homeassistant/components/sensor/pvoutput.py
+    homeassistant/components/sensor/qnap.py
     homeassistant/components/sensor/sabnzbd.py
     homeassistant/components/sensor/scrape.py
+    homeassistant/components/sensor/sensehat.py
     homeassistant/components/sensor/serial_pm.py
+    homeassistant/components/sensor/skybeacon.py
+    homeassistant/components/sensor/sma.py
     homeassistant/components/sensor/snmp.py
+    homeassistant/components/sensor/sonarr.py
     homeassistant/components/sensor/speedtest.py
     homeassistant/components/sensor/steam_online.py
     homeassistant/components/sensor/supervisord.py
@@ -296,17 +358,25 @@ omit =
     homeassistant/components/sensor/transmission.py
     homeassistant/components/sensor/twitch.py
     homeassistant/components/sensor/uber.py
+    homeassistant/components/sensor/usps.py
     homeassistant/components/sensor/vasttrafik.py
+    homeassistant/components/sensor/waqi.py
     homeassistant/components/sensor/xbox_live.py
     homeassistant/components/sensor/yweather.py
+    homeassistant/components/sensor/zamg.py
     homeassistant/components/switch/acer_projector.py
     homeassistant/components/switch/anel_pwrctrl.py
     homeassistant/components/switch/arest.py
+    homeassistant/components/switch/broadlink.py
+    homeassistant/components/switch/digitalloggers.py
     homeassistant/components/switch/dlink.py
     homeassistant/components/switch/edimax.py
+    homeassistant/components/switch/fritzdect.py
+    homeassistant/components/switch/hdmi_cec.py
     homeassistant/components/switch/hikvisioncam.py
+    homeassistant/components/switch/hook.py
+    homeassistant/components/switch/kankun.py
     homeassistant/components/switch/mystrom.py
-    homeassistant/components/switch/neato.py
     homeassistant/components/switch/netio.py
     homeassistant/components/switch/orvibo.py
     homeassistant/components/switch/pilight.py
@@ -317,7 +387,10 @@ omit =
     homeassistant/components/switch/transmission.py
     homeassistant/components/switch/wake_on_lan.py
     homeassistant/components/thingspeak.py
+    homeassistant/components/tts/amazon_polly.py
+    homeassistant/components/tts/picotts.py
     homeassistant/components/upnp.py
+    homeassistant/components/weather/bom.py
     homeassistant/components/weather/openweathermap.py
     homeassistant/components/zeroconf.py
 

.gitignore

@@ -62,6 +62,7 @@ pip-log.txt
 .coverage
 .tox
 nosetests.xml
+htmlcov/
 
 # Translations
 *.mo

.hound.yml

@@ -0,0 +1,2 @@
+python:
+  enabled: true

.ignore

@@ -0,0 +1,6 @@
+# Patterns matched in this file will be ignored by supported search utilities
+
+# Ignore generated html and javascript files
+/homeassistant/components/frontend/www_static/*.html
+/homeassistant/components/frontend/www_static/*.js
+/homeassistant/components/frontend/www_static/panels/*.html

.travis.yml

@@ -8,13 +8,16 @@ matrix:
       env: TOXENV=requirements
     - python: "3.4.2"
       env: TOXENV=lint
-    - python: "3.5"
-      env: TOXENV=typing
+    # - python: "3.5"
+    #   env: TOXENV=typing
     - python: "3.5"
       env: TOXENV=py35
-  allow_failures:
-    - python: "3.5"
-      env: TOXENV=typing
+    - python: "3.6"
+      env: TOXENV=py36
+  # allow_failures:
+  #   - python: "3.5"
+  #     env: TOXENV=typing
+
 cache:
   directories:
     - $HOME/.cache/pip

CLA.md

@@ -0,0 +1,39 @@
+# Contributor License Agreement
+
+```
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the Apache 2.0 license; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the Apache 2.0 license; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it) is maintained indefinitely
+    and may be redistributed consistent with this project or the open
+    source license(s) involved.
+```
+
+## Attribution
+
+The text of this license is available under the [Creative Commons Attribution-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-sa/3.0/).  It is based on the Linux [Developer Certificate Of Origin](http://elinux.org/Developer_Certificate_Of_Origin), but is modified to explicitly use the Apache 2.0 license
+and not mention sign-off.
+
+## Signing
+
+To sign this CLA you must first submit a pull request to a repository under the Home Assistant organization.
+
+## Adoption
+
+This Contributor License Agreement (CLA) was first announced on January 21st, 2017 in [this][cla-blog] blog post and adopted January 28th, 2017.
+
+[cla-blog]: https://home-assistant.io/blog/2017/01/21/home-assistant-governance/

CODE_OF_CONDUCT.md

@@ -0,0 +1,80 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [safety@home-assistant.io][email]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available [here][version].
+
+## Adoption
+
+This Code of Conduct was first adopted January 21st, 2017 and announced in [this][coc-blog] blog post.
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
+[email]: mailto:safety@home-assistant.io
+[coc-blog]: https://home-assistant.io/blog/2017/01/21/home-assistant-governance/

CONTRIBUTING.md

@@ -1,13 +1,14 @@
 # Contributing to Home Assistant
 
-Everybody is invited and welcome to contribute to Home Assistant. There is a lot to do...if you are not a developer perhaps you would like to help with the documentation on [home-assistant.io](https://home-assistant.io/)? If you are a developer and have devices in your home which aren't working with Home Assistant yet, why not spent a couple of hours and help to integrate them? 
+Everybody is invited and welcome to contribute to Home Assistant. There is a lot to do...if you are not a developer perhaps you would like to help with the documentation on [home-assistant.io](https://home-assistant.io/)? If you are a developer and have devices in your home which aren't working with Home Assistant yet, why not spent a couple of hours and help to integrate them?
 
 The process is straight-forward.
 
+ - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/faster_reviews.md) by Kubernetes (but skip step 0)
  - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
  - Write the code for your device, notification service, sensor, or IoT thing.
  - Ensure tests work.
  - Create a Pull Request against the [**dev**](https://github.com/home-assistant/home-assistant/tree/dev) branch of Home Assistant.
 
-Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details. 
+Still interested? Then you should take a peak at the [developer documentation](https://home-assistant.io/developers/) to get more details.
 

Dockerfile

@@ -1,28 +1,29 @@
 FROM python:3.5
 MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
 
+# Uncomment any of the following lines to disable the installation.
+#ENV INSTALL_TELLSTICK no
+#ENV INSTALL_OPENALPR no
+#ENV INSTALL_FFMPEG no
+#ENV INSTALL_OPENZWAVE no
+#ENV INSTALL_LIBCEC no
+#ENV INSTALL_PHANTOMJS no
+
 VOLUME /config
 
 RUN mkdir -p /usr/src/app
 WORKDIR /usr/src/app
 
-RUN pip3 install --no-cache-dir colorlog cython
-
-# For the nmap tracker, bluetooth tracker, Z-Wave
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo libglib2.0-dev bluetooth libbluetooth-dev && \
-    apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-COPY script/build_python_openzwave script/build_python_openzwave
-RUN script/build_python_openzwave && \
-  mkdir -p /usr/local/share/python-openzwave && \
-  ln -sf /usr/src/app/build/python-openzwave/openzwave/config /usr/local/share/python-openzwave/config
+# Copy build scripts
+COPY virtualization/Docker/ virtualization/Docker/
+RUN virtualization/Docker/setup_docker_prereqs
 
+# Install hass component dependencies
 COPY requirements_all.txt requirements_all.txt
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install mysqlclient psycopg2 uvloop
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop
 
 # Copy source
 COPY . .
 
-CMD [ "python", "-m", "homeassistant", "--config", "/config" ]
+CMD [ "python", "-m", "homeassistant", "--config", "/config" ]

LICENSE

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Paulus Schoutsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE.md

@@ -0,0 +1,194 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

README.rst

@@ -26,7 +26,8 @@ Examples of devices Home Assistant can interface with:
    `Netgear <http://netgear.com>`__,
    `DD-WRT <http://www.dd-wrt.com/site/index>`__,
    `TPLink <http://www.tp-link.us/>`__,
-   `ASUSWRT <http://event.asus.com/2013/nw/ASUSWRT/>`__ and any SNMP
+   `ASUSWRT <http://event.asus.com/2013/nw/ASUSWRT/>`__,
+   `Xiaomi <http://miwifi.com/>`__ and any SNMP
    capable Linksys WAP/WRT
 -  `Philips Hue <http://meethue.com>`__ lights,
    `WeMo <http://www.belkin.com/us/Products/home-automation/c/wemo-home-automation/>`__
@@ -86,7 +87,7 @@ components <https://home-assistant.io/developers/creating_components/>`__.
 
 If you run into issues while using Home Assistant or during development
 of a component, check the `Home Assistant help
-section <https://home-assistant.io/help/>`__ how to reach us.
+section <https://home-assistant.io/help/>`__ of our website for further help and information.
 
 .. |Build Status| image:: https://travis-ci.org/home-assistant/home-assistant.svg?branch=master
    :target: https://travis-ci.org/home-assistant/home-assistant

homeassistant/__main__.py

@@ -356,7 +356,8 @@ def try_to_restart() -> None:
 
 def main() -> int:
     """Start Home Assistant."""
-    monkey_patch_asyncio()
+    if sys.version_info[:3] < (3, 5, 3):
+        monkey_patch_asyncio()
 
     validate_python()
 

homeassistant/bootstrap.py

@@ -4,7 +4,7 @@ import logging
 import logging.handlers
 import os
 import sys
-from collections import defaultdict
+from collections import OrderedDict
 
 from types import ModuleType
 from typing import Any, Optional, Dict
@@ -20,11 +20,13 @@ import homeassistant.loader as loader
 import homeassistant.util.package as pkg_util
 from homeassistant.util.async import (
     run_coroutine_threadsafe, run_callback_threadsafe)
+from homeassistant.util.logging import AsyncHandler
 from homeassistant.util.yaml import clear_secret_cache
 from homeassistant.const import EVENT_COMPONENT_LOADED, PLATFORM_FORMAT
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import (
     event_decorators, service, config_per_platform, extract_domain_configs)
+from homeassistant.helpers.signal import async_register_signal_handling
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -57,7 +59,7 @@ def async_setup_component(hass: core.HomeAssistant, domain: str,
         yield from hass.loop.run_in_executor(None, loader.prepare, hass)
 
     if config is None:
-        config = defaultdict(dict)
+        config = {}
 
     components = loader.load_order_component(domain)
 
@@ -142,6 +144,7 @@ def _async_setup_component(hass: core.HomeAssistant,
         async_comp = hasattr(component, 'async_setup')
 
         try:
+            _LOGGER.info("Setting up %s", domain)
             if async_comp:
                 result = yield from component.async_setup(hass, config)
             else:
@@ -165,15 +168,6 @@ def _async_setup_component(hass: core.HomeAssistant,
 
         hass.config.components.append(component.DOMAIN)
 
-        # Assumption: if a component does not depend on groups
-        # it communicates with devices
-        if (not async_comp and
-                'group' not in getattr(component, 'DEPENDENCIES', [])):
-            if hass.pool is None:
-                hass.async_init_pool()
-            if hass.pool.worker_count <= 10:
-                hass.pool.add_worker()
-
         hass.bus.async_fire(
             EVENT_COMPONENT_LOADED, {ATTR_COMPONENT: component.DOMAIN}
         )
@@ -353,7 +347,7 @@ def from_config_dict(config: Dict[str, Any],
 
     # run task
     future = asyncio.Future(loop=hass.loop)
-    hass.loop.create_task(_async_init_from_config_dict(future))
+    hass.async_add_job(_async_init_from_config_dict(future))
     hass.loop.run_until_complete(future)
 
     return future.result()
@@ -373,6 +367,13 @@ def async_from_config_dict(config: Dict[str, Any],
     Dynamically loads required components and its dependencies.
     This method is a coroutine.
     """
+    hass.async_track_tasks()
+    setup_lock = hass.data.get('setup_lock')
+    if setup_lock is None:
+        setup_lock = hass.data['setup_lock'] = asyncio.Lock(loop=hass.loop)
+
+    yield from setup_lock.acquire()
+
     core_config = config.get(core.DOMAIN, {})
 
     try:
@@ -395,11 +396,17 @@ def async_from_config_dict(config: Dict[str, Any],
     if not loader.PREPARED:
         yield from hass.loop.run_in_executor(None, loader.prepare, hass)
 
+    # Merge packages
+    conf_util.merge_packages_config(
+        config, core_config.get(conf_util.CONF_PACKAGES, {}))
+
     # Make a copy because we are mutating it.
-    # Convert it to defaultdict so components can always have config dict
+    # Use OrderedDict in case original one was one.
     # Convert values to dictionaries if they are None
-    config = defaultdict(
-        dict, {key: value or {} for key, value in config.items()})
+    new_config = OrderedDict()
+    for key, value in config.items():
+        new_config[key] = value or {}
+    config = new_config
 
     # Filter out the repeating and common config section [homeassistant]
     components = set(key.split(' ')[0] for key in config.keys()
@@ -425,6 +432,11 @@ def async_from_config_dict(config: Dict[str, Any],
     for domain in loader.load_order_components(components):
         yield from _async_setup_component(hass, domain, config)
 
+    setup_lock.release()
+
+    yield from hass.async_stop_track_tasks()
+
+    async_register_signal_handling(hass)
     return hass
 
 
@@ -498,8 +510,10 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
     Async friendly.
     """
     logging.basicConfig(level=logging.INFO)
-    fmt = ("%(log_color)s%(asctime)s %(levelname)s (%(threadName)s) "
-           "[%(name)s] %(message)s%(reset)s")
+    fmt = ("%(asctime)s %(levelname)s (%(threadName)s) "
+           "[%(name)s] %(message)s")
+    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
+    datefmt = '%y-%m-%d %H:%M:%S'
 
     # suppress overly verbose logs from libraries that aren't helpful
     logging.getLogger("requests").setLevel(logging.WARNING)
@@ -509,8 +523,8 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
     try:
         from colorlog import ColoredFormatter
         logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
-            fmt,
-            datefmt='%y-%m-%d %H:%M:%S',
+            colorfmt,
+            datefmt=datefmt,
             reset=True,
             log_colors={
                 'DEBUG': 'cyan',
@@ -523,6 +537,10 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
     except ImportError:
         pass
 
+    # AsyncHandler allready exists?
+    if hass.data.get(core.DATA_ASYNCHANDLER):
+        return
+
     # Log errors to a file if we have write access to file or config dir
     err_log_path = hass.config.path(ERROR_LOG_FILENAME)
     err_path_exists = os.path.isfile(err_log_path)
@@ -540,11 +558,13 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
                 err_log_path, mode='w', delay=True)
 
         err_handler.setLevel(logging.INFO if verbose else logging.WARNING)
-        err_handler.setFormatter(
-            logging.Formatter('%(asctime)s %(name)s: %(message)s',
-                              datefmt='%y-%m-%d %H:%M:%S'))
+        err_handler.setFormatter(logging.Formatter(fmt, datefmt=datefmt))
+
+        async_handler = AsyncHandler(hass.loop, err_handler)
+        hass.data[core.DATA_ASYNCHANDLER] = async_handler
+
         logger = logging.getLogger('')
-        logger.addHandler(err_handler)
+        logger.addHandler(async_handler)
         logger.setLevel(logging.INFO)
 
     else:
@@ -592,7 +612,7 @@ def async_log_exception(ex, domain, config, hass):
         message += '{}.'.format(humanize_error(config, ex))
 
     domain_config = config.get(domain, config)
-    message += " (See {}:{}). ".format(
+    message += " (See {}, line {}). ".format(
         getattr(domain_config, '__config_file__', '?'),
         getattr(domain_config, '__line__', '?'))
 

homeassistant/components/__init__.py

@@ -12,14 +12,19 @@ import itertools as it
 import logging
 
 import homeassistant.core as ha
+import homeassistant.config as conf_util
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.service import extract_entity_ids
 from homeassistant.loader import get_component
 from homeassistant.const import (
-    ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE)
+    ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE,
+    SERVICE_HOMEASSISTANT_STOP, SERVICE_HOMEASSISTANT_RESTART,
+    RESTART_EXIT_CODE)
 
 _LOGGER = logging.getLogger(__name__)
 
 SERVICE_RELOAD_CORE_CONFIG = 'reload_core_config'
+SERVICE_CHECK_CONFIG = 'check_config'
 
 
 def is_on(hass, entity_id=None):
@@ -75,6 +80,21 @@ def toggle(hass, entity_id=None, **service_data):
     hass.services.call(ha.DOMAIN, SERVICE_TOGGLE, service_data)
 
 
+def stop(hass):
+    """Stop Home Assistant."""
+    hass.services.call(ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP)
+
+
+def restart(hass):
+    """Stop Home Assistant."""
+    hass.services.call(ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART)
+
+
+def check_config(hass):
+    """Check the config files."""
+    hass.services.call(ha.DOMAIN, SERVICE_CHECK_CONFIG)
+
+
 def reload_core_config(hass):
     """Reload the core config."""
     hass.services.call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
@@ -84,7 +104,7 @@ def reload_core_config(hass):
 def async_setup(hass, config):
     """Setup general services related to Home Assistant."""
     @asyncio.coroutine
-    def handle_turn_service(service):
+    def async_handle_turn_service(service):
         """Method to handle calls to homeassistant.turn_on/off."""
         entity_ids = extract_entity_ids(hass, service)
 
@@ -119,21 +139,40 @@ def async_setup(hass, config):
             tasks.append(hass.services.async_call(
                 domain, service.service, data, blocking))
 
-        yield from asyncio.gather(*tasks, loop=hass.loop)
+        yield from asyncio.wait(tasks, loop=hass.loop)
 
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_OFF, handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_OFF, async_handle_turn_service)
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_ON, handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_ON, async_handle_turn_service)
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_TOGGLE, handle_turn_service)
+        ha.DOMAIN, SERVICE_TOGGLE, async_handle_turn_service)
 
     @asyncio.coroutine
-    def handle_reload_config(call):
-        """Service handler for reloading core config."""
-        from homeassistant.exceptions import HomeAssistantError
-        from homeassistant import config as conf_util
+    def async_handle_core_service(call):
+        """Service handler for handling core services."""
+        if call.service == SERVICE_HOMEASSISTANT_STOP:
+            hass.async_add_job(hass.async_stop())
+            return
 
+        try:
+            yield from conf_util.async_check_ha_config_file(hass)
+        except HomeAssistantError:
+            return
+
+        if call.service == SERVICE_HOMEASSISTANT_RESTART:
+            hass.async_add_job(hass.async_stop(RESTART_EXIT_CODE))
+
+    hass.services.async_register(
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP, async_handle_core_service)
+    hass.services.async_register(
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART, async_handle_core_service)
+    hass.services.async_register(
+        ha.DOMAIN, SERVICE_CHECK_CONFIG, async_handle_core_service)
+
+    @asyncio.coroutine
+    def async_handle_reload_config(call):
+        """Service handler for reloading core config."""
         try:
             conf = yield from conf_util.async_hass_config_yaml(hass)
         except HomeAssistantError as err:
@@ -144,6 +183,6 @@ def async_setup(hass, config):
             hass, conf.get(ha.DOMAIN) or {})
 
     hass.services.async_register(
-        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, handle_reload_config)
+        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, async_handle_reload_config)
 
     return True

homeassistant/components/alarm_control_panel/__init__.py

@@ -4,6 +4,8 @@ Component to interface with an alarm control panel.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel/
 """
+import asyncio
+from datetime import timedelta
 import logging
 import os
 
@@ -19,7 +21,7 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 
 DOMAIN = 'alarm_control_panel'
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)
 ATTR_CHANGED_BY = 'changed_by'
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
@@ -42,36 +44,6 @@ ALARM_SERVICE_SCHEMA = vol.Schema({
 })
 
 
-def setup(hass, config):
-    """Track states and offer events for sensors."""
-    component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
-
-    component.setup(config)
-
-    def alarm_service_handler(service):
-        """Map services to methods on Alarm."""
-        target_alarms = component.extract_from_service(service)
-
-        code = service.data.get(ATTR_CODE)
-
-        method = SERVICE_TO_METHOD[service.service]
-
-        for alarm in target_alarms:
-            getattr(alarm, method)(code)
-            if alarm.should_poll:
-                alarm.update_ha_state(True)
-
-    descriptions = load_yaml_config_file(
-        os.path.join(os.path.dirname(__file__), 'services.yaml'))
-
-    for service in SERVICE_TO_METHOD:
-        hass.services.register(DOMAIN, service, alarm_service_handler,
-                               descriptions.get(service),
-                               schema=ALARM_SERVICE_SCHEMA)
-    return True
-
-
 def alarm_disarm(hass, code=None, entity_id=None):
     """Send the alarm the command for disarm."""
     data = {}
@@ -116,6 +88,53 @@ def alarm_trigger(hass, code=None, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_ALARM_TRIGGER, data)
 
 
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Track states and offer events for sensors."""
+    component = EntityComponent(
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
+
+    yield from component.async_setup(config)
+
+    @asyncio.coroutine
+    def async_alarm_service_handler(service):
+        """Map services to methods on Alarm."""
+        target_alarms = component.async_extract_from_service(service)
+
+        code = service.data.get(ATTR_CODE)
+
+        method = "async_{}".format(SERVICE_TO_METHOD[service.service])
+
+        for alarm in target_alarms:
+            yield from getattr(alarm, method)(code)
+
+        update_tasks = []
+        for alarm in target_alarms:
+            if not alarm.should_poll:
+                continue
+
+            update_coro = hass.loop.create_task(
+                alarm.async_update_ha_state(True))
+            if hasattr(alarm, 'async_update'):
+                update_tasks.append(update_coro)
+            else:
+                yield from update_coro
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml'))
+
+    for service in SERVICE_TO_METHOD:
+        hass.services.async_register(
+            DOMAIN, service, async_alarm_service_handler,
+            descriptions.get(service), schema=ALARM_SERVICE_SCHEMA)
+
+    return True
+
+
 # pylint: disable=no-self-use
 class AlarmControlPanel(Entity):
     """An abstract class for alarm control devices."""
@@ -134,18 +153,50 @@ class AlarmControlPanel(Entity):
         """Send disarm command."""
         raise NotImplementedError()
 
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.alarm_disarm, code)
+
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         raise NotImplementedError()
 
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.alarm_arm_home, code)
+
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         raise NotImplementedError()
 
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.alarm_arm_away, code)
+
     def alarm_trigger(self, code=None):
         """Send alarm trigger command."""
         raise NotImplementedError()
 
+    def async_alarm_trigger(self, code=None):
+        """Send alarm trigger command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.alarm_trigger, code)
+
     @property
     def state_attributes(self):
         """Return the state attributes."""

homeassistant/components/alarm_control_panel/alarmdotcom.py

@@ -39,7 +39,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     username = config.get(CONF_USERNAME)
     password = config.get(CONF_PASSWORD)
 
-    add_devices([AlarmDotCom(hass, name, code, username, password)])
+    add_devices([AlarmDotCom(hass, name, code, username, password)], True)
 
 
 class AlarmDotCom(alarm.AlarmControlPanel):
@@ -54,11 +54,11 @@ class AlarmDotCom(alarm.AlarmControlPanel):
         self._code = str(code) if code else None
         self._username = username
         self._password = password
+        self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """No polling needed."""
-        return True
+    def update(self):
+        """Fetch the latest state."""
+        self._state = self._alarm.state
 
     @property
     def name(self):
@@ -73,11 +73,11 @@ class AlarmDotCom(alarm.AlarmControlPanel):
     @property
     def state(self):
         """Return the state of the device."""
-        if self._alarm.state == 'Disarmed':
+        if self._state == 'Disarmed':
             return STATE_ALARM_DISARMED
-        elif self._alarm.state == 'Armed Stay':
+        elif self._state == 'Armed Stay':
             return STATE_ALARM_ARMED_HOME
-        elif self._alarm.state == 'Armed Away':
+        elif self._state == 'Armed Away':
             return STATE_ALARM_ARMED_AWAY
         else:
             return STATE_UNKNOWN

homeassistant/components/alarm_control_panel/concord232.py

@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.concord232/
 """
 import datetime
+from datetime import timedelta
 import logging
 
 import requests
@@ -25,7 +26,7 @@ DEFAULT_HOST = 'localhost'
 DEFAULT_NAME = 'CONCORD232'
 DEFAULT_PORT = 5007
 
-SCAN_INTERVAL = 1
+SCAN_INTERVAL = timedelta(seconds=1)
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
@@ -71,11 +72,6 @@ class Concord232Alarm(alarm.AlarmControlPanel):
         self._alarm.last_partition_update = datetime.datetime.now()
         self.update()
 
-    @property
-    def should_poll(self):
-        """Polling needed."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -126,7 +122,3 @@ class Concord232Alarm(alarm.AlarmControlPanel):
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         self._alarm.arm('auto')
-
-    def alarm_trigger(self, code=None):
-        """Alarm trigger command."""
-        raise NotImplementedError()

homeassistant/components/alarm_control_panel/envisalink.py

@@ -4,20 +4,45 @@ Support for Envisalink-based alarm control panels (Honeywell/DSC).
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.envisalink/
 """
+from os import path
 import logging
+import voluptuous as vol
 
 import homeassistant.components.alarm_control_panel as alarm
+import homeassistant.helpers.config_validation as cv
+from homeassistant.config import load_yaml_config_file
 from homeassistant.components.envisalink import (
     EVL_CONTROLLER, EnvisalinkDevice, PARTITION_SCHEMA, CONF_CODE, CONF_PANIC,
     CONF_PARTITIONNAME, SIGNAL_PARTITION_UPDATE, SIGNAL_KEYPAD_UPDATE)
 from homeassistant.const import (
     STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
-    STATE_UNKNOWN, STATE_ALARM_TRIGGERED)
+    STATE_UNKNOWN, STATE_ALARM_TRIGGERED, STATE_ALARM_PENDING, ATTR_ENTITY_ID)
 
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['envisalink']
 
+DEVICES = []
+
+SERVICE_ALARM_KEYPRESS = 'envisalink_alarm_keypress'
+ATTR_KEYPRESS = 'keypress'
+ALARM_KEYPRESS_SCHEMA = vol.Schema({
+    vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_KEYPRESS): cv.string
+})
+
+
+def alarm_keypress_handler(service):
+    """Map services to methods on Alarm."""
+    entity_ids = service.data.get(ATTR_ENTITY_ID)
+    keypress = service.data.get(ATTR_KEYPRESS)
+
+    _target_devices = [device for device in DEVICES
+                       if device.entity_id in entity_ids]
+
+    for device in _target_devices:
+        EnvisalinkAlarm.alarm_keypress(device, keypress)
+
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -35,8 +60,18 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             _panic_type,
             EVL_CONTROLLER.alarm_state['partition'][part_num],
             EVL_CONTROLLER)
-        add_devices([_device])
+        DEVICES.append(_device)
 
+    add_devices(DEVICES)
+
+    # Register Envisalink specific services
+    descriptions = load_yaml_config_file(
+        path.join(path.dirname(__file__), 'services.yaml'))
+
+    hass.services.register(alarm.DOMAIN, SERVICE_ALARM_KEYPRESS,
+                           alarm_keypress_handler,
+                           descriptions.get(SERVICE_ALARM_KEYPRESS),
+                           schema=ALARM_KEYPRESS_SCHEMA)
     return True
 
 
@@ -62,46 +97,68 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
     def _update_callback(self, partition):
         """Update HA state, if needed."""
         if partition is None or int(partition) == self._partition_number:
-            self.hass.async_add_job(self.update_ha_state)
+            self.hass.async_add_job(self.async_update_ha_state())
 
     @property
     def code_format(self):
-        """The characters if code is defined."""
-        return self._code
+        """Regex for code format or None if no code is required."""
+        if self._code:
+            return None
+        else:
+            return '^\\d{4,6}$'
 
     @property
     def state(self):
         """Return the state of the device."""
+        state = STATE_UNKNOWN
+
         if self._info['status']['alarm']:
-            return STATE_ALARM_TRIGGERED
+            state = STATE_ALARM_TRIGGERED
         elif self._info['status']['armed_away']:
-            return STATE_ALARM_ARMED_AWAY
+            state = STATE_ALARM_ARMED_AWAY
         elif self._info['status']['armed_stay']:
-            return STATE_ALARM_ARMED_HOME
+            state = STATE_ALARM_ARMED_HOME
+        elif self._info['status']['exit_delay']:
+            state = STATE_ALARM_PENDING
+        elif self._info['status']['entry_delay']:
+            state = STATE_ALARM_PENDING
         elif self._info['status']['alpha']:
-            return STATE_ALARM_DISARMED
-        else:
-            return STATE_UNKNOWN
+            state = STATE_ALARM_DISARMED
+        return state
 
     def alarm_disarm(self, code=None):
         """Send disarm command."""
-        if self._code:
-            EVL_CONTROLLER.disarm_partition(
-                str(code), self._partition_number)
+        if code:
+            EVL_CONTROLLER.disarm_partition(str(code),
+                                            self._partition_number)
+        else:
+            EVL_CONTROLLER.disarm_partition(str(self._code),
+                                            self._partition_number)
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
-        if self._code:
-            EVL_CONTROLLER.arm_stay_partition(
-                str(code), self._partition_number)
+        if code:
+            EVL_CONTROLLER.arm_stay_partition(str(code),
+                                              self._partition_number)
+        else:
+            EVL_CONTROLLER.arm_stay_partition(str(self._code),
+                                              self._partition_number)
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
-        if self._code:
-            EVL_CONTROLLER.arm_away_partition(
-                str(code), self._partition_number)
+        if code:
+            EVL_CONTROLLER.arm_away_partition(str(code),
+                                              self._partition_number)
+        else:
+            EVL_CONTROLLER.arm_away_partition(str(self._code),
+                                              self._partition_number)
 
     def alarm_trigger(self, code=None):
         """Alarm trigger command. Will be used to trigger a panic alarm."""
-        if self._code:
-            EVL_CONTROLLER.panic_alarm(self._panic_type)
+        EVL_CONTROLLER.panic_alarm(self._panic_type)
+
+    def alarm_keypress(self, keypress=None):
+        """Send custom keypress."""
+        if keypress:
+            EVL_CONTROLLER.keypresses_to_partition(self._partition_number,
+                                                   keypress)

homeassistant/components/alarm_control_panel/manual.py

@@ -116,7 +116,7 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_DISARMED
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
@@ -125,11 +125,11 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_ARMED_HOME
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._pending_time:
             track_point_in_time(
-                self._hass, self.update_ha_state,
+                self._hass, self.async_update_ha_state,
                 self._state_ts + self._pending_time)
 
     def alarm_arm_away(self, code=None):
@@ -139,11 +139,11 @@ class ManualAlarm(alarm.AlarmControlPanel):
 
         self._state = STATE_ALARM_ARMED_AWAY
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._pending_time:
             track_point_in_time(
-                self._hass, self.update_ha_state,
+                self._hass, self.async_update_ha_state,
                 self._state_ts + self._pending_time)
 
     def alarm_trigger(self, code=None):
@@ -151,15 +151,15 @@ class ManualAlarm(alarm.AlarmControlPanel):
         self._pre_trigger_state = self._state
         self._state = STATE_ALARM_TRIGGERED
         self._state_ts = dt_util.utcnow()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
         if self._trigger_time:
             track_point_in_time(
-                self._hass, self.update_ha_state,
+                self._hass, self.async_update_ha_state,
                 self._state_ts + self._pending_time)
 
             track_point_in_time(
-                self._hass, self.update_ha_state,
+                self._hass, self.async_update_ha_state,
                 self._state_ts + self._pending_time + self._trigger_time)
 
     def _validate_code(self, code, state):

homeassistant/components/alarm_control_panel/nx584.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
     STATE_UNKNOWN, CONF_NAME, CONF_HOST, CONF_PORT)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['pynx584==0.2']
+REQUIREMENTS = ['pynx584==0.4']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -62,11 +62,6 @@ class NX584Alarm(alarm.AlarmControlPanel):
         self._alarm.list_zones()
         self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """Polling needed."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -91,9 +86,11 @@ class NX584Alarm(alarm.AlarmControlPanel):
             _LOGGER.error('Unable to connect to %(host)s: %(reason)s',
                           dict(host=self._url, reason=ex))
             self._state = STATE_UNKNOWN
+            zones = []
         except IndexError:
             _LOGGER.error('nx584 reports no partitions')
             self._state = STATE_UNKNOWN
+            zones = []
 
         bypassed = False
         for zone in zones:
@@ -117,12 +114,8 @@ class NX584Alarm(alarm.AlarmControlPanel):
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
-        self._alarm.arm('home')
+        self._alarm.arm('stay')
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
-        self._alarm.arm('auto')
-
-    def alarm_trigger(self, code=None):
-        """Alarm trigger command."""
-        raise NotImplementedError()
+        self._alarm.arm('exit')

homeassistant/components/alarm_control_panel/services.yaml

@@ -41,3 +41,14 @@ alarm_trigger:
     code:
       description: An optional code to trigger the alarm control panel with
       example: 1234
+
+envisalink_alarm_keypress:
+  description: Send custom keypresses to the alarm
+
+  fields:
+    entity_id:
+      description: Name of the alarm control panel to trigger
+      example: 'alarm_control_panel.downstairs'
+    keypress:
+      description: 'String to send to the alarm panel (1-6 characters)'
+      example: '*71'

homeassistant/components/alarm_control_panel/simplisafe.py

@@ -61,11 +61,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
         else:
             self._state = STATE_UNKNOWN
 
-    @property
-    def should_poll(self):
-        """Poll the SimpliSafe API."""
-        return True
-
     @property
     def name(self):
         """Return the name of the device."""
@@ -104,7 +99,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('off')
         _LOGGER.info('SimpliSafe alarm disarming')
-        self.update()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
@@ -112,7 +106,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('home')
         _LOGGER.info('SimpliSafe alarm arming home')
-        self.update()
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
@@ -120,7 +113,6 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
             return
         self.simplisafe.set_state('away')
         _LOGGER.info('SimpliSafe alarm arming away')
-        self.update()
 
     def _validate_code(self, code, state):
         """Validate given code."""

homeassistant/components/alarm_control_panel/verisure.py

@@ -84,18 +84,15 @@ class VerisureAlarm(alarm.AlarmControlPanel):
         hub.my_pages.alarm.set(code, 'DISARMED')
         _LOGGER.info('verisure alarm disarming')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()
 
     def alarm_arm_home(self, code=None):
         """Send arm home command."""
         hub.my_pages.alarm.set(code, 'ARMED_HOME')
         _LOGGER.info('verisure alarm arming home')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()
 
     def alarm_arm_away(self, code=None):
         """Send arm away command."""
         hub.my_pages.alarm.set(code, 'ARMED_AWAY')
         _LOGGER.info('verisure alarm arming away')
         hub.my_pages.alarm.wait_while_pending()
-        self.update()

homeassistant/components/alarm_control_panel/wink.py

@@ -0,0 +1,75 @@
+"""
+Interfaces with Wink Cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.wink/
+"""
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.const import (STATE_UNKNOWN,
+                                 STATE_ALARM_DISARMED,
+                                 STATE_ALARM_ARMED_HOME,
+                                 STATE_ALARM_ARMED_AWAY)
+from homeassistant.components.wink import WinkDevice, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['wink']
+STATE_ALARM_PRIVACY = 'Private'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Wink platform."""
+    import pywink
+
+    for camera in pywink.get_cameras():
+        # get_cameras returns multiple device types.
+        # Only add those that aren't sensors.
+        try:
+            camera.capability()
+        except AttributeError:
+            _id = camera.object_id() + camera.name()
+            if _id not in hass.data[DOMAIN]['unique_ids']:
+                add_devices([WinkCameraDevice(camera, hass)])
+
+
+class WinkCameraDevice(WinkDevice, alarm.AlarmControlPanel):
+    """Representation a Wink camera alarm."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink alarm."""
+        super().__init__(wink, hass)
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        wink_state = self.wink.state()
+        if wink_state == "away":
+            state = STATE_ALARM_ARMED_AWAY
+        elif wink_state == "home":
+            state = STATE_ALARM_DISARMED
+        elif wink_state == "night":
+            state = STATE_ALARM_ARMED_HOME
+        else:
+            state = STATE_UNKNOWN
+        return state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self.wink.set_mode("home")
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self.wink.set_mode("night")
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self.wink.set_mode("away")
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'private': self.wink.private()
+        }

homeassistant/components/alert.py

@@ -0,0 +1,275 @@
+"""
+Support for repeating alerts when conditions are met.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alert/
+"""
+import asyncio
+from datetime import datetime, timedelta
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.core import callback
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (CONF_ENTITY_ID, STATE_IDLE, CONF_NAME,
+                                 CONF_STATE, STATE_ON, STATE_OFF,
+                                 SERVICE_TURN_ON, SERVICE_TURN_OFF,
+                                 SERVICE_TOGGLE, ATTR_ENTITY_ID)
+from homeassistant.helpers.entity import ToggleEntity
+from homeassistant.helpers import service, event
+from homeassistant.util.async import run_callback_threadsafe
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'alert'
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+CONF_CAN_ACK = 'can_acknowledge'
+CONF_NOTIFIERS = 'notifiers'
+CONF_REPEAT = 'repeat'
+CONF_SKIP_FIRST = 'skip_first'
+
+ALERT_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_STATE, default=STATE_ON): cv.string,
+    vol.Required(CONF_REPEAT): vol.All(cv.ensure_list, [vol.Coerce(float)]),
+    vol.Required(CONF_CAN_ACK, default=True): cv.boolean,
+    vol.Required(CONF_SKIP_FIRST, default=False): cv.boolean,
+    vol.Required(CONF_NOTIFIERS): cv.ensure_list})
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        cv.slug: ALERT_SCHEMA,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+ALERT_SERVICE_SCHEMA = vol.Schema({
+    vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
+})
+
+
+def is_on(hass, entity_id):
+    """Return if the alert is firing and not acknowledged."""
+    return hass.states.is_state(entity_id, STATE_ON)
+
+
+def turn_on(hass, entity_id):
+    """Reset the alert."""
+    run_callback_threadsafe(hass.loop, async_turn_on, hass, entity_id)
+
+
+@callback
+def async_turn_on(hass, entity_id):
+    """Async reset the alert."""
+    data = {ATTR_ENTITY_ID: entity_id}
+    hass.async_add_job(
+        hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))
+
+
+def turn_off(hass, entity_id):
+    """Acknowledge alert."""
+    run_callback_threadsafe(hass.loop, async_turn_off, hass, entity_id)
+
+
+@callback
+def async_turn_off(hass, entity_id):
+    """Async acknowledge the alert."""
+    data = {ATTR_ENTITY_ID: entity_id}
+    hass.async_add_job(
+        hass.services.async_call(DOMAIN, SERVICE_TURN_OFF, data))
+
+
+def toggle(hass, entity_id):
+    """Toggle acknowledgement of alert."""
+    run_callback_threadsafe(hass.loop, async_toggle, hass, entity_id)
+
+
+@callback
+def async_toggle(hass, entity_id):
+    """Async toggle acknowledgement of alert."""
+    data = {ATTR_ENTITY_ID: entity_id}
+    hass.async_add_job(
+        hass.services.async_call(DOMAIN, SERVICE_TOGGLE, data))
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Setup alert component."""
+    alerts = config.get(DOMAIN)
+    all_alerts = {}
+
+    @asyncio.coroutine
+    def async_handle_alert_service(service_call):
+        """Handle calls to alert services."""
+        alert_ids = service.extract_entity_ids(hass, service_call)
+
+        for alert_id in alert_ids:
+            alert = all_alerts[alert_id]
+            if service_call.service == SERVICE_TURN_ON:
+                yield from alert.async_turn_on()
+            elif service_call.service == SERVICE_TOGGLE:
+                yield from alert.async_toggle()
+            else:
+                yield from alert.async_turn_off()
+
+    # setup alerts
+    for entity_id, alert in alerts.items():
+        entity = Alert(hass, entity_id,
+                       alert[CONF_NAME], alert[CONF_ENTITY_ID],
+                       alert[CONF_STATE], alert[CONF_REPEAT],
+                       alert[CONF_SKIP_FIRST], alert[CONF_NOTIFIERS],
+                       alert[CONF_CAN_ACK])
+        all_alerts[entity.entity_id] = entity
+
+    # read descriptions
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml'))
+    descriptions = descriptions.get(DOMAIN, {})
+
+    # setup service calls
+    hass.services.async_register(
+        DOMAIN, SERVICE_TURN_OFF, async_handle_alert_service,
+        descriptions.get(SERVICE_TURN_OFF), schema=ALERT_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_TURN_ON, async_handle_alert_service,
+        descriptions.get(SERVICE_TURN_ON), schema=ALERT_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_TOGGLE, async_handle_alert_service,
+        descriptions.get(SERVICE_TOGGLE), schema=ALERT_SERVICE_SCHEMA)
+
+    tasks = [alert.async_update_ha_state() for alert in all_alerts.values()]
+    if tasks:
+        yield from asyncio.wait(tasks, loop=hass.loop)
+
+    return True
+
+
+class Alert(ToggleEntity):
+    """Representation of an alert."""
+
+    def __init__(self, hass, entity_id, name, watched_entity_id, state,
+                 repeat, skip_first, notifiers, can_ack):
+        """Initialize the alert."""
+        self.hass = hass
+        self._name = name
+        self._alert_state = state
+        self._skip_first = skip_first
+        self._notifiers = notifiers
+        self._can_ack = can_ack
+
+        self._delay = [timedelta(minutes=val) for val in repeat]
+        self._next_delay = 0
+
+        self._firing = False
+        self._ack = False
+        self._cancel = None
+        self.entity_id = ENTITY_ID_FORMAT.format(entity_id)
+
+        event.async_track_state_change(hass, watched_entity_id,
+                                       self.watched_entity_change)
+
+    @property
+    def name(self):
+        """Return the name of the alert."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """HASS need not poll these entities."""
+        return False
+
+    @property
+    def state(self):
+        """Return the alert status."""
+        if self._firing:
+            if self._ack:
+                return STATE_OFF
+            return STATE_ON
+        return STATE_IDLE
+
+    @property
+    def hidden(self):
+        """Hide the alert when it is not firing."""
+        return not self._can_ack or not self._firing
+
+    @asyncio.coroutine
+    def watched_entity_change(self, entity, from_state, to_state):
+        """Determine if the alert should start or stop."""
+        _LOGGER.debug('Watched entity (%s) has changed.', entity)
+        if to_state.state == self._alert_state and not self._firing:
+            yield from self.begin_alerting()
+        if to_state.state != self._alert_state and self._firing:
+            yield from self.end_alerting()
+
+    @asyncio.coroutine
+    def begin_alerting(self):
+        """Begin the alert procedures."""
+        _LOGGER.debug('Beginning Alert: %s', self._name)
+        self._ack = False
+        self._firing = True
+        self._next_delay = 0
+
+        if not self._skip_first:
+            yield from self._notify()
+        else:
+            yield from self._schedule_notify()
+
+        self.hass.async_add_job(self.async_update_ha_state)
+
+    @asyncio.coroutine
+    def end_alerting(self):
+        """End the alert procedures."""
+        _LOGGER.debug('Ending Alert: %s', self._name)
+        self._cancel()
+        self._ack = False
+        self._firing = False
+        self.hass.async_add_job(self.async_update_ha_state)
+
+    @asyncio.coroutine
+    def _schedule_notify(self):
+        """Schedule a notification."""
+        delay = self._delay[self._next_delay]
+        next_msg = datetime.now() + delay
+        self._cancel = \
+            event.async_track_point_in_time(self.hass, self._notify, next_msg)
+        self._next_delay = min(self._next_delay + 1, len(self._delay) - 1)
+
+    @asyncio.coroutine
+    def _notify(self, *args):
+        """Send the alert notification."""
+        if not self._firing:
+            return
+
+        if not self._ack:
+            _LOGGER.info('Alerting: %s', self._name)
+            for target in self._notifiers:
+                yield from self.hass.services.async_call(
+                    'notify', target, {'message': self._name})
+        yield from self._schedule_notify()
+
+    @asyncio.coroutine
+    def async_turn_on(self):
+        """Async Unacknowledge alert."""
+        _LOGGER.debug('Reset Alert: %s', self._name)
+        self._ack = False
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_turn_off(self):
+        """Async Acknowledge alert."""
+        _LOGGER.debug('Acknowledged Alert: %s', self._name)
+        self._ack = True
+        yield from self.async_update_ha_state()
+
+    @asyncio.coroutine
+    def async_toggle(self):
+        """Async toggle alert."""
+        if self._ack:
+            return self.async_turn_on()
+        return self.async_turn_off()

homeassistant/components/alexa.py

@@ -118,7 +118,7 @@ class AlexaIntentsView(HomeAssistantView):
 
     def __init__(self, hass, intents):
         """Initialize Alexa view."""
-        super().__init__(hass)
+        super().__init__()
 
         intents = copy.deepcopy(intents)
         template.attach(hass, intents)
@@ -150,7 +150,7 @@ class AlexaIntentsView(HomeAssistantView):
             return None
 
         intent = req.get('intent')
-        response = AlexaResponse(self.hass, intent)
+        response = AlexaResponse(request.app['hass'], intent)
 
         if req_type == 'LaunchRequest':
             response.add_speech(
@@ -203,11 +203,12 @@ class AlexaResponse(object):
         self.reprompt = None
         self.session_attributes = {}
         self.should_end_session = True
+        self.variables = {}
         if intent is not None and 'slots' in intent:
-            self.variables = {key: value['value'] for key, value
-                              in intent['slots'].items() if 'value' in value}
-        else:
-            self.variables = {}
+            for key, value in intent['slots'].items():
+                if 'value' in value:
+                    underscored_key = key.replace('.', '_')
+                    self.variables[underscored_key] = value['value']
 
     def add_card(self, card_type, title, content):
         """Add a card to the response."""
@@ -282,7 +283,7 @@ class AlexaFlashBriefingView(HomeAssistantView):
 
     def __init__(self, hass, flash_briefings):
         """Initialize Alexa view."""
-        super().__init__(hass)
+        super().__init__()
         self.flash_briefings = copy.deepcopy(flash_briefings)
         template.attach(hass, self.flash_briefings)
 

homeassistant/components/api.py

@@ -77,8 +77,10 @@ class APIEventStream(HomeAssistantView):
     @asyncio.coroutine
     def get(self, request):
         """Provide a streaming interface for the event bus."""
+        # pylint: disable=no-self-use
+        hass = request.app['hass']
         stop_obj = object()
-        to_write = asyncio.Queue(loop=self.hass.loop)
+        to_write = asyncio.Queue(loop=hass.loop)
 
         restrict = request.GET.get('restrict')
         if restrict:
@@ -106,7 +108,7 @@ class APIEventStream(HomeAssistantView):
         response.content_type = 'text/event-stream'
         yield from response.prepare(request)
 
-        unsub_stream = self.hass.bus.async_listen(MATCH_ALL, forward_events)
+        unsub_stream = hass.bus.async_listen(MATCH_ALL, forward_events)
 
         try:
             _LOGGER.debug('STREAM %s ATTACHED', id(stop_obj))
@@ -117,7 +119,7 @@ class APIEventStream(HomeAssistantView):
             while True:
                 try:
                     with async_timeout.timeout(STREAM_PING_INTERVAL,
-                                               loop=self.hass.loop):
+                                               loop=hass.loop):
                         payload = yield from to_write.get()
 
                     if payload is stop_obj:
@@ -131,6 +133,9 @@ class APIEventStream(HomeAssistantView):
                 except asyncio.TimeoutError:
                     yield from to_write.put(STREAM_PING_PAYLOAD)
 
+        except asyncio.CancelledError:
+            _LOGGER.debug('STREAM %s ABORT', id(stop_obj))
+
         finally:
             _LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
             unsub_stream()
@@ -145,7 +150,7 @@ class APIConfigView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get current configuration."""
-        return self.json(self.hass.config.as_dict())
+        return self.json(request.app['hass'].config.as_dict())
 
 
 class APIDiscoveryView(HomeAssistantView):
@@ -158,10 +163,11 @@ class APIDiscoveryView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get discovery info."""
-        needs_auth = self.hass.config.api.api_password is not None
+        hass = request.app['hass']
+        needs_auth = hass.config.api.api_password is not None
         return self.json({
-            'base_url': self.hass.config.api.base_url,
-            'location_name': self.hass.config.location_name,
+            'base_url': hass.config.api.base_url,
+            'location_name': hass.config.location_name,
             'requires_api_password': needs_auth,
             'version': __version__
         })
@@ -176,7 +182,7 @@ class APIStatesView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get current states."""
-        return self.json(self.hass.states.async_all())
+        return self.json(request.app['hass'].states.async_all())
 
 
 class APIEntityStateView(HomeAssistantView):
@@ -188,7 +194,7 @@ class APIEntityStateView(HomeAssistantView):
     @ha.callback
     def get(self, request, entity_id):
         """Retrieve state of entity."""
-        state = self.hass.states.get(entity_id)
+        state = request.app['hass'].states.get(entity_id)
         if state:
             return self.json(state)
         else:
@@ -197,6 +203,7 @@ class APIEntityStateView(HomeAssistantView):
     @asyncio.coroutine
     def post(self, request, entity_id):
         """Update state of entity."""
+        hass = request.app['hass']
         try:
             data = yield from request.json()
         except ValueError:
@@ -211,15 +218,14 @@ class APIEntityStateView(HomeAssistantView):
         attributes = data.get('attributes')
         force_update = data.get('force_update', False)
 
-        is_new_state = self.hass.states.get(entity_id) is None
+        is_new_state = hass.states.get(entity_id) is None
 
         # Write state
-        self.hass.states.async_set(entity_id, new_state, attributes,
-                                   force_update)
+        hass.states.async_set(entity_id, new_state, attributes, force_update)
 
         # Read the state back for our response
         status_code = HTTP_CREATED if is_new_state else 200
-        resp = self.json(self.hass.states.get(entity_id), status_code)
+        resp = self.json(hass.states.get(entity_id), status_code)
 
         resp.headers.add('Location', URL_API_STATES_ENTITY.format(entity_id))
 
@@ -228,7 +234,7 @@ class APIEntityStateView(HomeAssistantView):
     @ha.callback
     def delete(self, request, entity_id):
         """Remove entity."""
-        if self.hass.states.async_remove(entity_id):
+        if request.app['hass'].states.async_remove(entity_id):
             return self.json_message('Entity removed')
         else:
             return self.json_message('Entity not found', HTTP_NOT_FOUND)
@@ -243,7 +249,7 @@ class APIEventListenersView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get event listeners."""
-        return self.json(async_events_json(self.hass))
+        return self.json(async_events_json(request.app['hass']))
 
 
 class APIEventView(HomeAssistantView):
@@ -271,7 +277,8 @@ class APIEventView(HomeAssistantView):
                 if state:
                     event_data[key] = state
 
-        self.hass.bus.async_fire(event_type, event_data, ha.EventOrigin.remote)
+        request.app['hass'].bus.async_fire(event_type, event_data,
+                                           ha.EventOrigin.remote)
 
         return self.json_message("Event {} fired.".format(event_type))
 
@@ -285,7 +292,7 @@ class APIServicesView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get registered services."""
-        return self.json(async_services_json(self.hass))
+        return self.json(async_services_json(request.app['hass']))
 
 
 class APIDomainServicesView(HomeAssistantView):
@@ -300,12 +307,12 @@ class APIDomainServicesView(HomeAssistantView):
 
         Returns a list of changed states.
         """
+        hass = request.app['hass']
         body = yield from request.text()
         data = json.loads(body) if body else None
 
-        with AsyncTrackStates(self.hass) as changed_states:
-            yield from self.hass.services.async_call(domain, service, data,
-                                                     True)
+        with AsyncTrackStates(hass) as changed_states:
+            yield from hass.services.async_call(domain, service, data, True)
 
         return self.json(changed_states)
 
@@ -320,6 +327,7 @@ class APIEventForwardingView(HomeAssistantView):
     @asyncio.coroutine
     def post(self, request):
         """Setup an event forwarder."""
+        hass = request.app['hass']
         try:
             data = yield from request.json()
         except ValueError:
@@ -340,14 +348,14 @@ class APIEventForwardingView(HomeAssistantView):
 
         api = rem.API(host, api_password, port)
 
-        valid = yield from self.hass.loop.run_in_executor(
+        valid = yield from hass.loop.run_in_executor(
             None, api.validate_api)
         if not valid:
             return self.json_message("Unable to validate API.",
                                      HTTP_UNPROCESSABLE_ENTITY)
 
         if self.event_forwarder is None:
-            self.event_forwarder = rem.EventForwarder(self.hass)
+            self.event_forwarder = rem.EventForwarder(hass)
 
         self.event_forwarder.async_connect(api)
 
@@ -389,7 +397,7 @@ class APIComponentsView(HomeAssistantView):
     @ha.callback
     def get(self, request):
         """Get current loaded components."""
-        return self.json(self.hass.config.components)
+        return self.json(request.app['hass'].config.components)
 
 
 class APIErrorLogView(HomeAssistantView):
@@ -402,7 +410,7 @@ class APIErrorLogView(HomeAssistantView):
     def get(self, request):
         """Serve error log."""
         resp = yield from self.file(
-            request, self.hass.config.path(ERROR_LOG_FILENAME))
+            request, request.app['hass'].config.path(ERROR_LOG_FILENAME))
         return resp
 
 
@@ -417,7 +425,7 @@ class APITemplateView(HomeAssistantView):
         """Render a template."""
         try:
             data = yield from request.json()
-            tpl = template.Template(data['template'], self.hass)
+            tpl = template.Template(data['template'], request.app['hass'])
             return tpl.async_render(data.get('variables'))
         except (ValueError, TemplateError) as ex:
             return self.json_message('Error rendering template: {}'.format(ex),

homeassistant/components/apiai.py

@@ -0,0 +1,172 @@
+"""
+Support for API.AI webhook.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/apiai/
+"""
+import asyncio
+import copy
+import logging
+
+import voluptuous as vol
+
+from homeassistant.const import PROJECT_NAME, HTTP_BAD_REQUEST
+from homeassistant.helpers import template, script, config_validation as cv
+from homeassistant.components.http import HomeAssistantView
+
+_LOGGER = logging.getLogger(__name__)
+
+INTENTS_API_ENDPOINT = '/api/apiai'
+
+CONF_INTENTS = 'intents'
+CONF_SPEECH = 'speech'
+CONF_ACTION = 'action'
+CONF_ASYNC_ACTION = 'async_action'
+
+DEFAULT_CONF_ASYNC_ACTION = False
+
+DOMAIN = 'apiai'
+DEPENDENCIES = ['http']
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: {
+        CONF_INTENTS: {
+            cv.string: {
+                vol.Optional(CONF_SPEECH): cv.template,
+                vol.Optional(CONF_ACTION): cv.SCRIPT_SCHEMA,
+                vol.Optional(CONF_ASYNC_ACTION,
+                             default=DEFAULT_CONF_ASYNC_ACTION): cv.boolean
+            }
+        }
+    }
+}, extra=vol.ALLOW_EXTRA)
+
+
+def setup(hass, config):
+    """Activate API.AI component."""
+    intents = config[DOMAIN].get(CONF_INTENTS, {})
+
+    hass.http.register_view(ApiaiIntentsView(hass, intents))
+
+    return True
+
+
+class ApiaiIntentsView(HomeAssistantView):
+    """Handle API.AI requests."""
+
+    url = INTENTS_API_ENDPOINT
+    name = 'api:apiai'
+
+    def __init__(self, hass, intents):
+        """Initialize API.AI view."""
+        super().__init__()
+
+        self.hass = hass
+        intents = copy.deepcopy(intents)
+        template.attach(hass, intents)
+
+        for name, intent in intents.items():
+            if CONF_ACTION in intent:
+                intent[CONF_ACTION] = script.Script(
+                    hass, intent[CONF_ACTION], "Apiai intent {}".format(name))
+
+        self.intents = intents
+
+    @asyncio.coroutine
+    def post(self, request):
+        """Handle API.AI."""
+        data = yield from request.json()
+
+        _LOGGER.debug('Received Apiai request: %s', data)
+
+        req = data.get('result')
+
+        if req is None:
+            _LOGGER.error('Received invalid data from Apiai: %s', data)
+            return self.json_message('Expected result value not received',
+                                     HTTP_BAD_REQUEST)
+
+        action_incomplete = req['actionIncomplete']
+
+        if action_incomplete:
+            return None
+
+        # use intent to no mix HASS actions with this parameter
+        intent = req.get('action')
+        parameters = req.get('parameters')
+        # contexts = req.get('contexts')
+        response = ApiaiResponse(parameters)
+
+        # Default Welcome Intent
+        # Maybe is better to handle this in api.ai directly?
+        #
+        # if intent == 'input.welcome':
+        #     response.add_speech(
+        #     "Hello, and welcome to the future. How may I help?")
+        #     return self.json(response)
+
+        if intent == "":
+            _LOGGER.warning('Received intent with empty action')
+            response.add_speech(
+                "You have not defined an action in your api.ai intent.")
+            return self.json(response)
+
+        config = self.intents.get(intent)
+
+        if config is None:
+            _LOGGER.warning('Received unknown intent %s', intent)
+            response.add_speech(
+                "Intent '%s' is not yet configured within Home Assistant." %
+                intent)
+            return self.json(response)
+
+        speech = config.get(CONF_SPEECH)
+        action = config.get(CONF_ACTION)
+        async_action = config.get(CONF_ASYNC_ACTION)
+
+        if action is not None:
+            # API.AI expects a response in less than 5s
+            if async_action:
+                # Do not wait for the action to be executed.
+                # Needed if the action will take longer than 5s to execute
+                self.hass.async_add_job(action.async_run(response.parameters))
+            else:
+                # Wait for the action to be executed so we can use results to
+                # render the answer
+                yield from action.async_run(response.parameters)
+
+        # pylint: disable=unsubscriptable-object
+        if speech is not None:
+            response.add_speech(speech)
+
+        return self.json(response)
+
+
+class ApiaiResponse(object):
+    """Help generating the response for API.AI."""
+
+    def __init__(self, parameters):
+        """Initialize the response."""
+        self.speech = None
+        self.parameters = {}
+        # Parameter names replace '.' and '-' for '_'
+        for key, value in parameters.items():
+            underscored_key = key.replace('.', '_').replace('-', '_')
+            self.parameters[underscored_key] = value
+
+    def add_speech(self, text):
+        """Add speech to the response."""
+        assert self.speech is None
+
+        if isinstance(text, template.Template):
+            text = text.async_render(self.parameters)
+
+        self.speech = text
+
+    def as_dict(self):
+        """Return response in an API.AI valid dict."""
+        return {
+            'speech': self.speech,
+            'displayText': self.speech,
+            'source': PROJECT_NAME,
+        }

homeassistant/components/automation/__init__.py

@@ -66,6 +66,7 @@ def _platform_validator(config):
 
     return getattr(platform, 'TRIGGER_SCHEMA')(config)
 
+
 _TRIGGER_SCHEMA = vol.All(
     cv.ensure_list,
     [
@@ -165,7 +166,9 @@ def async_setup(hass, config):
         for entity in component.async_extract_from_service(service_call):
             tasks.append(entity.async_trigger(
                 service_call.data.get(ATTR_VARIABLES), True))
-        yield from asyncio.gather(*tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def turn_onoff_service_handler(service_call):
@@ -174,7 +177,9 @@ def async_setup(hass, config):
         method = 'async_{}'.format(service_call.service)
         for entity in component.async_extract_from_service(service_call):
             tasks.append(getattr(entity, method)())
-        yield from asyncio.gather(*tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def toggle_service_handler(service_call):
@@ -185,7 +190,9 @@ def async_setup(hass, config):
                 tasks.append(entity.async_turn_off())
             else:
                 tasks.append(entity.async_turn_on())
-        yield from asyncio.gather(*tasks, loop=hass.loop)
+
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
 
     @asyncio.coroutine
     def reload_service_handler(service_call):
@@ -348,8 +355,10 @@ def _async_process_config(hass, config, component):
                 tasks.append(entity.async_enable())
             entities.append(entity)
 
-    yield from asyncio.gather(*tasks, loop=hass.loop)
-    yield from component.async_add_entities(entities)
+    if tasks:
+        yield from asyncio.wait(tasks, loop=hass.loop)
+    if entities:
+        yield from component.async_add_entities(entities)
 
     return len(entities) > 0
 

homeassistant/components/automation/litejet.py

@@ -11,22 +11,34 @@ import voluptuous as vol
 from homeassistant.core import callback
 from homeassistant.const import CONF_PLATFORM
 import homeassistant.helpers.config_validation as cv
+import homeassistant.util.dt as dt_util
+from homeassistant.helpers.event import track_point_in_utc_time
 
 DEPENDENCIES = ['litejet']
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_NUMBER = 'number'
+CONF_HELD_MORE_THAN = 'held_more_than'
+CONF_HELD_LESS_THAN = 'held_less_than'
 
 TRIGGER_SCHEMA = vol.Schema({
     vol.Required(CONF_PLATFORM): 'litejet',
-    vol.Required(CONF_NUMBER): cv.positive_int
+    vol.Required(CONF_NUMBER): cv.positive_int,
+    vol.Optional(CONF_HELD_MORE_THAN):
+        vol.All(cv.time_period, cv.positive_timedelta),
+    vol.Optional(CONF_HELD_LESS_THAN):
+        vol.All(cv.time_period, cv.positive_timedelta)
 })
 
 
 def async_trigger(hass, config, action):
     """Listen for events based on configuration."""
     number = config.get(CONF_NUMBER)
+    held_more_than = config.get(CONF_HELD_MORE_THAN)
+    held_less_than = config.get(CONF_HELD_LESS_THAN)
+    pressed_time = None
+    cancel_pressed_more_than = None
 
     @callback
     def call_action():
@@ -34,8 +46,53 @@ def async_trigger(hass, config, action):
         hass.async_run_job(action, {
             'trigger': {
                 CONF_PLATFORM: 'litejet',
-                CONF_NUMBER: number
+                CONF_NUMBER: number,
+                CONF_HELD_MORE_THAN: held_more_than,
+                CONF_HELD_LESS_THAN: held_less_than
             },
         })
 
-    hass.data['litejet_system'].on_switch_released(number, call_action)
+    # held_more_than and held_less_than: trigger on released (if in time range)
+    # held_more_than: trigger after pressed with calculation
+    # held_less_than: trigger on released with calculation
+    # neither: trigger on pressed
+
+    @callback
+    def pressed_more_than_satisfied(now):
+        """Handle the LiteJet's switch's button pressed >= held_more_than."""
+        call_action()
+
+    def pressed():
+        """Handle the press of the LiteJet switch's button."""
+        nonlocal cancel_pressed_more_than, pressed_time
+        nonlocal held_less_than, held_more_than
+        pressed_time = dt_util.utcnow()
+        if held_more_than is None and held_less_than is None:
+            call_action()
+        if held_more_than is not None and held_less_than is None:
+            cancel_pressed_more_than = track_point_in_utc_time(
+                hass,
+                pressed_more_than_satisfied,
+                dt_util.utcnow() + held_more_than)
+
+    def released():
+        """Handle the release of the LiteJet switch's button."""
+        nonlocal cancel_pressed_more_than, pressed_time
+        nonlocal held_less_than, held_more_than
+        # pylint: disable=not-callable
+        if cancel_pressed_more_than is not None:
+            cancel_pressed_more_than()
+            cancel_pressed_more_than = None
+        held_time = dt_util.utcnow() - pressed_time
+        if held_less_than is not None and held_time < held_less_than:
+            if held_more_than is None or held_time > held_more_than:
+                call_action()
+
+    hass.data['litejet_system'].on_switch_pressed(number, pressed)
+    hass.data['litejet_system'].on_switch_released(number, released)
+
+    def async_remove():
+        """Remove all subscriptions used for this trigger."""
+        return
+
+    return async_remove

homeassistant/components/automation/mqtt.py

@@ -4,6 +4,8 @@ Offer MQTT listening automation rules.
 For more details about this automation rule, please refer to the documentation
 at https://home-assistant.io/components/automation/#mqtt-trigger
 """
+import json
+
 import voluptuous as vol
 
 from homeassistant.core import callback
@@ -31,13 +33,20 @@ def async_trigger(hass, config, action):
     def mqtt_automation_listener(msg_topic, msg_payload, qos):
         """Listen for MQTT messages."""
         if payload is None or payload == msg_payload:
+            data = {
+                'platform': 'mqtt',
+                'topic': msg_topic,
+                'payload': msg_payload,
+                'qos': qos,
+            }
+
+            try:
+                data['payload_json'] = json.loads(msg_payload)
+            except ValueError:
+                pass
+
             hass.async_run_job(action, {
-                'trigger': {
-                    'platform': 'mqtt',
-                    'topic': msg_topic,
-                    'payload': msg_payload,
-                    'qos': qos,
-                }
+                'trigger': data
             })
 
     return mqtt.async_subscribe(hass, topic, mqtt_automation_listener)

homeassistant/components/automation/state.py

@@ -64,10 +64,19 @@ def async_trigger(hass, config, action):
             call_action()
             return
 
+        @callback
+        def clear_listener():
+            """Clear all unsub listener."""
+            nonlocal async_remove_state_for_cancel
+            nonlocal async_remove_state_for_listener
+            async_remove_state_for_listener = None
+            async_remove_state_for_cancel = None
+
         @callback
         def state_for_listener(now):
             """Fire on state changes after a delay and calls action."""
             async_remove_state_for_cancel()
+            clear_listener()
             call_action()
 
         @callback
@@ -77,6 +86,7 @@ def async_trigger(hass, config, action):
                 return
             async_remove_state_for_listener()
             async_remove_state_for_cancel()
+            clear_listener()
 
         async_remove_state_for_listener = async_track_point_in_utc_time(
             hass, state_for_listener, dt_util.utcnow() + time_delta)

homeassistant/components/bbb_gpio.py

@@ -0,0 +1,74 @@
+"""
+Support for controlling GPIO pins of a Beaglebone Black.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/bbb_gpio/
+"""
+import logging
+
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP)
+
+REQUIREMENTS = ['Adafruit_BBIO==1.0.0']
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'bbb_gpio'
+
+
+# pylint: disable=no-member
+def setup(hass, config):
+    """Set up the BeagleBone Black GPIO component."""
+    # pylint: disable=import-error
+    import Adafruit_BBIO.GPIO as GPIO
+
+    def cleanup_gpio(event):
+        """Stuff to do before stopping."""
+        GPIO.cleanup()
+
+    def prepare_gpio(event):
+        """Stuff to do when home assistant starts."""
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, cleanup_gpio)
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, prepare_gpio)
+    return True
+
+
+# noqa: F821
+
+def setup_output(pin):
+    """Setup a GPIO as output."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.setup(pin, GPIO.OUT)
+
+
+def setup_input(pin, pull_mode):
+    """Setup a GPIO as input."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.setup(pin, GPIO.IN,                            # noqa: F821
+               GPIO.PUD_DOWN if pull_mode == 'DOWN'     # noqa: F821
+               else GPIO.PUD_UP)                        # noqa: F821
+
+
+def write_output(pin, value):
+    """Write a value to a GPIO."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.output(pin, value)
+
+
+def read_input(pin):
+    """Read a value from a GPIO."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    return GPIO.input(pin) is GPIO.HIGH
+
+
+def edge_detect(pin, event_callback, bounce):
+    """Add detection for RISING and FALLING events."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.add_event_detect(
+        pin, GPIO.BOTH, callback=event_callback, bouncetime=bounce)

homeassistant/components/binary_sensor/__init__.py

@@ -4,6 +4,8 @@ Component to interface with binary sensors.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor/
 """
+import asyncio
+from datetime import timedelta
 import logging
 
 import voluptuous as vol
@@ -14,7 +16,7 @@ from homeassistant.const import (STATE_ON, STATE_OFF)
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 
 DOMAIN = 'binary_sensor'
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)
 
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 SENSOR_CLASSES = [
@@ -39,13 +41,13 @@ SENSOR_CLASSES = [
 SENSOR_CLASSES_SCHEMA = vol.All(vol.Lower, vol.In(SENSOR_CLASSES))
 
 
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Track states and offer events for binary sensors."""
     component = EntityComponent(
         logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
 
-    component.setup(config)
-
+    yield from component.async_setup(config)
     return True
 
 

homeassistant/components/binary_sensor/arest.py

@@ -30,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the aREST binary sensor."""
+    """Set up the aREST binary sensor."""
     resource = config.get(CONF_RESOURCE)
     pin = config.get(CONF_PIN)
     sensor_class = config.get(CONF_SENSOR_CLASS)
@@ -38,13 +38,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     try:
         response = requests.get(resource, timeout=10).json()
     except requests.exceptions.MissingSchema:
-        _LOGGER.error('Missing resource or schema in configuration. '
-                      'Add http:// to your URL.')
+        _LOGGER.error("Missing resource or schema in configuration. "
+                      "Add http:// to your URL")
         return False
     except requests.exceptions.ConnectionError:
-        _LOGGER.error('No route to device at %s. '
-                      'Please check the IP address in the configuration file.',
-                      resource)
+        _LOGGER.error("No route to device at %s", resource)
         return False
 
     arest = ArestData(resource, pin)
@@ -67,10 +65,10 @@ class ArestBinarySensor(BinarySensorDevice):
         self.update()
 
         if self._pin is not None:
-            request = requests.get('{}/mode/{}/i'.format
-                                   (self._resource, self._pin), timeout=10)
+            request = requests.get(
+                '{}/mode/{}/i'.format(self._resource, self._pin), timeout=10)
             if request.status_code is not 200:
-                _LOGGER.error("Can't set mode. Is device offline?")
+                _LOGGER.error("Can't set mode of %s", self._resource)
 
     @property
     def name(self):
@@ -109,5 +107,4 @@ class ArestData(object):
                 self._resource, self._pin), timeout=10)
             self.data = {'state': response.json()['return_value']}
         except requests.exceptions.ConnectionError:
-            _LOGGER.error("No route to device '%s'. Is device offline?",
-                          self._resource)
+            _LOGGER.error("No route to device '%s'", self._resource)

homeassistant/components/binary_sensor/bbb_gpio.py

@@ -0,0 +1,89 @@
+"""
+Support for binary sensor using Beaglebone Black GPIO.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.bbb_gpio/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.components.bbb_gpio as bbb_gpio
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (DEVICE_DEFAULT_NAME, CONF_NAME)
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['bbb_gpio']
+
+CONF_PINS = 'pins'
+CONF_BOUNCETIME = 'bouncetime'
+CONF_INVERT_LOGIC = 'invert_logic'
+CONF_PULL_MODE = 'pull_mode'
+
+DEFAULT_BOUNCETIME = 50
+DEFAULT_INVERT_LOGIC = False
+DEFAULT_PULL_MODE = 'UP'
+
+PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Optional(CONF_BOUNCETIME, default=DEFAULT_BOUNCETIME): cv.positive_int,
+    vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean,
+    vol.Optional(CONF_PULL_MODE, default=DEFAULT_PULL_MODE):
+        vol.In(['UP', 'DOWN'])
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PINS, default={}):
+        vol.Schema({cv.string: PIN_SCHEMA}),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Beaglebone Black GPIO devices."""
+    pins = config.get(CONF_PINS)
+
+    binary_sensors = []
+
+    for pin, params in pins.items():
+        binary_sensors.append(BBBGPIOBinarySensor(pin, params))
+    add_devices(binary_sensors)
+
+
+class BBBGPIOBinarySensor(BinarySensorDevice):
+    """Represent a binary sensor that uses Beaglebone Black GPIO."""
+
+    def __init__(self, pin, params):
+        """Initialize the Beaglebone Black binary sensor."""
+        self._pin = pin
+        self._name = params.get(CONF_NAME) or DEVICE_DEFAULT_NAME
+        self._bouncetime = params.get(CONF_BOUNCETIME)
+        self._pull_mode = params.get(CONF_PULL_MODE)
+        self._invert_logic = params.get(CONF_INVERT_LOGIC)
+
+        bbb_gpio.setup_input(self._pin, self._pull_mode)
+        self._state = bbb_gpio.read_input(self._pin)
+
+        def read_gpio(pin):
+            """Read state from GPIO."""
+            self._state = bbb_gpio.read_input(self._pin)
+            self.schedule_update_ha_state()
+
+        bbb_gpio.edge_detect(self._pin, read_gpio, self._bouncetime)
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the entity."""
+        return self._state != self._invert_logic

homeassistant/components/binary_sensor/command_line.py

@@ -4,8 +4,8 @@ Support for custom shell commands to retrieve values.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.command_line/
 """
-import logging
 from datetime import timedelta
+import logging
 
 import voluptuous as vol
 
@@ -23,7 +23,7 @@ DEFAULT_NAME = 'Binary Command Sensor'
 DEFAULT_PAYLOAD_ON = 'ON'
 DEFAULT_PAYLOAD_OFF = 'OFF'
 
-MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+SCAN_INTERVAL = timedelta(seconds=60)
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_COMMAND): cv.string,

homeassistant/components/binary_sensor/concord232.py

@@ -27,7 +27,7 @@ DEFAULT_NAME = 'Alarm'
 DEFAULT_PORT = '5007'
 DEFAULT_SSL = False
 
-SCAN_INTERVAL = 1
+SCAN_INTERVAL = datetime.timedelta(seconds=1)
 
 ZONE_TYPES_SCHEMA = vol.Schema({
     cv.positive_int: vol.In(SENSOR_CLASSES),

homeassistant/components/binary_sensor/digital_ocean.py

@@ -29,7 +29,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Digital Ocean droplet sensor."""
+    """Set up the Digital Ocean droplet sensor."""
     digital_ocean = get_component('digital_ocean')
     droplets = config.get(CONF_DROPLETS)
 
@@ -68,7 +68,7 @@ class DigitalOceanBinarySensor(BinarySensorDevice):
         return DEFAULT_SENSOR_CLASS
 
     @property
-    def state_attributes(self):
+    def device_state_attributes(self):
         """Return the state attributes of the Digital Ocean droplet."""
         return {
             ATTR_CREATED_AT: self.data.created_at,

homeassistant/components/binary_sensor/enocean.py

@@ -20,7 +20,7 @@ DEPENDENCIES = ['enocean']
 DEFAULT_NAME = 'EnOcean binary sensor'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ID): cv.string,
+    vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_SENSOR_CLASS, default=None): SENSOR_CLASSES_SCHEMA,
 })

homeassistant/components/binary_sensor/ffmpeg.py

@@ -1,224 +0,0 @@
-"""
-Provides a binary sensor which is a collection of ffmpeg tools.
-
-For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/binary_sensor.ffmpeg/
-"""
-import logging
-from os import path
-
-import voluptuous as vol
-
-import homeassistant.helpers.config_validation as cv
-from homeassistant.components.binary_sensor import (
-    BinarySensorDevice, PLATFORM_SCHEMA, DOMAIN)
-from homeassistant.components.ffmpeg import (
-    get_binary, run_test, CONF_INPUT, CONF_OUTPUT, CONF_EXTRA_ARGUMENTS)
-from homeassistant.config import load_yaml_config_file
-from homeassistant.const import (EVENT_HOMEASSISTANT_STOP, CONF_NAME,
-                                 ATTR_ENTITY_ID)
-
-DEPENDENCIES = ['ffmpeg']
-
-_LOGGER = logging.getLogger(__name__)
-
-SERVICE_RESTART = 'ffmpeg_restart'
-
-FFMPEG_SENSOR_NOISE = 'noise'
-FFMPEG_SENSOR_MOTION = 'motion'
-
-MAP_FFMPEG_BIN = [
-    FFMPEG_SENSOR_NOISE,
-    FFMPEG_SENSOR_MOTION
-]
-
-CONF_TOOL = 'tool'
-CONF_PEAK = 'peak'
-CONF_DURATION = 'duration'
-CONF_RESET = 'reset'
-CONF_CHANGES = 'changes'
-CONF_REPEAT = 'repeat'
-CONF_REPEAT_TIME = 'repeat_time'
-
-DEFAULT_NAME = 'FFmpeg'
-
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_TOOL): vol.In(MAP_FFMPEG_BIN),
-    vol.Required(CONF_INPUT): cv.string,
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_EXTRA_ARGUMENTS): cv.string,
-    vol.Optional(CONF_OUTPUT): cv.string,
-    vol.Optional(CONF_PEAK, default=-30): vol.Coerce(int),
-    vol.Optional(CONF_DURATION, default=1):
-        vol.All(vol.Coerce(int), vol.Range(min=1)),
-    vol.Optional(CONF_RESET, default=10):
-        vol.All(vol.Coerce(int), vol.Range(min=1)),
-    vol.Optional(CONF_CHANGES, default=10):
-        vol.All(vol.Coerce(float), vol.Range(min=0, max=99)),
-    vol.Optional(CONF_REPEAT, default=0):
-        vol.All(vol.Coerce(int), vol.Range(min=0)),
-    vol.Optional(CONF_REPEAT_TIME, default=0):
-        vol.All(vol.Coerce(int), vol.Range(min=0)),
-})
-
-SERVICE_RESTART_SCHEMA = vol.Schema({
-    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-})
-
-
-def restart(hass, entity_id=None):
-    """Restart a ffmpeg process on entity."""
-    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
-    hass.services.call(DOMAIN, SERVICE_RESTART, data)
-
-
-# list of all ffmpeg sensors
-DEVICES = []
-
-
-def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Create the binary sensor."""
-    from haffmpeg import SensorNoise, SensorMotion
-
-    # check source
-    if not run_test(hass, config.get(CONF_INPUT)):
-        return
-
-    # generate sensor object
-    if config.get(CONF_TOOL) == FFMPEG_SENSOR_NOISE:
-        entity = FFmpegNoise(SensorNoise, config)
-    else:
-        entity = FFmpegMotion(SensorMotion, config)
-
-    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, entity.shutdown_ffmpeg)
-
-    # add to system
-    add_entities([entity])
-    DEVICES.append(entity)
-
-    # exists service?
-    if hass.services.has_service(DOMAIN, SERVICE_RESTART):
-        return
-
-    descriptions = load_yaml_config_file(
-        path.join(path.dirname(__file__), 'services.yaml'))
-
-    # register service
-    def _service_handle_restart(service):
-        """Handle service binary_sensor.ffmpeg_restart."""
-        entity_ids = service.data.get('entity_id')
-
-        if entity_ids:
-            _devices = [device for device in DEVICES
-                        if device.entity_id in entity_ids]
-        else:
-            _devices = DEVICES
-
-        for device in _devices:
-            device.restart_ffmpeg()
-
-    hass.services.register(DOMAIN, SERVICE_RESTART,
-                           _service_handle_restart,
-                           descriptions.get(SERVICE_RESTART),
-                           schema=SERVICE_RESTART_SCHEMA)
-
-
-class FFmpegBinarySensor(BinarySensorDevice):
-    """A binary sensor which use ffmpeg for noise detection."""
-
-    def __init__(self, ffobj, config):
-        """Constructor for binary sensor noise detection."""
-        self._state = False
-        self._config = config
-        self._name = config.get(CONF_NAME)
-        self._ffmpeg = ffobj(get_binary(), self._callback)
-
-        self._start_ffmpeg(config)
-
-    def _callback(self, state):
-        """HA-FFmpeg callback for noise detection."""
-        self._state = state
-        self.update_ha_state()
-
-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
-        raise NotImplementedError
-
-    def shutdown_ffmpeg(self, event):
-        """For STOP event to shutdown ffmpeg."""
-        self._ffmpeg.close()
-
-    def restart_ffmpeg(self):
-        """Restart ffmpeg with new config."""
-        self._ffmpeg.close()
-        self._start_ffmpeg(self._config)
-
-    @property
-    def is_on(self):
-        """True if the binary sensor is on."""
-        return self._state
-
-    @property
-    def should_poll(self):
-        """Return True if entity has to be polled for state."""
-        return False
-
-    @property
-    def name(self):
-        """Return the name of the entity."""
-        return self._name
-
-    @property
-    def available(self):
-        """Return True if entity is available."""
-        return self._ffmpeg.is_running
-
-
-class FFmpegNoise(FFmpegBinarySensor):
-    """A binary sensor which use ffmpeg for noise detection."""
-
-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
-        # init config
-        self._ffmpeg.set_options(
-            time_duration=config.get(CONF_DURATION),
-            time_reset=config.get(CONF_RESET),
-            peak=config.get(CONF_PEAK),
-        )
-
-        # run
-        self._ffmpeg.open_sensor(
-            input_source=config.get(CONF_INPUT),
-            output_dest=config.get(CONF_OUTPUT),
-            extra_cmd=config.get(CONF_EXTRA_ARGUMENTS),
-        )
-
-    @property
-    def sensor_class(self):
-        """Return the class of this sensor, from SENSOR_CLASSES."""
-        return "sound"
-
-
-class FFmpegMotion(FFmpegBinarySensor):
-    """A binary sensor which use ffmpeg for noise detection."""
-
-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
-        # init config
-        self._ffmpeg.set_options(
-            time_reset=config.get(CONF_RESET),
-            time_repeat=config.get(CONF_REPEAT_TIME),
-            repeat=config.get(CONF_REPEAT),
-            changes=config.get(CONF_CHANGES),
-        )
-
-        # run
-        self._ffmpeg.open_sensor(
-            input_source=config.get(CONF_INPUT),
-            extra_cmd=config.get(CONF_EXTRA_ARGUMENTS),
-        )
-
-    @property
-    def sensor_class(self):
-        """Return the class of this sensor, from SENSOR_CLASSES."""
-        return "motion"

homeassistant/components/binary_sensor/ffmpeg_motion.py

@@ -0,0 +1,127 @@
+"""
+Provides a binary sensor which is a collection of ffmpeg tools.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.ffmpeg_motion/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.ffmpeg import (
+    FFmpegBase, DATA_FFMPEG, CONF_INPUT, CONF_EXTRA_ARGUMENTS,
+    CONF_INITIAL_STATE)
+from homeassistant.const import CONF_NAME
+
+DEPENDENCIES = ['ffmpeg']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_RESET = 'reset'
+CONF_CHANGES = 'changes'
+CONF_REPEAT = 'repeat'
+CONF_REPEAT_TIME = 'repeat_time'
+
+DEFAULT_NAME = 'FFmpeg Motion'
+DEFAULT_INIT_STATE = True
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_INPUT): cv.string,
+    vol.Optional(CONF_INITIAL_STATE, default=DEFAULT_INIT_STATE): cv.boolean,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_EXTRA_ARGUMENTS): cv.string,
+    vol.Optional(CONF_RESET, default=10):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Optional(CONF_CHANGES, default=10):
+        vol.All(vol.Coerce(float), vol.Range(min=0, max=99)),
+    vol.Inclusive(CONF_REPEAT, 'repeat'):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Inclusive(CONF_REPEAT_TIME, 'repeat'):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Create the binary sensor."""
+    manager = hass.data[DATA_FFMPEG]
+
+    # check source
+    if not manager.async_run_test(config.get(CONF_INPUT)):
+        return
+
+    # generate sensor object
+    entity = FFmpegMotion(hass, manager, config)
+
+    # add to system
+    manager.async_register_device(entity)
+    yield from async_add_devices([entity])
+
+
+class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
+    """A binary sensor which use ffmpeg for noise detection."""
+
+    def __init__(self, hass, config):
+        """Constructor for binary sensor noise detection."""
+        super().__init__(config.get(CONF_INITIAL_STATE))
+
+        self._state = False
+        self._config = config
+        self._name = config.get(CONF_NAME)
+
+    @callback
+    def _async_callback(self, state):
+        """HA-FFmpeg callback for noise detection."""
+        self._state = state
+        self.hass.async_add_job(self.async_update_ha_state())
+
+    @property
+    def is_on(self):
+        """True if the binary sensor is on."""
+        return self._state
+
+    @property
+    def name(self):
+        """Return the name of the entity."""
+        return self._name
+
+
+class FFmpegMotion(FFmpegBinarySensor):
+    """A binary sensor which use ffmpeg for noise detection."""
+
+    def __init__(self, hass, manager, config):
+        """Initialize ffmpeg motion binary sensor."""
+        from haffmpeg import SensorMotion
+
+        super().__init__(hass, config)
+        self.ffmpeg = SensorMotion(
+            manager.binary, hass.loop, self._async_callback)
+
+    def async_start_ffmpeg(self):
+        """Start a FFmpeg instance.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        # init config
+        self.ffmpeg.set_options(
+            time_reset=self._config.get(CONF_RESET),
+            time_repeat=self._config.get(CONF_REPEAT_TIME, 0),
+            repeat=self._config.get(CONF_REPEAT, 0),
+            changes=self._config.get(CONF_CHANGES),
+        )
+
+        # run
+        return self.ffmpeg.open_sensor(
+            input_source=self._config.get(CONF_INPUT),
+            extra_cmd=self._config.get(CONF_EXTRA_ARGUMENTS),
+        )
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return "motion"

homeassistant/components/binary_sensor/ffmpeg_noise.py

@@ -0,0 +1,96 @@
+"""
+Provides a binary sensor which is a collection of ffmpeg tools.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.ffmpeg_noise/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA
+from homeassistant.components.binary_sensor.ffmpeg_motion import (
+    FFmpegBinarySensor)
+from homeassistant.components.ffmpeg import (
+    DATA_FFMPEG, CONF_INPUT, CONF_OUTPUT, CONF_EXTRA_ARGUMENTS,
+    CONF_INITIAL_STATE)
+from homeassistant.const import CONF_NAME
+
+DEPENDENCIES = ['ffmpeg']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_PEAK = 'peak'
+CONF_DURATION = 'duration'
+CONF_RESET = 'reset'
+
+DEFAULT_NAME = 'FFmpeg Noise'
+DEFAULT_INIT_STATE = True
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_INPUT): cv.string,
+    vol.Optional(CONF_INITIAL_STATE, default=DEFAULT_INIT_STATE): cv.boolean,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_EXTRA_ARGUMENTS): cv.string,
+    vol.Optional(CONF_OUTPUT): cv.string,
+    vol.Optional(CONF_PEAK, default=-30): vol.Coerce(int),
+    vol.Optional(CONF_DURATION, default=1):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+    vol.Optional(CONF_RESET, default=10):
+        vol.All(vol.Coerce(int), vol.Range(min=1)),
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Create the binary sensor."""
+    manager = hass.data[DATA_FFMPEG]
+
+    # check source
+    if not manager.async_run_test(config.get(CONF_INPUT)):
+        return
+
+    # generate sensor object
+    entity = FFmpegNoise(hass, manager, config)
+
+    # add to system
+    manager.async_register_device(entity)
+    yield from async_add_devices([entity])
+
+
+class FFmpegNoise(FFmpegBinarySensor):
+    """A binary sensor which use ffmpeg for noise detection."""
+
+    def __init__(self, hass, manager, config):
+        """Initialize ffmpeg noise binary sensor."""
+        from haffmpeg import SensorNoise
+
+        super().__init__(hass, config)
+        self.ffmpeg = SensorNoise(
+            manager.binary, hass.loop, self._async_callback)
+
+    def async_start_ffmpeg(self):
+        """Start a FFmpeg instance.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        # init config
+        self.ffmpeg.set_options(
+            time_duration=self._config.get(CONF_DURATION),
+            time_reset=self._config.get(CONF_RESET),
+            peak=self._config.get(CONF_PEAK),
+        )
+
+        # run
+        return self.ffmpeg.open_sensor(
+            input_source=self._config.get(CONF_INPUT),
+            output_dest=self._config.get(CONF_OUTPUT),
+            extra_cmd=self._config.get(CONF_EXTRA_ARGUMENTS),
+        )
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return "sound"

homeassistant/components/binary_sensor/flic.py

@@ -0,0 +1,241 @@
+"""Contains functionality to use flic buttons as a binary sensor."""
+import logging
+import threading
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    CONF_HOST, CONF_PORT, CONF_DISCOVERY, CONF_TIMEOUT,
+    EVENT_HOMEASSISTANT_STOP)
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+
+
+REQUIREMENTS = ['https://github.com/soldag/pyflic/archive/0.4.zip#pyflic==0.4']
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 3
+
+CLICK_TYPE_SINGLE = "single"
+CLICK_TYPE_DOUBLE = "double"
+CLICK_TYPE_HOLD = "hold"
+CLICK_TYPES = [CLICK_TYPE_SINGLE, CLICK_TYPE_DOUBLE, CLICK_TYPE_HOLD]
+
+CONF_IGNORED_CLICK_TYPES = "ignored_click_types"
+
+EVENT_NAME = "flic_click"
+EVENT_DATA_NAME = "button_name"
+EVENT_DATA_ADDRESS = "button_address"
+EVENT_DATA_TYPE = "click_type"
+EVENT_DATA_QUEUED_TIME = "queued_time"
+
+# Validation of the user's configuration
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_HOST, default='localhost'): cv.string,
+    vol.Optional(CONF_PORT, default=5551): cv.port,
+    vol.Optional(CONF_DISCOVERY, default=True): cv.boolean,
+    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_IGNORED_CLICK_TYPES): vol.All(cv.ensure_list,
+                                                    [vol.In(CLICK_TYPES)])
+})
+
+
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Setup the flic platform."""
+    import pyflic
+
+    # Initialize flic client responsible for
+    # connecting to buttons and retrieving events
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    discovery = config.get(CONF_DISCOVERY)
+
+    try:
+        client = pyflic.FlicClient(host, port)
+    except ConnectionRefusedError:
+        _LOGGER.error("Failed to connect to flic server.")
+        return
+
+    def new_button_callback(address):
+        """Setup newly verified button as device in home assistant."""
+        setup_button(hass, config, add_entities, client, address)
+
+    client.on_new_verified_button = new_button_callback
+    if discovery:
+        start_scanning(config, add_entities, client)
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
+                         lambda event: client.close())
+
+    # Start the pyflic event handling thread
+    threading.Thread(target=client.handle_events).start()
+
+    def get_info_callback(items):
+        """Add entities for already verified buttons."""
+        addresses = items["bd_addr_of_verified_buttons"] or []
+        for address in addresses:
+            setup_button(hass, config, add_entities, client, address)
+
+    # Get addresses of already verified buttons
+    client.get_info(get_info_callback)
+
+
+def start_scanning(config, add_entities, client):
+    """Start a new flic client for scanning & connceting to new buttons."""
+    import pyflic
+
+    scan_wizard = pyflic.ScanWizard()
+
+    def scan_completed_callback(scan_wizard, result, address, name):
+        """Restart scan wizard to constantly check for new buttons."""
+        if result == pyflic.ScanWizardResult.WizardSuccess:
+            _LOGGER.info("Found new button (%s)", address)
+        elif result != pyflic.ScanWizardResult.WizardFailedTimeout:
+            _LOGGER.warning("Failed to connect to button (%s). Reason: %s",
+                            address, result)
+
+        # Restart scan wizard
+        start_scanning(config, add_entities, client)
+
+    scan_wizard.on_completed = scan_completed_callback
+    client.add_scan_wizard(scan_wizard)
+
+
+def setup_button(hass, config, add_entities, client, address):
+    """Setup single button device."""
+    timeout = config.get(CONF_TIMEOUT)
+    ignored_click_types = config.get(CONF_IGNORED_CLICK_TYPES)
+    button = FlicButton(hass, client, address, timeout, ignored_click_types)
+    _LOGGER.info("Connected to button (%s)", address)
+
+    add_entities([button])
+
+
+class FlicButton(BinarySensorDevice):
+    """Representation of a flic button."""
+
+    def __init__(self, hass, client, address, timeout, ignored_click_types):
+        """Initialize the flic button."""
+        import pyflic
+
+        self._hass = hass
+        self._address = address
+        self._timeout = timeout
+        self._is_down = False
+        self._ignored_click_types = ignored_click_types or []
+        self._hass_click_types = {
+            pyflic.ClickType.ButtonClick: CLICK_TYPE_SINGLE,
+            pyflic.ClickType.ButtonSingleClick: CLICK_TYPE_SINGLE,
+            pyflic.ClickType.ButtonDoubleClick: CLICK_TYPE_DOUBLE,
+            pyflic.ClickType.ButtonHold: CLICK_TYPE_HOLD,
+        }
+
+        self._channel = self._create_channel()
+        client.add_connection_channel(self._channel)
+
+    def _create_channel(self):
+        """Create a new connection channel to the button."""
+        import pyflic
+
+        channel = pyflic.ButtonConnectionChannel(self._address)
+        channel.on_button_up_or_down = self._on_up_down
+
+        # If all types of clicks should be ignored, skip registering callbacks
+        if set(self._ignored_click_types) == set(CLICK_TYPES):
+            return channel
+
+        if CLICK_TYPE_DOUBLE in self._ignored_click_types:
+            # Listen to all but double click type events
+            channel.on_button_click_or_hold = self._on_click
+        elif CLICK_TYPE_HOLD in self._ignored_click_types:
+            # Listen to all but hold click type events
+            channel.on_button_single_or_double_click = self._on_click
+        else:
+            # Listen to all click type events
+            channel.on_button_single_or_double_click_or_hold = self._on_click
+
+        return channel
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return "flic_%s" % self.address.replace(":", "")
+
+    @property
+    def address(self):
+        """Return the bluetooth address of the device."""
+        return self._address
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._is_down
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def state_attributes(self):
+        """Return device specific state attributes."""
+        attr = super(FlicButton, self).state_attributes
+        attr["address"] = self.address
+
+        return attr
+
+    def _queued_event_check(self, click_type, time_diff):
+        """Generate a log message and returns true if timeout exceeded."""
+        time_string = "{:d} {}".format(
+            time_diff, "second" if time_diff == 1 else "seconds")
+
+        if time_diff > self._timeout:
+            _LOGGER.warning(
+                "Queued %s dropped for %s. Time in queue was %s.",
+                click_type, self.address, time_string)
+            return True
+        else:
+            _LOGGER.info(
+                "Queued %s allowed for %s. Time in queue was %s.",
+                click_type, self.address, time_string)
+            return False
+
+    def _on_up_down(self, channel, click_type, was_queued, time_diff):
+        """Update device state, if event was not queued."""
+        import pyflic
+
+        if was_queued and self._queued_event_check(click_type, time_diff):
+            return
+
+        self._is_down = click_type == pyflic.ClickType.ButtonDown
+        self.schedule_update_ha_state()
+
+    def _on_click(self, channel, click_type, was_queued, time_diff):
+        """Fire click event, if event was not queued."""
+        # Return if click event was queued beyond allowed timeout
+        if was_queued and self._queued_event_check(click_type, time_diff):
+            return
+
+        # Return if click event is in ignored click types
+        hass_click_type = self._hass_click_types[click_type]
+        if hass_click_type in self._ignored_click_types:
+            return
+
+        self._hass.bus.fire(EVENT_NAME, {
+            EVENT_DATA_NAME: self.name,
+            EVENT_DATA_ADDRESS: self.address,
+            EVENT_DATA_QUEUED_TIME: time_diff,
+            EVENT_DATA_TYPE: hass_click_type
+        })
+
+    def _connection_status_changed(self, channel,
+                                   connection_status, disconnect_reason):
+        """Remove device, if button disconnects."""
+        import pyflic
+
+        if connection_status == pyflic.ConnectionStatus.Disconnected:
+            _LOGGER.info("Button (%s) disconnected. Reason: %s",
+                         self.address, disconnect_reason)
+            self.remove()

homeassistant/components/binary_sensor/hikvision.py

@@ -0,0 +1,262 @@
+"""
+Support for Hikvision event stream events represented as binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.hikvision/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.util.dt import utcnow
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    CONF_HOST, CONF_PORT, CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_SSL, EVENT_HOMEASSISTANT_STOP, ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)
+
+REQUIREMENTS = ['pyhik==0.0.7', 'pydispatcher==2.0.5']
+_LOGGER = logging.getLogger(__name__)
+
+CONF_IGNORED = 'ignored'
+CONF_DELAY = 'delay'
+
+DEFAULT_PORT = 80
+DEFAULT_IGNORED = False
+DEFAULT_DELAY = 0
+
+ATTR_DELAY = 'delay'
+
+SENSOR_CLASS_MAP = {
+    'Motion': 'motion',
+    'Line Crossing': 'motion',
+    'IO Trigger': None,
+    'Field Detection': 'motion',
+    'Video Loss': None,
+    'Tamper Detection': 'motion',
+    'Shelter Alarm': None,
+    'Disk Full': None,
+    'Disk Error': None,
+    'Net Interface Broken': 'connectivity',
+    'IP Conflict': 'connectivity',
+    'Illegal Access': None,
+    'Video Mismatch': None,
+    'Bad Video': None,
+    'PIR Alarm': 'motion',
+    'Face Detection': 'motion',
+}
+
+CUSTOMIZE_SCHEMA = vol.Schema({
+    vol.Optional(CONF_IGNORED, default=DEFAULT_IGNORED): cv.boolean,
+    vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): cv.positive_int
+    })
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=None): cv.string,
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_SSL, default=False): cv.boolean,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_CUSTOMIZE, default={}):
+        vol.Schema({cv.string: CUSTOMIZE_SCHEMA}),
+})
+
+
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Setup Hikvision binary sensor devices."""
+    name = config.get(CONF_NAME)
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    customize = config.get(CONF_CUSTOMIZE)
+
+    if config.get(CONF_SSL):
+        protocol = "https"
+    else:
+        protocol = "http"
+
+    url = '{}://{}'.format(protocol, host)
+
+    data = HikvisionData(hass, url, port, name, username, password)
+
+    if data.sensors is None:
+        _LOGGER.error('Hikvision event stream has no data, unable to setup.')
+        return False
+
+    entities = []
+
+    for sensor in data.sensors:
+        # Build sensor name, then parse customize config.
+        sensor_name = sensor.replace(' ', '_')
+
+        custom = customize.get(sensor_name.lower(), {})
+        ignore = custom.get(CONF_IGNORED)
+        delay = custom.get(CONF_DELAY)
+
+        _LOGGER.debug('Entity: %s - %s, Options - Ignore: %s, Delay: %s',
+                      data.name, sensor_name, ignore, delay)
+        if not ignore:
+            entities.append(HikvisionBinarySensor(hass, sensor, data, delay))
+
+    add_entities(entities)
+
+
+class HikvisionData(object):
+    """Hikvision camera event stream object."""
+
+    def __init__(self, hass, url, port, name, username, password):
+        """Initialize the data oject."""
+        from pyhik.hikvision import HikCamera
+        self._url = url
+        self._port = port
+        self._name = name
+        self._username = username
+        self._password = password
+
+        # Establish camera
+        self._cam = HikCamera(self._url, self._port,
+                              self._username, self._password)
+
+        if self._name is None:
+            self._name = self._cam.get_name
+
+        # Start event stream
+        self._cam.start_stream()
+
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, self.stop_hik)
+
+    def stop_hik(self, event):
+        """Shutdown Hikvision subscriptions and subscription thread on exit."""
+        self._cam.disconnect()
+
+    @property
+    def sensors(self):
+        """Return list of available sensors and their states."""
+        return self._cam.current_event_states
+
+    @property
+    def cam_id(self):
+        """Return camera id."""
+        return self._cam.get_id
+
+    @property
+    def name(self):
+        """Return camera name."""
+        return self._name
+
+
+class HikvisionBinarySensor(BinarySensorDevice):
+    """Representation of a Hikvision binary sensor."""
+
+    def __init__(self, hass, sensor, cam, delay):
+        """Initialize the binary_sensor."""
+        from pydispatch import dispatcher
+
+        self._hass = hass
+        self._cam = cam
+        self._name = self._cam.name + ' ' + sensor
+        self._id = self._cam.cam_id + '.' + sensor
+        self._sensor = sensor
+
+        if delay is None:
+            self._delay = 0
+        else:
+            self._delay = delay
+
+        self._timer = None
+
+        # Form signal for dispatcher
+        signal = 'ValueChanged.{}'.format(self._cam.cam_id)
+
+        dispatcher.connect(self._update_callback,
+                           signal=signal,
+                           sender=self._sensor)
+
+    def _sensor_state(self):
+        """Extract sensor state."""
+        return self._cam.sensors[self._sensor][0]
+
+    def _sensor_last_update(self):
+        """Extract sensor last update time."""
+        return self._cam.sensors[self._sensor][3]
+
+    @property
+    def name(self):
+        """Return the name of the Hikvision sensor."""
+        return self._name
+
+    @property
+    def unique_id(self):
+        """Return an unique ID."""
+        return '{}.{}'.format(self.__class__, self._id)
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._sensor_state()
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        try:
+            return SENSOR_CLASS_MAP[self._sensor]
+        except KeyError:
+            # Sensor must be unknown to us, add as generic
+            return None
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attr = {}
+        attr[ATTR_LAST_TRIP_TIME] = self._sensor_last_update()
+
+        if self._delay != 0:
+            attr[ATTR_DELAY] = self._delay
+
+        return attr
+
+    def _update_callback(self, signal, sender):
+        """Update the sensor's state, if needed."""
+        _LOGGER.debug('Dispatcher callback, signal: %s, sender: %s',
+                      signal, sender)
+
+        if sender is not self._sensor:
+            return
+
+        if self._delay > 0 and not self.is_on:
+            # Set timer to wait until updating the state
+            def _delay_update(now):
+                """Timer callback for sensor update."""
+                _LOGGER.debug('%s Called delayed (%ssec) update.',
+                              self._name, self._delay)
+                self.schedule_update_ha_state()
+                self._timer = None
+
+            if self._timer is not None:
+                self._timer()
+                self._timer = None
+
+            self._timer = track_point_in_utc_time(
+                self._hass, _delay_update,
+                utcnow() + timedelta(seconds=self._delay))
+
+        elif self._delay > 0 and self.is_on:
+            # For delayed sensors kill any callbacks on true events and update
+            if self._timer is not None:
+                self._timer()
+                self._timer = None
+
+            self.schedule_update_ha_state()
+
+        else:
+            self.schedule_update_ha_state()

homeassistant/components/binary_sensor/homematic.py

@@ -7,7 +7,8 @@ https://home-assistant.io/components/binary_sensor.homematic/
 import logging
 from homeassistant.const import STATE_UNKNOWN
 from homeassistant.components.binary_sensor import BinarySensorDevice
-import homeassistant.components.homematic as homematic
+from homeassistant.components.homematic import HMDevice
+from homeassistant.loader import get_component
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,6 +17,7 @@ DEPENDENCIES = ['homematic']
 SENSOR_TYPES_CLASS = {
     "Remote": None,
     "ShutterContact": "opening",
+    "MaxShutterContact": "opening",
     "IPShutterContact": "opening",
     "Smoke": "smoke",
     "SmokeV2": "smoke",
@@ -32,14 +34,16 @@ def setup_platform(hass, config, add_callback_devices, discovery_info=None):
     if discovery_info is None:
         return
 
+    homematic = get_component("homematic")
     return homematic.setup_hmdevice_discovery_helper(
+        hass,
         HMBinarySensor,
         discovery_info,
         add_callback_devices
     )
 
 
-class HMBinarySensor(homematic.HMDevice, BinarySensorDevice):
+class HMBinarySensor(HMDevice, BinarySensorDevice):
     """Representation of a binary Homematic device."""
 
     @property

homeassistant/components/binary_sensor/iss.py

@@ -0,0 +1,131 @@
+"""
+Support for International Space Station data sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.iss/
+"""
+import logging
+from datetime import timedelta
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE)
+from homeassistant.util import Throttle
+
+REQUIREMENTS = ['pyiss==1.0.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_ISS_NEXT_RISE = 'next_rise'
+ATTR_ISS_NUMBER_PEOPLE_SPACE = 'number_of_people_in_space'
+
+CONF_SHOW_ON_MAP = 'show_on_map'
+
+DEFAULT_NAME = 'ISS'
+DEFAULT_SENSOR_CLASS = 'visible'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_SHOW_ON_MAP, default=False): cv.boolean,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the ISS sensor."""
+    if None in (hass.config.latitude, hass.config.longitude):
+        _LOGGER.error("Latitude or longitude not set in Home Assistant config")
+        return False
+
+    try:
+        iss_data = IssData(hass.config.latitude, hass.config.longitude)
+        iss_data.update()
+    except requests.exceptions.HTTPError as error:
+        _LOGGER.error(error)
+        return False
+
+    name = config.get(CONF_NAME)
+    show_on_map = config.get(CONF_SHOW_ON_MAP)
+
+    add_devices([IssBinarySensor(iss_data, name, show_on_map)], True)
+
+
+class IssBinarySensor(BinarySensorDevice):
+    """Implementation of the ISS binary sensor."""
+
+    def __init__(self, iss_data, name, show):
+        """Initialize the sensor."""
+        self.iss_data = iss_data
+        self._state = None
+        self._name = name
+        self._show_on_map = show
+        self.update()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.iss_data.is_above if self.iss_data else False
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_SENSOR_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        if self.iss_data:
+            attrs = {
+                ATTR_ISS_NUMBER_PEOPLE_SPACE:
+                    self.iss_data.number_of_people_in_space,
+                ATTR_ISS_NEXT_RISE: self.iss_data.next_rise,
+            }
+            if self._show_on_map:
+                attrs[ATTR_LONGITUDE] = self.iss_data.position.get('longitude')
+                attrs[ATTR_LATITUDE] = self.iss_data.position.get('latitude')
+            else:
+                attrs['long'] = self.iss_data.position.get('longitude')
+                attrs['lat'] = self.iss_data.position.get('latitude')
+            return attrs
+
+    def update(self):
+        """Get the latest data from ISS API and updates the states."""
+        self.iss_data.update()
+
+
+class IssData(object):
+    """Get data from the ISS API."""
+
+    def __init__(self, latitude, longitude):
+        """Initialize the data object."""
+        self.is_above = None
+        self.next_rise = None
+        self.number_of_people_in_space = None
+        self.position = None
+        self.latitude = latitude
+        self.longitude = longitude
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data from the ISS API."""
+        import pyiss
+
+        try:
+            iss = pyiss.ISS()
+            self.is_above = iss.is_ISS_above(self.latitude, self.longitude)
+            self.next_rise = iss.next_rise(self.latitude, self.longitude)
+            self.number_of_people_in_space = iss.number_of_people_in_space()
+            self.position = iss.current_location()
+        except requests.exceptions.HTTPError as error:
+            _LOGGER.error(error)
+            return False

homeassistant/components/binary_sensor/mqtt.py

@@ -8,6 +8,7 @@ import logging
 
 import voluptuous as vol
 
+from homeassistant.core import callback
 import homeassistant.components.mqtt as mqtt
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, SENSOR_CLASSES)
@@ -35,7 +36,10 @@ PLATFORM_SCHEMA = mqtt.MQTT_RO_PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the MQTT binary sensor."""
+    """Set up the MQTT binary sensor."""
+    if discovery_info is not None:
+        config = PLATFORM_SCHEMA(discovery_info)
+
     value_template = config.get(CONF_VALUE_TEMPLATE)
     if value_template is not None:
         value_template.hass = hass
@@ -66,17 +70,18 @@ class MqttBinarySensor(BinarySensorDevice):
         self._payload_off = payload_off
         self._qos = qos
 
+        @callback
         def message_received(topic, payload, qos):
             """A new MQTT message has been received."""
             if value_template is not None:
-                payload = value_template.render_with_possible_json_value(
+                payload = value_template.async_render_with_possible_json_value(
                     payload)
             if payload == self._payload_on:
                 self._state = True
-                self.update_ha_state()
+                hass.async_add_job(self.async_update_ha_state())
             elif payload == self._payload_off:
                 self._state = False
-                self.update_ha_state()
+                hass.async_add_job(self.async_update_ha_state())
 
         mqtt.subscribe(hass, self._state_topic, message_received, self._qos)
 

homeassistant/components/binary_sensor/mysensors.py

@@ -22,7 +22,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     if discovery_info is None:
         return
 
-    for gateway in mysensors.GATEWAYS.values():
+    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
+    if not gateways:
+        return
+
+    for gateway in gateways:
         # Define the S_TYPES and V_TYPES that the platform should handle as
         # states. Map them in a dict of lists.
         pres = gateway.const.Presentation
@@ -43,7 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
         devices = {}
         gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsBinarySensor))
+            map_sv_types, devices, MySensorsBinarySensor, add_devices))
 
 
 class MySensorsBinarySensor(

homeassistant/components/binary_sensor/nest.py

@@ -4,46 +4,88 @@ Support for Nest Thermostat Binary Sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.nest/
 """
-import voluptuous as vol
+from itertools import chain
+import logging
 
-from homeassistant.components.binary_sensor import (
-    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.binary_sensor import (BinarySensorDevice)
 from homeassistant.components.sensor.nest import NestSensor
-from homeassistant.const import (CONF_SCAN_INTERVAL, CONF_MONITORED_CONDITIONS)
+from homeassistant.const import CONF_MONITORED_CONDITIONS
 from homeassistant.components.nest import DATA_NEST
-import homeassistant.helpers.config_validation as cv
 
 DEPENDENCIES = ['nest']
-BINARY_TYPES = ['fan',
-                'hvac_ac_state',
-                'hvac_aux_heater_state',
-                'hvac_heater_state',
-                'hvac_heat_x2_state',
-                'hvac_heat_x3_state',
-                'hvac_alt_heat_state',
-                'hvac_alt_heat_x2_state',
-                'hvac_emer_heat_state',
-                'online']
 
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_SCAN_INTERVAL):
-        vol.All(vol.Coerce(int), vol.Range(min=1)),
-    vol.Required(CONF_MONITORED_CONDITIONS):
-        vol.All(cv.ensure_list, [vol.In(BINARY_TYPES)]),
-})
+BINARY_TYPES = ['online']
+
+CLIMATE_BINARY_TYPES = ['fan',
+                        'is_using_emergency_heat',
+                        'is_locked',
+                        'has_leaf']
+
+CAMERA_BINARY_TYPES = [
+    'motion_detected',
+    'sound_detected',
+    'person_detected']
+
+_BINARY_TYPES_DEPRECATED = [
+    'hvac_ac_state',
+    'hvac_aux_heater_state',
+    'hvac_heater_state',
+    'hvac_heat_x2_state',
+    'hvac_heat_x3_state',
+    'hvac_alt_heat_state',
+    'hvac_alt_heat_x2_state',
+    'hvac_emer_heat_state']
+
+_VALID_BINARY_SENSOR_TYPES = BINARY_TYPES + CLIMATE_BINARY_TYPES \
+    + CAMERA_BINARY_TYPES
+
+_LOGGER = logging.getLogger(__name__)
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup Nest binary sensors."""
+    if discovery_info is None:
+        return
+
     nest = hass.data[DATA_NEST]
 
-    all_sensors = []
-    for structure, device in nest.devices():
-        all_sensors.extend(
-            [NestBinarySensor(structure, device, variable)
-             for variable in config[CONF_MONITORED_CONDITIONS]])
+    # Add all available binary sensors if no Nest binary sensor config is set
+    if discovery_info == {}:
+        conditions = _VALID_BINARY_SENSOR_TYPES
+    else:
+        conditions = discovery_info.get(CONF_MONITORED_CONDITIONS, {})
 
-    add_devices(all_sensors, True)
+    for variable in conditions:
+        if variable in _BINARY_TYPES_DEPRECATED:
+            wstr = (variable + " is no a longer supported "
+                    "monitored_conditions. See "
+                    "https://home-assistant.io/components/binary_sensor.nest/ "
+                    "for valid options.")
+            _LOGGER.error(wstr)
+
+    sensors = []
+    device_chain = chain(nest.thermostats(),
+                         nest.smoke_co_alarms(),
+                         nest.cameras())
+    for structure, device in device_chain:
+        sensors += [NestBinarySensor(structure, device, variable)
+                    for variable in conditions
+                    if variable in BINARY_TYPES]
+        sensors += [NestBinarySensor(structure, device, variable)
+                    for variable in conditions
+                    if variable in CLIMATE_BINARY_TYPES
+                    and device.is_thermostat]
+
+        if device.is_camera:
+            sensors += [NestBinarySensor(structure, device, variable)
+                        for variable in conditions
+                        if variable in CAMERA_BINARY_TYPES]
+            for activity_zone in device.activity_zones:
+                sensors += [NestActivityZoneSensor(structure,
+                                                   device,
+                                                   activity_zone)]
+
+    add_devices(sensors, True)
 
 
 class NestBinarySensor(NestSensor, BinarySensorDevice):
@@ -57,3 +99,22 @@ class NestBinarySensor(NestSensor, BinarySensorDevice):
     def update(self):
         """Retrieve latest state."""
         self._state = bool(getattr(self.device, self.variable))
+
+
+class NestActivityZoneSensor(NestBinarySensor):
+    """Represents a Nest binary sensor for activity in a zone."""
+
+    def __init__(self, structure, device, zone):
+        """Initialize the sensor."""
+        super(NestActivityZoneSensor, self).__init__(structure, device, "")
+        self.zone = zone
+        self._name = "{} {} activity".format(self._name, self.zone.name)
+
+    @property
+    def name(self):
+        """Return the name of the nest, if any."""
+        return self._name
+
+    def update(self):
+        """Retrieve latest state."""
+        self._state = self.device.has_ongoing_motion_in_zone(self.zone.zone_id)

homeassistant/components/binary_sensor/netatmo.py

@@ -1,19 +1,19 @@
 """
 Support for the Netatmo binary sensors.
 
-The binary sensors based on events seen by the NetatmoCamera
+The binary sensors based on events seen by the Netatmo cameras.
 
 For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/binary_sensor.netatmo/
+https://home-assistant.io/components/binary_sensor.netatmo/.
 """
 import logging
 import voluptuous as vol
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.components.netatmo import WelcomeData
+from homeassistant.components.netatmo import CameraData
 from homeassistant.loader import get_component
-from homeassistant.const import CONF_MONITORED_CONDITIONS
+from homeassistant.const import CONF_TIMEOUT, CONF_OFFSET
 from homeassistant.helpers import config_validation as cv
 
 DEPENDENCIES = ["netatmo"]
@@ -22,21 +22,40 @@ _LOGGER = logging.getLogger(__name__)
 
 
 # These are the available sensors mapped to binary_sensor class
-SENSOR_TYPES = {
+WELCOME_SENSOR_TYPES = {
     "Someone known": "motion",
     "Someone unknown": "motion",
     "Motion": "motion",
 }
+PRESENCE_SENSOR_TYPES = {
+    "Outdoor motion": "motion",
+    "Outdoor human": "motion",
+    "Outdoor animal": "motion",
+    "Outdoor vehicle": "motion"
+}
+TAG_SENSOR_TYPES = {
+    "Tag Vibration": 'vibration',
+    "Tag Open": 'opening'
+}
 
 CONF_HOME = 'home'
 CONF_CAMERAS = 'cameras'
+CONF_WELCOME_SENSORS = 'welcome_sensors'
+CONF_PRESENCE_SENSORS = 'presence_sensors'
+CONF_TAG_SENSORS = 'tag_sensors'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOME): cv.string,
+    vol.Optional(CONF_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_OFFSET): cv.positive_int,
     vol.Optional(CONF_CAMERAS, default=[]):
         vol.All(cv.ensure_list, [cv.string]),
-    vol.Optional(CONF_MONITORED_CONDITIONS, default=SENSOR_TYPES.keys()):
-        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+    vol.Optional(
+        CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES.keys()):
+        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
+    vol.Optional(
+        CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES.keys()):
+        vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
 })
 
 
@@ -45,45 +64,83 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup access to Netatmo binary sensor."""
     netatmo = get_component('netatmo')
     home = config.get(CONF_HOME, None)
+    timeout = config.get(CONF_TIMEOUT, 15)
+    offset = config.get(CONF_OFFSET, 90)
+
+    module_name = None
 
     import lnetatmo
     try:
-        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        data = CameraData(netatmo.NETATMO_AUTH, home)
         if data.get_camera_names() == []:
             return None
     except lnetatmo.NoDevice:
         return None
 
-    sensors = config.get(CONF_MONITORED_CONDITIONS, SENSOR_TYPES)
+    welcome_sensors = config.get(
+        CONF_WELCOME_SENSORS, WELCOME_SENSOR_TYPES)
+    presence_sensors = config.get(
+        CONF_PRESENCE_SENSORS, PRESENCE_SENSOR_TYPES)
+    tag_sensors = config.get(CONF_TAG_SENSORS, TAG_SENSOR_TYPES)
 
     for camera_name in data.get_camera_names():
-        if CONF_CAMERAS in config:
-            if config[CONF_CAMERAS] != [] and \
-               camera_name not in config[CONF_CAMERAS]:
-                continue
-        for variable in sensors:
-            add_devices([WelcomeBinarySensor(data, camera_name, home,
-                                             variable)])
+        camera_type = data.get_camera_type(camera=camera_name, home=home)
+        if camera_type == "NACamera":
+            if CONF_CAMERAS in config:
+                if config[CONF_CAMERAS] != [] and \
+                   camera_name not in config[CONF_CAMERAS]:
+                    continue
+            for variable in welcome_sensors:
+                add_devices([NetatmoBinarySensor(data, camera_name,
+                                                 module_name, home, timeout,
+                                                 offset, camera_type,
+                                                 variable)])
+        if camera_type == "NOC":
+            if CONF_CAMERAS in config:
+                if config[CONF_CAMERAS] != [] and \
+                   camera_name not in config[CONF_CAMERAS]:
+                    continue
+            for variable in presence_sensors:
+                add_devices([NetatmoBinarySensor(data, camera_name,
+                                                 module_name, home, timeout,
+                                                 offset, camera_type,
+                                                 variable)])
+
+        for module_name in data.get_module_names(camera_name):
+            for variable in tag_sensors:
+                camera_type = None
+                add_devices([NetatmoBinarySensor(data, camera_name,
+                                                 module_name, home,
+                                                 timeout, offset,
+                                                 camera_type,
+                                                 variable)])
 
 
-class WelcomeBinarySensor(BinarySensorDevice):
-    """Represent a single binary sensor in a Netatmo Welcome device."""
+class NetatmoBinarySensor(BinarySensorDevice):
+    """Represent a single binary sensor in a Netatmo Camera device."""
 
-    def __init__(self, data, camera_name, home, sensor):
+    def __init__(self, data, camera_name, module_name, home,
+                 timeout, offset, camera_type, sensor):
         """Setup for access to the Netatmo camera events."""
         self._data = data
         self._camera_name = camera_name
+        self._module_name = module_name
         self._home = home
+        self._timeout = timeout
+        self._offset = offset
         if home:
             self._name = home + ' / ' + camera_name
         else:
             self._name = camera_name
+        if module_name:
+            self._name += ' / ' + module_name
         self._sensor_name = sensor
         self._name += ' ' + sensor
-        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+        camera_id = data.camera_data.cameraByName(camera=camera_name,
                                                   home=home)['id']
-        self._unique_id = "Welcome_binary_sensor {0} - {1}".format(self._name,
+        self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(self._name,
                                                                    camera_id)
+        self._cameratype = camera_type
         self.update()
 
     @property
@@ -99,7 +156,12 @@ class WelcomeBinarySensor(BinarySensorDevice):
     @property
     def sensor_class(self):
         """Return the class of this sensor, from SENSOR_CLASSES."""
-        return SENSOR_TYPES.get(self._sensor_name)
+        if self._cameratype == "NACamera":
+            return WELCOME_SENSOR_TYPES.get(self._sensor_name)
+        elif self._cameratype == "NOC":
+            return PRESENCE_SENSOR_TYPES.get(self._sensor_name)
+        else:
+            return TAG_SENSOR_TYPES.get(self._sensor_name)
 
     @property
     def is_on(self):
@@ -109,19 +171,53 @@ class WelcomeBinarySensor(BinarySensorDevice):
     def update(self):
         """Request an update from the Netatmo API."""
         self._data.update()
-        self._data.welcomedata.updateEvent(home=self._data.home)
+        self._data.update_event()
 
-        if self._sensor_name == "Someone known":
+        if self._cameratype == "NACamera":
+            if self._sensor_name == "Someone known":
+                self._state =\
+                    self._data.camera_data.someoneKnownSeen(self._home,
+                                                            self._camera_name,
+                                                            self._timeout*60)
+            elif self._sensor_name == "Someone unknown":
+                self._state =\
+                    self._data.camera_data.someoneUnknownSeen(
+                        self._home, self._camera_name, self._timeout*60)
+            elif self._sensor_name == "Motion":
+                self._state =\
+                    self._data.camera_data.motionDetected(self._home,
+                                                          self._camera_name,
+                                                          self._timeout*60)
+        elif self._cameratype == "NOC":
+            if self._sensor_name == "Outdoor motion":
+                self._state =\
+                    self._data.camera_data.outdoormotionDetected(
+                        self._home, self._camera_name, self._offset)
+            elif self._sensor_name == "Outdoor human":
+                self._state =\
+                    self._data.camera_data.humanDetected(self._home,
+                                                         self._camera_name,
+                                                         self._offset)
+            elif self._sensor_name == "Outdoor animal":
+                self._state =\
+                    self._data.camera_data.animalDetected(self._home,
+                                                          self._camera_name,
+                                                          self._offset)
+            elif self._sensor_name == "Outdoor vehicle":
+                self._state =\
+                    self._data.camera_data.carDetected(self._home,
+                                                       self._camera_name,
+                                                       self._offset)
+        if self._sensor_name == "Tag Vibration":
             self._state =\
-                    self._data.welcomedata.someoneKnownSeen(self._home,
-                                                            self._camera_name)
-        elif self._sensor_name == "Someone unknown":
+                self._data.camera_data.moduleMotionDetected(self._home,
+                                                            self._module_name,
+                                                            self._camera_name,
+                                                            self._timeout*60)
+        elif self._sensor_name == "Tag Open":
             self._state =\
-                self._data.welcomedata.someoneUnknownSeen(self._home,
-                                                          self._camera_name)
-        elif self._sensor_name == "Motion":
-            self._state =\
-                self._data.welcomedata.motionDetected(self._home,
-                                                      self._camera_name)
+                self._data.camera_data.moduleOpened(self._home,
+                                                    self._module_name,
+                                                    self._camera_name)
         else:
             return None

homeassistant/components/binary_sensor/nx584.py

@@ -16,7 +16,7 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import (CONF_HOST, CONF_PORT)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['pynx584==0.2']
+REQUIREMENTS = ['pynx584==0.4']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -123,7 +123,7 @@ class NX584Watcher(threading.Thread):
         if not zone_sensor:
             return
         zone_sensor._zone['state'] = event['zone_state']
-        zone_sensor.update_ha_state()
+        zone_sensor.schedule_update_ha_state()
 
     def _process_events(self, events):
         for event in events:

homeassistant/components/binary_sensor/rpi_gpio.py

@@ -51,7 +51,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     for port_num, port_name in ports.items():
         binary_sensors.append(RPiGPIOBinarySensor(
             port_name, port_num, pull_mode, bouncetime, invert_logic))
-    add_devices(binary_sensors)
+    add_devices(binary_sensors, True)
 
 
 class RPiGPIOBinarySensor(BinarySensorDevice):
@@ -65,14 +65,14 @@ class RPiGPIOBinarySensor(BinarySensorDevice):
         self._pull_mode = pull_mode
         self._bouncetime = bouncetime
         self._invert_logic = invert_logic
+        self._state = None
 
         rpi_gpio.setup_input(self._port, self._pull_mode)
-        self._state = rpi_gpio.read_input(self._port)
 
         def read_gpio(port):
             """Read state from GPIO."""
             self._state = rpi_gpio.read_input(self._port)
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
         rpi_gpio.edge_detect(self._port, read_gpio, self._bouncetime)
 
@@ -90,3 +90,7 @@ class RPiGPIOBinarySensor(BinarySensorDevice):
     def is_on(self):
         """Return the state of the entity."""
         return self._state != self._invert_logic
+
+    def update(self):
+        """Update the GPIO state."""
+        self._state = rpi_gpio.read_input(self._port)

homeassistant/components/binary_sensor/services.yaml

@@ -1,9 +0,0 @@
-# Describes the format for available binary_sensor services
-
-ffmpeg_restart:
-  description: Send a restart command to a ffmpeg based sensor (party mode).
-
-  fields:
-    entity_id:
-      description: Name(s) of entites that will restart. Platform dependent.
-      example: 'binary_sensor.ffmpeg_noise'

homeassistant/components/binary_sensor/template.py

@@ -63,7 +63,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         _LOGGER.error('No sensors added')
         return False
 
-    hass.loop.create_task(async_add_devices(sensors, True))
+    yield from async_add_devices(sensors, True)
     return True
 
 
@@ -84,7 +84,7 @@ class BinarySensorTemplate(BinarySensorDevice):
         @callback
         def template_bsensor_state_listener(entity, old_state, new_state):
             """Called when the target device changes state."""
-            hass.loop.create_task(self.async_update_ha_state(True))
+            hass.async_add_job(self.async_update_ha_state, True)
 
         async_track_state_change(
             hass, entity_ids, template_bsensor_state_listener)
@@ -118,7 +118,8 @@ class BinarySensorTemplate(BinarySensorDevice):
             if ex.args and ex.args[0].startswith(
                     "UndefinedError: 'None' has no attribute"):
                 # Common during HA startup - so just a warning
-                _LOGGER.warning(ex)
+                _LOGGER.warning('Could not render template %s,'
+                                ' the state is unknown.', self._name)
                 return
-            _LOGGER.error(ex)
+            _LOGGER.error('Could not render template %s: %s', self._name, ex)
             self._state = False

homeassistant/components/binary_sensor/threshold.py

@@ -0,0 +1,128 @@
+"""
+Support for monitoring if a sensor value is below/above a threshold.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.threshold/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, SENSOR_CLASSES_SCHEMA)
+from homeassistant.const import (
+    CONF_NAME, CONF_ENTITY_ID, CONF_TYPE, STATE_UNKNOWN, CONF_SENSOR_CLASS,
+    ATTR_ENTITY_ID)
+from homeassistant.core import callback
+from homeassistant.helpers.event import async_track_state_change
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_SENSOR_VALUE = 'sensor_value'
+ATTR_THRESHOLD = 'threshold'
+ATTR_TYPE = 'type'
+
+CONF_LOWER = 'lower'
+CONF_THRESHOLD = 'threshold'
+CONF_UPPER = 'upper'
+
+DEFAULT_NAME = 'Threshold'
+
+SENSOR_TYPES = [CONF_LOWER, CONF_UPPER]
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_THRESHOLD): vol.Coerce(float),
+    vol.Required(CONF_TYPE): vol.In(SENSOR_TYPES),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_SENSOR_CLASS, default=None): SENSOR_CLASSES_SCHEMA,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Threshold sensor."""
+    entity_id = config.get(CONF_ENTITY_ID)
+    name = config.get(CONF_NAME)
+    threshold = config.get(CONF_THRESHOLD)
+    limit_type = config.get(CONF_TYPE)
+    sensor_class = config.get(CONF_SENSOR_CLASS)
+
+    yield from async_add_devices(
+        [ThresholdSensor(hass, entity_id, name, threshold, limit_type,
+                         sensor_class)], True)
+    return True
+
+
+class ThresholdSensor(BinarySensorDevice):
+    """Representation of a Threshold sensor."""
+
+    def __init__(self, hass, entity_id, name, threshold, limit_type,
+                 sensor_class):
+        """Initialize the Threshold sensor."""
+        self._hass = hass
+        self._entity_id = entity_id
+        self.is_upper = limit_type == 'upper'
+        self._name = name
+        self._threshold = threshold
+        self._sensor_class = sensor_class
+        self._deviation = False
+        self.sensor_value = 0
+
+        @callback
+        # pylint: disable=invalid-name
+        def async_threshold_sensor_state_listener(
+                entity, old_state, new_state):
+            """Called when the sensor changes state."""
+            if new_state.state == STATE_UNKNOWN:
+                return
+
+            try:
+                self.sensor_value = float(new_state.state)
+            except ValueError:
+                _LOGGER.error("State is not numerical")
+
+            hass.async_add_job(self.async_update_ha_state, True)
+
+        async_track_state_change(
+            hass, entity_id, async_threshold_sensor_state_listener)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._deviation
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def sensor_class(self):
+        """Return the sensor class of the sensor."""
+        return self._sensor_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            ATTR_ENTITY_ID: self._entity_id,
+            ATTR_SENSOR_VALUE: self.sensor_value,
+            ATTR_THRESHOLD: self._threshold,
+            ATTR_TYPE: CONF_UPPER if self.is_upper else CONF_LOWER,
+        }
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get the latest data and updates the states."""
+        if self.is_upper:
+            self._deviation = bool(self.sensor_value > self._threshold)
+        else:
+            self._deviation = bool(self.sensor_value < self._threshold)

homeassistant/components/binary_sensor/trend.py

@@ -4,8 +4,11 @@ A sensor that monitors trands in other components.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/sensor.trend/
 """
+import asyncio
 import logging
 import voluptuous as vol
+
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 from homeassistant.components.binary_sensor import (
@@ -87,13 +90,12 @@ class SensorTrend(BinarySensorDevice):
         self.from_state = None
         self.to_state = None
 
-        self.update()
-
+        @callback
         def trend_sensor_state_listener(entity, old_state, new_state):
             """Called when the target device changes state."""
             self.from_state = old_state
             self.to_state = new_state
-            self.update_ha_state(True)
+            hass.async_add_job(self.async_update_ha_state(True))
 
         track_state_change(hass, target_entity,
                            trend_sensor_state_listener)
@@ -118,7 +120,8 @@ class SensorTrend(BinarySensorDevice):
         """No polling needed."""
         return False
 
-    def update(self):
+    @asyncio.coroutine
+    def async_update(self):
         """Get the latest data and update the states."""
         if self.from_state is None or self.to_state is None:
             return

homeassistant/components/binary_sensor/wemo.py

@@ -45,10 +45,10 @@ class WemoBinarySensor(BinarySensorDevice):
         _LOGGER.info(
             'Subscription update for  %s',
             _device)
+        self.update()
         if not hasattr(self, 'hass'):
-            self.update()
             return
-        self.update_ha_state(True)
+        self.schedule_update_ha_state()
 
     @property
     def should_poll(self):

homeassistant/components/binary_sensor/wink.py

@@ -4,12 +4,13 @@ Support for Wink binary sensors.
 For more details about this platform, please refer to the documentation at
 at https://home-assistant.io/components/binary_sensor.wink/
 """
-import json
+import logging
 
 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.sensor.wink import WinkDevice
+from homeassistant.components.wink import WinkDevice, DOMAIN
 from homeassistant.helpers.entity import Entity
-from homeassistant.loader import get_component
+
+_LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['wink']
 
@@ -19,11 +20,14 @@ SENSOR_TYPES = {
     "brightness": "light",
     "vibration": "vibration",
     "loudness": "sound",
+    "noise": "sound",
+    "capturing_audio": "sound",
     "liquid_detected": "moisture",
     "motion": "motion",
     "presence": "occupancy",
     "co_detected": "gas",
-    "smoke_detected": "smoke"
+    "smoke_detected": "smoke",
+    "capturing_video": None
 }
 
 
@@ -32,59 +36,160 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     import pywink
 
     for sensor in pywink.get_sensors():
-        if sensor.capability() in SENSOR_TYPES:
-            add_devices([WinkBinarySensorDevice(sensor)])
+        _id = sensor.object_id() + sensor.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            if sensor.capability() in SENSOR_TYPES:
+                add_devices([WinkBinarySensorDevice(sensor, hass)])
 
     for key in pywink.get_keys():
-        add_devices([WinkBinarySensorDevice(key)])
+        _id = key.object_id() + key.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkBinarySensorDevice(key, hass)])
 
     for sensor in pywink.get_smoke_and_co_detectors():
-        add_devices([WinkBinarySensorDevice(sensor)])
+        _id = sensor.object_id() + sensor.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkSmokeDetector(sensor, hass)])
+
+    for hub in pywink.get_hubs():
+        _id = hub.object_id() + hub.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkHub(hub, hass)])
+
+    for remote in pywink.get_remotes():
+        _id = remote.object_id() + remote.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkRemote(remote, hass)])
+
+    for button in pywink.get_buttons():
+        _id = button.object_id() + button.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkButton(button, hass)])
+
+    for gang in pywink.get_gangs():
+        _id = gang.object_id() + gang.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkGang(gang, hass)])
+
+    for door_bell_sensor in pywink.get_door_bells():
+        _id = door_bell_sensor.object_id() + door_bell_sensor.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkBinarySensorDevice(door_bell_sensor, hass)])
+
+    for camera_sensor in pywink.get_cameras():
+        _id = camera_sensor.object_id() + camera_sensor.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            try:
+                if camera_sensor.capability() in SENSOR_TYPES:
+                    add_devices([WinkBinarySensorDevice(camera_sensor, hass)])
+            except AttributeError:
+                _LOGGER.info("Device isn't a sensor, skipping.")
 
 
 class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
     """Representation of a Wink binary sensor."""
 
-    def __init__(self, wink):
+    def __init__(self, wink, hass):
         """Initialize the Wink binary sensor."""
-        super().__init__(wink)
-        wink = get_component('wink')
-        self._unit_of_measurement = self.wink.UNIT
-        self.capability = self.wink.capability()
-
-    def _pubnub_update(self, message, channel):
-        if 'data' in message:
-            json_data = json.dumps(message.get('data'))
-        else:
-            json_data = message
-        self.wink.pubnub_update(json.loads(json_data))
-        self.update_ha_state()
+        super().__init__(wink, hass)
+        try:
+            self._unit_of_measurement = self.wink.unit()
+        except AttributeError:
+            self._unit_of_measurement = None
+        try:
+            self.capability = self.wink.capability()
+        except AttributeError:
+            self.capability = None
 
     @property
     def is_on(self):
         """Return true if the binary sensor is on."""
-        if self.capability == "loudness":
-            state = self.wink.loudness_boolean()
-        elif self.capability == "vibration":
-            state = self.wink.vibration_boolean()
-        elif self.capability == "brightness":
-            state = self.wink.brightness_boolean()
-        elif self.capability == "liquid_detected":
-            state = self.wink.liquid_boolean()
-        elif self.capability == "motion":
-            state = self.wink.motion_boolean()
-        elif self.capability == "presence":
-            state = self.wink.presence_boolean()
-        elif self.capability == "co_detected":
-            state = self.wink.co_detected_boolean()
-        elif self.capability == "smoke_detected":
-            state = self.wink.smoke_detected_boolean()
-        else:
-            state = self.wink.state()
-
-        return state
+        return self.wink.state()
 
     @property
     def sensor_class(self):
         """Return the class of this sensor, from SENSOR_CLASSES."""
         return SENSOR_TYPES.get(self.capability)
+
+
+class WinkSmokeDetector(WinkBinarySensorDevice):
+    """Representation of a Wink Smoke detector."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink binary sensor."""
+        super().__init__(wink, hass)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'test_activated': self.wink.test_activated()
+        }
+
+
+class WinkHub(WinkBinarySensorDevice):
+    """Representation of a Wink Hub."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink binary sensor."""
+        super().__init__(wink, hass)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'update needed': self.wink.update_needed(),
+            'firmware version': self.wink.firmware_version()
+        }
+
+
+class WinkRemote(WinkBinarySensorDevice):
+    """Representation of a Wink Lutron Connected bulb remote."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink binary sensor."""
+        super().__init__(wink, hass)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'button_on_pressed': self.wink.button_on_pressed(),
+            'button_off_pressed': self.wink.button_off_pressed(),
+            'button_up_pressed': self.wink.button_up_pressed(),
+            'button_down_pressed': self.wink.button_down_pressed()
+        }
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor, from SENSOR_CLASSES."""
+        return None
+
+
+class WinkButton(WinkBinarySensorDevice):
+    """Representation of a Wink Relay button."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink binary sensor."""
+        super().__init__(wink, hass)
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'pressed': self.wink.pressed(),
+            'long_pressed': self.wink.long_pressed()
+        }
+
+
+class WinkGang(WinkBinarySensorDevice):
+    """Representation of a Wink Relay gang."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink binary sensor."""
+        super().__init__(wink, hass)
+
+    @property
+    def is_on(self):
+        """Return true if the gang is connected."""
+        return self.wink.state()

homeassistant/components/binary_sensor/zwave.py

@@ -8,8 +8,8 @@ import logging
 import datetime
 import homeassistant.util.dt as dt_util
 from homeassistant.helpers.event import track_point_in_time
-from homeassistant.helpers.entity import Entity
 from homeassistant.components import zwave
+from homeassistant.components.zwave import workaround
 from homeassistant.components.binary_sensor import (
     DOMAIN,
     BinarySensorDevice)
@@ -17,19 +17,6 @@ from homeassistant.components.binary_sensor import (
 _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = []
 
-PHILIO = 0x013c
-PHILIO_SLIM_SENSOR = 0x0002
-PHILIO_SLIM_SENSOR_MOTION = (PHILIO, PHILIO_SLIM_SENSOR, 0)
-WENZHOU = 0x0118
-WENZHOU_SLIM_SENSOR_MOTION = (WENZHOU, PHILIO_SLIM_SENSOR, 0)
-
-WORKAROUND_NO_OFF_EVENT = 'trigger_no_off_event'
-
-DEVICE_MAPPINGS = {
-    PHILIO_SLIM_SENSOR_MOTION: WORKAROUND_NO_OFF_EVENT,
-    WENZHOU_SLIM_SENSOR_MOTION: WORKAROUND_NO_OFF_EVENT,
-}
-
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Z-Wave platform for binary sensors."""
@@ -40,43 +27,32 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     value = node.values[discovery_info[zwave.const.ATTR_VALUE_ID]]
     value.set_change_verified(False)
 
-    # Make sure that we have values for the key before converting to int
-    if (value.node.manufacturer_id.strip() and
-            value.node.product_id.strip()):
-        specific_sensor_key = (int(value.node.manufacturer_id, 16),
-                               int(value.node.product_id, 16),
-                               value.index)
+    device_mapping = workaround.get_device_mapping(value)
+    if device_mapping == workaround.WORKAROUND_NO_OFF_EVENT:
+        # Default the multiplier to 4
+        re_arm_multiplier = (zwave.get_config_value(value.node, 9) or 4)
+        add_devices([
+            ZWaveTriggerSensor(value, "motion",
+                               hass, re_arm_multiplier * 8)
+        ])
+        return
 
-        if specific_sensor_key in DEVICE_MAPPINGS:
-            if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_NO_OFF_EVENT:
-                # Default the multiplier to 4
-                re_arm_multiplier = (zwave.get_config_value(value.node,
-                                                            9) or 4)
-                add_devices([
-                    ZWaveTriggerSensor(value, "motion",
-                                       hass, re_arm_multiplier * 8)
-                ])
-                return
+    if workaround.get_device_component_mapping(value) == DOMAIN:
+        add_devices([ZWaveBinarySensor(value, None)])
+        return
 
     if value.command_class == zwave.const.COMMAND_CLASS_SENSOR_BINARY:
         add_devices([ZWaveBinarySensor(value, None)])
 
 
-class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity, Entity):
+class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
     """Representation of a binary sensor within Z-Wave."""
 
     def __init__(self, value, sensor_class):
         """Initialize the sensor."""
         self._sensor_type = sensor_class
-        # pylint: disable=import-error
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
-
         zwave.ZWaveDeviceEntity.__init__(self, value, DOMAIN)
 
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
-
     @property
     def is_on(self):
         """Return True if the binary sensor is on."""
@@ -92,39 +68,33 @@ class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity, Entity):
         """No polling needed."""
         return False
 
-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.update_ha_state()
 
-
-class ZWaveTriggerSensor(ZWaveBinarySensor, Entity):
+class ZWaveTriggerSensor(ZWaveBinarySensor):
     """Representation of a stateless sensor within Z-Wave."""
 
-    def __init__(self, sensor_value, sensor_class, hass, re_arm_sec=60):
+    def __init__(self, value, sensor_class, hass, re_arm_sec=60):
         """Initialize the sensor."""
-        super(ZWaveTriggerSensor, self).__init__(sensor_value, sensor_class)
+        super(ZWaveTriggerSensor, self).__init__(value, sensor_class)
         self._hass = hass
         self.re_arm_sec = re_arm_sec
         self.invalidate_after = dt_util.utcnow() + datetime.timedelta(
             seconds=self.re_arm_sec)
         # If it's active make sure that we set the timeout tracker
-        if sensor_value.data:
+        if value.data:
             track_point_in_time(
-                self._hass, self.update_ha_state,
+                self._hass, self.async_update_ha_state,
                 self.invalidate_after)
 
     def value_changed(self, value):
-        """Called when a value has changed on the network."""
+        """Called when a value for this entity's node has changed."""
         if self._value.value_id == value.value_id:
-            self.update_ha_state()
+            self.schedule_update_ha_state()
             if value.data:
                 # only allow this value to be true for re_arm secs
                 self.invalidate_after = dt_util.utcnow() + datetime.timedelta(
                     seconds=self.re_arm_sec)
                 track_point_in_time(
-                    self._hass, self.update_ha_state,
+                    self._hass, self.async_update_ha_state,
                     self.invalidate_after)
 
     @property

homeassistant/components/calendar/__init__.py

@@ -0,0 +1,186 @@
+"""
+Support for Google Calendar event device sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/calendar/
+
+"""
+import logging
+from datetime import timedelta
+
+import re
+
+from homeassistant.components.google import (CONF_OFFSET,
+                                             CONF_DEVICE_ID,
+                                             CONF_NAME)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.helpers.config_validation import time_period_str
+from homeassistant.helpers.entity import Entity, generate_entity_id
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.template import DATE_STR_FORMAT
+from homeassistant.util import dt
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=60)
+DOMAIN = 'calendar'
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+
+
+def setup(hass, config):
+    """Track states and offer events for calendars."""
+    component = EntityComponent(
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL, DOMAIN)
+
+    component.setup(config)
+
+    return True
+
+
+DEFAULT_CONF_TRACK_NEW = True
+DEFAULT_CONF_OFFSET = '!!'
+
+
+# pylint: disable=too-many-instance-attributes
+class CalendarEventDevice(Entity):
+    """A calendar event device."""
+
+    # Classes overloading this must set data to an object
+    # with an update() method
+    data = None
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, hass, data):
+        """Create the Calendar Event Device."""
+        self._name = data.get(CONF_NAME)
+        self.dev_id = data.get(CONF_DEVICE_ID)
+        self._offset = data.get(CONF_OFFSET, DEFAULT_CONF_OFFSET)
+        self.entity_id = generate_entity_id(ENTITY_ID_FORMAT,
+                                            self.dev_id,
+                                            hass=hass)
+
+        self._cal_data = {
+            'all_day': False,
+            'offset_time': dt.dt.timedelta(),
+            'message': '',
+            'start': None,
+            'end': None,
+            'location': '',
+            'description': '',
+        }
+
+        self.update()
+
+    def offset_reached(self):
+        """Have we reached the offset time specified in the event title."""
+        if self._cal_data['start'] is None or \
+           self._cal_data['offset_time'] == dt.dt.timedelta():
+            return False
+
+        return self._cal_data['start'] + self._cal_data['offset_time'] <= \
+            dt.now(self._cal_data['start'].tzinfo)
+
+    @property
+    def name(self):
+        """Return the name of the entity."""
+        return self._name
+
+    @property
+    def device_state_attributes(self):
+        """State Attributes for HA."""
+        start = self._cal_data.get('start', None)
+        end = self._cal_data.get('end', None)
+        start = start.strftime(DATE_STR_FORMAT) if start is not None else None
+        end = end.strftime(DATE_STR_FORMAT) if end is not None else None
+
+        return {
+            'message': self._cal_data.get('message', ''),
+            'all_day': self._cal_data.get('all_day', False),
+            'offset_reached': self.offset_reached(),
+            'start_time': start,
+            'end_time': end,
+            'location': self._cal_data.get('location', None),
+            'description': self._cal_data.get('description', None),
+        }
+
+    @property
+    def state(self):
+        """Return the state of the calendar event."""
+        start = self._cal_data.get('start', None)
+        end = self._cal_data.get('end', None)
+        if start is None or end is None:
+            return STATE_OFF
+
+        now = dt.now()
+
+        if start <= now and end > now:
+            return STATE_ON
+
+        if now >= end:
+            self.cleanup()
+
+        return STATE_OFF
+
+    def cleanup(self):
+        """Cleanup any start/end listeners that were setup."""
+        self._cal_data = {
+            'all_day': False,
+            'offset_time': 0,
+            'message': '',
+            'start': None,
+            'end': None,
+            'location': None,
+            'description': None
+        }
+
+    def update(self):
+        """Search for the next event."""
+        if not self.data or not self.data.update():
+            # update cached, don't do anything
+            return
+
+        if not self.data.event:
+            # we have no event to work on, make sure we're clean
+            self.cleanup()
+            return
+
+        def _get_date(date):
+            """Get the dateTime from date or dateTime as a local."""
+            if 'date' in date:
+                return dt.start_of_local_day(dt.dt.datetime.combine(
+                    dt.parse_date(date['date']), dt.dt.time.min))
+            else:
+                return dt.as_local(dt.parse_datetime(date['dateTime']))
+
+        start = _get_date(self.data.event['start'])
+        end = _get_date(self.data.event['end'])
+
+        summary = self.data.event['summary']
+
+        # check if we have an offset tag in the message
+        # time is HH:MM or MM
+        reg = '{}([+-]?[0-9]{{0,2}}(:[0-9]{{0,2}})?)'.format(self._offset)
+        search = re.search(reg, summary)
+        if search and search.group(1):
+            time = search.group(1)
+            if ':' not in time:
+                if time[0] == '+' or time[0] == '-':
+                    time = '{}0:{}'.format(time[0], time[1:])
+                else:
+                    time = '0:{}'.format(time)
+
+            offset_time = time_period_str(time)
+            summary = (summary[:search.start()] + summary[search.end():]) \
+                .strip()
+        else:
+            offset_time = dt.dt.timedelta()  # default it
+
+        # cleanup the string so we don't have a bunch of double+ spaces
+        self._cal_data['message'] = re.sub('  +', '', summary).strip()
+
+        self._cal_data['offset_time'] = offset_time
+        self._cal_data['location'] = self.data.event.get('location', '')
+        self._cal_data['description'] = self.data.event.get('description', '')
+        self._cal_data['start'] = start
+        self._cal_data['end'] = end
+        self._cal_data['all_day'] = 'date' in self.data.event['start']

homeassistant/components/calendar/demo.py

@@ -0,0 +1,82 @@
+"""
+Demo platform that has two fake binary sensors.
+
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/demo/
+"""
+import homeassistant.util.dt as dt_util
+from homeassistant.components.calendar import CalendarEventDevice
+from homeassistant.components.google import CONF_DEVICE_ID, CONF_NAME
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Demo binary sensor platform."""
+    calendar_data_future = DemoGoogleCalendarDataFuture()
+    calendar_data_current = DemoGoogleCalendarDataCurrent()
+    add_devices([
+        DemoGoogleCalendar(hass, calendar_data_future, {
+            CONF_NAME: 'Future Event',
+            CONF_DEVICE_ID: 'future_event',
+        }),
+
+        DemoGoogleCalendar(hass, calendar_data_current, {
+            CONF_NAME: 'Current Event',
+            CONF_DEVICE_ID: 'current_event',
+        }),
+    ])
+
+
+class DemoGoogleCalendarData(object):
+    """Setup base class for data."""
+
+    # pylint: disable=no-self-use
+    def update(self):
+        """Return true so entity knows we have new data."""
+        return True
+
+
+class DemoGoogleCalendarDataFuture(DemoGoogleCalendarData):
+    """Setup future data event."""
+
+    def __init__(self):
+        """Set the event to a future event."""
+        one_hour_from_now = dt_util.now() \
+            + dt_util.dt.timedelta(minutes=30)
+        self.event = {
+            'start': {
+                'dateTime': one_hour_from_now.isoformat()
+            },
+            'end': {
+                'dateTime': (one_hour_from_now + dt_util.dt.
+                             timedelta(minutes=60)).isoformat()
+            },
+            'summary': 'Future Event',
+        }
+
+
+class DemoGoogleCalendarDataCurrent(DemoGoogleCalendarData):
+    """Create a current event we're in the middle of."""
+
+    def __init__(self):
+        """Set the event data."""
+        middle_of_event = dt_util.now() \
+            - dt_util.dt.timedelta(minutes=30)
+        self.event = {
+            'start': {
+                'dateTime': middle_of_event.isoformat()
+            },
+            'end': {
+                'dateTime': (middle_of_event + dt_util.dt.
+                             timedelta(minutes=60)).isoformat()
+            },
+            'summary': 'Current Event',
+        }
+
+
+class DemoGoogleCalendar(CalendarEventDevice):
+    """A Demo binary sensor."""
+
+    def __init__(self, hass, calendar_data, data):
+        """The same as a google calendar but without the api calls."""
+        self.data = calendar_data
+        super().__init__(hass, data)

homeassistant/components/calendar/google.py

@@ -0,0 +1,79 @@
+"""
+Support for Google Calendar Search binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.google_calendar/
+"""
+# pylint: disable=import-error
+import logging
+from datetime import timedelta
+
+from homeassistant.components.calendar import CalendarEventDevice
+from homeassistant.components.google import (CONF_CAL_ID, CONF_ENTITIES,
+                                             CONF_TRACK, TOKEN_FILE,
+                                             GoogleCalendarService)
+from homeassistant.util import Throttle, dt
+
+DEFAULT_GOOGLE_SEARCH_PARAMS = {
+    'orderBy': 'startTime',
+    'maxResults': 1,
+    'singleEvents': True,
+}
+
+# Return cached results if last scan was less then this time ago
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, disc_info=None):
+    """Setup the calendar platform for event devices."""
+    if disc_info is None:
+        return
+
+    if not any([data[CONF_TRACK] for data in disc_info[CONF_ENTITIES]]):
+        return
+
+    calendar_service = GoogleCalendarService(hass.config.path(TOKEN_FILE))
+    add_devices([GoogleCalendarEventDevice(hass, calendar_service,
+                                           disc_info[CONF_CAL_ID], data)
+                 for data in disc_info[CONF_ENTITIES] if data[CONF_TRACK]])
+
+
+# pylint: disable=too-many-instance-attributes
+class GoogleCalendarEventDevice(CalendarEventDevice):
+    """A calendar event device."""
+
+    def __init__(self, hass, calendar_service, calendar, data):
+        """Create the Calendar event device."""
+        self.data = GoogleCalendarData(calendar_service, calendar,
+                                       data.get('search', None))
+        super().__init__(hass, data)
+
+
+class GoogleCalendarData(object):
+    """Class to utilize calendar service object to get next event."""
+
+    def __init__(self, calendar_service, calendar_id, search=None):
+        """Setup how we are going to search the google calendar."""
+        self.calendar_service = calendar_service
+        self.calendar_id = calendar_id
+        self.search = search
+        self.event = None
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data."""
+        service = self.calendar_service.get()
+        params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
+        params['timeMin'] = dt.start_of_local_day().isoformat('T')
+        params['calendarId'] = self.calendar_id
+        if self.search:
+            params['q'] = self.search
+
+        events = service.events()  # pylint: disable=no-member
+        result = events.list(**params).execute()
+
+        items = result.get('items', [])
+        self.event = items[0] if len(items) == 1 else None
+        return True

homeassistant/components/camera/__init__.py

@@ -6,18 +6,31 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/camera/
 """
 import asyncio
+import collections
+from datetime import timedelta
 import logging
+import hashlib
+from random import SystemRandom
 
+import aiohttp
 from aiohttp import web
+import async_timeout
 
+from homeassistant.core import callback
+from homeassistant.const import ATTR_ENTITY_PICTURE
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
-from homeassistant.components.http import HomeAssistantView
+from homeassistant.components.http import HomeAssistantView, KEY_AUTHENTICATED
+from homeassistant.helpers.event import async_track_time_interval
+
+_LOGGER = logging.getLogger(__name__)
 
 DOMAIN = 'camera'
 DEPENDENCIES = ['http']
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)
 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 
 STATE_RECORDING = 'recording'
@@ -26,17 +39,63 @@ STATE_IDLE = 'idle'
 
 ENTITY_IMAGE_URL = '/api/camera_proxy/{0}?token={1}'
 
+TOKEN_CHANGE_INTERVAL = timedelta(minutes=5)
+_RND = SystemRandom()
+
+
+@asyncio.coroutine
+def async_get_image(hass, entity_id, timeout=10):
+    """Fetch a image from a camera entity."""
+    websession = async_get_clientsession(hass)
+    state = hass.states.get(entity_id)
+
+    if state is None:
+        raise HomeAssistantError(
+            "No entity '{0}' for grab a image".format(entity_id))
+
+    url = "{0}{1}".format(
+        hass.config.api.base_url,
+        state.attributes.get(ATTR_ENTITY_PICTURE)
+    )
+
+    response = None
+    try:
+        with async_timeout.timeout(timeout, loop=hass.loop):
+            response = yield from websession.get(url)
+
+            if response.status != 200:
+                raise HomeAssistantError("Error {0} on {1}".format(
+                    response.status, url))
+
+            image = yield from response.read()
+            return image
+
+    except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+        raise HomeAssistantError("Can't connect to {0}".format(url))
+
+    finally:
+        if response is not None:
+            yield from response.release()
+
 
 @asyncio.coroutine
 def async_setup(hass, config):
     """Setup the camera component."""
-    component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
+    component = EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)
 
-    hass.http.register_view(CameraImageView(hass, component.entities))
-    hass.http.register_view(CameraMjpegStream(hass, component.entities))
+    hass.http.register_view(CameraImageView(component.entities))
+    hass.http.register_view(CameraMjpegStream(component.entities))
 
     yield from component.async_setup(config)
+
+    @callback
+    def update_tokens(time):
+        """Update tokens of the entities."""
+        for entity in component.entities.values():
+            entity.async_update_token()
+            hass.async_add_job(entity.async_update_ha_state())
+
+    async_track_time_interval(hass, update_tokens, TOKEN_CHANGE_INTERVAL)
     return True
 
 
@@ -46,11 +105,8 @@ class Camera(Entity):
     def __init__(self):
         """Initialize a camera."""
         self.is_streaming = False
-
-    @property
-    def access_token(self):
-        """Access token for this camera."""
-        return str(id(self))
+        self.access_tokens = collections.deque([], 2)
+        self.async_update_token()
 
     @property
     def should_poll(self):
@@ -60,7 +116,7 @@ class Camera(Entity):
     @property
     def entity_picture(self):
         """Return a link to the camera feed as entity picture."""
-        return ENTITY_IMAGE_URL.format(self.entity_id, self.access_token)
+        return ENTITY_IMAGE_URL.format(self.entity_id, self.access_tokens[-1])
 
     @property
     def is_recording(self):
@@ -81,15 +137,12 @@ class Camera(Entity):
         """Return bytes of camera image."""
         raise NotImplementedError()
 
-    @asyncio.coroutine
     def async_camera_image(self):
         """Return bytes of camera image.
 
-        This method must be run in the event loop.
+        This method must be run in the event loop and returns a coroutine.
         """
-        image = yield from self.hass.loop.run_in_executor(
-            None, self.camera_image)
-        return image
+        return self.hass.loop.run_in_executor(None, self.camera_image)
 
     @asyncio.coroutine
     def handle_async_mjpeg_stream(self, request):
@@ -101,7 +154,6 @@ class Camera(Entity):
 
         response.content_type = ('multipart/x-mixed-replace; '
                                  'boundary=--jpegboundary')
-        response.enable_chunked_encoding()
         yield from response.prepare(request)
 
         def write(img_bytes):
@@ -132,8 +184,14 @@ class Camera(Entity):
                     yield from response.drain()
 
                 yield from asyncio.sleep(.5)
+
+        except (asyncio.CancelledError, ConnectionResetError):
+            _LOGGER.debug("Close stream by frontend.")
+            response = None
+
         finally:
-            yield from response.write_eof()
+            if response is not None:
+                yield from response.write_eof()
 
     @property
     def state(self):
@@ -149,7 +207,7 @@ class Camera(Entity):
     def state_attributes(self):
         """Camera state attributes."""
         attr = {
-            'access_token': self.access_token,
+            'access_token': self.access_tokens[-1],
         }
 
         if self.model:
@@ -160,15 +218,21 @@ class Camera(Entity):
 
         return attr
 
+    @callback
+    def async_update_token(self):
+        """Update the used token."""
+        self.access_tokens.append(
+            hashlib.sha256(
+                _RND.getrandbits(256).to_bytes(32, 'little')).hexdigest())
+
 
 class CameraView(HomeAssistantView):
     """Base CameraView."""
 
     requires_auth = False
 
-    def __init__(self, hass, entities):
+    def __init__(self, entities):
         """Initialize a basic camera view."""
-        super().__init__(hass)
         self.entities = entities
 
     @asyncio.coroutine
@@ -177,10 +241,11 @@ class CameraView(HomeAssistantView):
         camera = self.entities.get(entity_id)
 
         if camera is None:
-            return web.Response(status=404)
+            status = 404 if request[KEY_AUTHENTICATED] else 401
+            return web.Response(status=status)
 
-        authenticated = (request.authenticated or
-                         request.GET.get('token') == camera.access_token)
+        authenticated = (request[KEY_AUTHENTICATED] or
+                         request.GET.get('token') in camera.access_tokens)
 
         if not authenticated:
             return web.Response(status=401)
@@ -203,12 +268,16 @@ class CameraImageView(CameraView):
     @asyncio.coroutine
     def handle(self, request, camera):
         """Serve camera image."""
-        image = yield from camera.async_camera_image()
+        try:
+            image = yield from camera.async_camera_image()
 
-        if image is None:
-            return web.Response(status=500)
+            if image is None:
+                return web.Response(status=500)
 
-        return web.Response(body=image)
+            return web.Response(body=image)
+
+        except asyncio.CancelledError:
+            _LOGGER.debug("Close stream by frontend.")
 
 
 class CameraMjpegStream(CameraView):

homeassistant/components/camera/amcrest.py

@@ -0,0 +1,133 @@
+"""
+This component provides basic support for Amcrest IP cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.amcrest/
+"""
+import asyncio
+import logging
+
+import aiohttp
+import voluptuous as vol
+
+import homeassistant.loader as loader
+from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
+from homeassistant.const import (
+    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_PORT)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import (
+    async_get_clientsession, async_aiohttp_proxy_stream)
+
+REQUIREMENTS = ['amcrest==1.1.4']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_RESOLUTION = 'resolution'
+CONF_STREAM_SOURCE = 'stream_source'
+
+DEFAULT_NAME = 'Amcrest Camera'
+DEFAULT_PORT = 80
+DEFAULT_RESOLUTION = 'high'
+DEFAULT_STREAM_SOURCE = 'mjpeg'
+
+NOTIFICATION_ID = 'amcrest_notification'
+NOTIFICATION_TITLE = 'Amcrest Camera Setup'
+
+RESOLUTION_LIST = {
+    'high': 0,
+    'low': 1,
+}
+
+STREAM_SOURCE_LIST = {
+    'mjpeg': 0,
+    'snapshot': 1
+}
+
+CONTENT_TYPE_HEADER = 'Content-Type'
+TIMEOUT = 5
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_RESOLUTION, default=DEFAULT_RESOLUTION):
+        vol.All(vol.In(RESOLUTION_LIST)),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_STREAM_SOURCE, default=DEFAULT_STREAM_SOURCE):
+        vol.All(vol.In(STREAM_SOURCE_LIST)),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up an Amcrest IP Camera."""
+    from amcrest import AmcrestCamera
+    camera = AmcrestCamera(
+        config.get(CONF_HOST), config.get(CONF_PORT),
+        config.get(CONF_USERNAME), config.get(CONF_PASSWORD)).camera
+
+    persistent_notification = loader.get_component('persistent_notification')
+    try:
+        camera.current_time
+    # pylint: disable=broad-except
+    except Exception as ex:
+        _LOGGER.error("Unable to connect to Amcrest camera: %s", str(ex))
+        persistent_notification.create(
+            hass, 'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+        return False
+
+    add_devices([AmcrestCam(hass, config, camera)])
+    return True
+
+
+class AmcrestCam(Camera):
+    """An implementation of an Amcrest IP camera."""
+
+    def __init__(self, hass, device_info, camera):
+        """Initialize an Amcrest camera."""
+        super(AmcrestCam, self).__init__()
+        self._camera = camera
+        self._base_url = self._camera.get_base_url()
+        self._hass = hass
+        self._name = device_info.get(CONF_NAME)
+        self._resolution = RESOLUTION_LIST[device_info.get(CONF_RESOLUTION)]
+        self._stream_source = STREAM_SOURCE_LIST[
+            device_info.get(CONF_STREAM_SOURCE)
+        ]
+        self._token = self._auth = aiohttp.BasicAuth(
+            device_info.get(CONF_USERNAME),
+            password=device_info.get(CONF_PASSWORD)
+        )
+
+    def camera_image(self):
+        """Return a still image reponse from the camera."""
+        # Send the request to snap a picture and return raw jpg data
+        response = self._camera.snapshot(channel=self._resolution)
+        return response.data
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Return an MJPEG stream."""
+        # The snapshot implementation is handled by the parent class
+        if self._stream_source == STREAM_SOURCE_LIST['snapshot']:
+            yield from super().handle_async_mjpeg_stream(request)
+            return
+
+        # Otherwise, stream an MJPEG image stream directly from the camera
+        websession = async_get_clientsession(self.hass)
+        streaming_url = '{0}mjpg/video.cgi?channel=0&subtype={1}'.format(
+            self._base_url, self._resolution)
+
+        stream_coro = websession.get(
+            streaming_url, auth=self._token, timeout=TIMEOUT)
+
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name

homeassistant/components/camera/ffmpeg.py

@@ -12,10 +12,9 @@ from aiohttp import web
 
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import (
-    async_run_test, get_binary, CONF_INPUT, CONF_EXTRA_ARGUMENTS)
+    DATA_FFMPEG, CONF_INPUT, CONF_EXTRA_ARGUMENTS)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.const import CONF_NAME
-from homeassistant.util.async import run_coroutine_threadsafe
 
 DEPENDENCIES = ['ffmpeg']
 
@@ -33,9 +32,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     """Setup a FFmpeg Camera."""
-    if not async_run_test(hass, config.get(CONF_INPUT)):
+    if not hass.data[DATA_FFMPEG].async_run_test(config.get(CONF_INPUT)):
         return
-    hass.loop.create_task(async_add_devices([FFmpegCamera(hass, config)]))
+    yield from async_add_devices([FFmpegCamera(hass, config)])
 
 
 class FFmpegCamera(Camera):
@@ -44,20 +43,17 @@ class FFmpegCamera(Camera):
     def __init__(self, hass, config):
         """Initialize a FFmpeg camera."""
         super().__init__()
+
+        self._manager = hass.data[DATA_FFMPEG]
         self._name = config.get(CONF_NAME)
         self._input = config.get(CONF_INPUT)
         self._extra_arguments = config.get(CONF_EXTRA_ARGUMENTS)
 
-    def camera_image(self):
-        """Return bytes of camera image."""
-        return run_coroutine_threadsafe(
-            self.async_camera_image(), self.hass.loop).result()
-
     @asyncio.coroutine
     def async_camera_image(self):
         """Return a still image response from the camera."""
-        from haffmpeg import ImageSingleAsync, IMAGE_JPEG
-        ffmpeg = ImageSingleAsync(get_binary(), loop=self.hass.loop)
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+        ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)
 
         image = yield from ffmpeg.get_image(
             self._input, output_format=IMAGE_JPEG,
@@ -67,15 +63,14 @@ class FFmpegCamera(Camera):
     @asyncio.coroutine
     def handle_async_mjpeg_stream(self, request):
         """Generate an HTTP MJPEG stream from the camera."""
-        from haffmpeg import CameraMjpegAsync
+        from haffmpeg import CameraMjpeg
 
-        stream = CameraMjpegAsync(get_binary(), loop=self.hass.loop)
+        stream = CameraMjpeg(self._manager.binary, loop=self.hass.loop)
         yield from stream.open_camera(
             self._input, extra_cmd=self._extra_arguments)
 
         response = web.StreamResponse()
         response.content_type = 'multipart/x-mixed-replace;boundary=ffserver'
-        response.enable_chunked_encoding()
 
         yield from response.prepare(request)
 
@@ -85,9 +80,15 @@ class FFmpegCamera(Camera):
                 if not data:
                     break
                 response.write(data)
+
+        except asyncio.CancelledError:
+            _LOGGER.debug("Close stream by frontend.")
+            response = None
+
         finally:
-            self.hass.loop.create_task(stream.close())
-            yield from response.write_eof()
+            yield from stream.close()
+            if response is not None:
+                yield from response.write_eof()
 
     @property
     def name(self):

homeassistant/components/camera/generic.py

@@ -18,6 +18,7 @@ from homeassistant.const import (
     HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.exceptions import TemplateError
 from homeassistant.components.camera import (PLATFORM_SCHEMA, Camera)
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers import config_validation as cv
 from homeassistant.util.async import run_coroutine_threadsafe
 
@@ -43,7 +44,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 # pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     """Setup a generic IP Camera."""
-    hass.loop.create_task(async_add_devices([GenericCamera(hass, config)]))
+    yield from async_add_devices([GenericCamera(hass, config)])
 
 
 class GenericCamera(Camera):
@@ -91,13 +92,12 @@ class GenericCamera(Camera):
         if url == self._last_url and self._limit_refetch:
             return self._last_image
 
-        # aiohttp don't support DigestAuth jet
+        # aiohttp don't support DigestAuth yet
         if self._authentication == HTTP_DIGEST_AUTHENTICATION:
             def fetch():
                 """Read image from a URL."""
                 try:
-                    kwargs = {'timeout': 10, 'auth': self._auth}
-                    response = requests.get(url, **kwargs)
+                    response = requests.get(url, timeout=10, auth=self._auth)
                     return response.content
                 except requests.exceptions.RequestException as error:
                     _LOGGER.error('Error getting camera image: %s', error)
@@ -107,17 +107,23 @@ class GenericCamera(Camera):
                 None, fetch)
         # async
         else:
+            response = None
             try:
+                websession = async_get_clientsession(self.hass)
                 with async_timeout.timeout(10, loop=self.hass.loop):
-                    respone = yield from self.hass.websession.get(
-                        url,
-                        auth=self._auth
-                    )
-                    self._last_image = yield from respone.read()
-                    yield from respone.release()
+                    response = yield from websession.get(
+                        url, auth=self._auth)
+                self._last_image = yield from response.read()
             except asyncio.TimeoutError:
                 _LOGGER.error('Timeout getting camera image')
                 return self._last_image
+            except (aiohttp.errors.ClientError,
+                    aiohttp.errors.ClientDisconnectedError) as err:
+                _LOGGER.error('Error getting new camera image: %s', err)
+                return self._last_image
+            finally:
+                if response is not None:
+                    self.hass.async_add_job(response.release())
 
         self._last_url = url
         return self._last_image

homeassistant/components/camera/mjpeg.py

@@ -9,8 +9,6 @@ import logging
 from contextlib import closing
 
 import aiohttp
-from aiohttp import web
-from aiohttp.web_exceptions import HTTPGatewayTimeout
 import async_timeout
 import requests
 from requests.auth import HTTPBasicAuth, HTTPDigestAuth
@@ -20,17 +18,21 @@ from homeassistant.const import (
     CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_AUTHENTICATION,
     HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera import (PLATFORM_SCHEMA, Camera)
+from homeassistant.helpers.aiohttp_client import (
+    async_get_clientsession, async_aiohttp_proxy_stream)
 from homeassistant.helpers import config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
 CONF_MJPEG_URL = 'mjpeg_url'
+CONF_STILL_IMAGE_URL = 'still_image_url'
 CONTENT_TYPE_HEADER = 'Content-Type'
 
 DEFAULT_NAME = 'Mjpeg Camera'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_MJPEG_URL): cv.url,
+    vol.Optional(CONF_STILL_IMAGE_URL): cv.url,
     vol.Optional(CONF_AUTHENTICATION, default=HTTP_BASIC_AUTHENTICATION):
         vol.In([HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION]),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -43,7 +45,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 # pylint: disable=unused-argument
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     """Setup a MJPEG IP Camera."""
-    hass.loop.create_task(async_add_devices([MjpegCamera(hass, config)]))
+    yield from async_add_devices([MjpegCamera(hass, config)])
 
 
 def extract_image_from_mjpeg(stream):
@@ -69,6 +71,7 @@ class MjpegCamera(Camera):
         self._username = device_info.get(CONF_USERNAME)
         self._password = device_info.get(CONF_PASSWORD)
         self._mjpeg_url = device_info[CONF_MJPEG_URL]
+        self._still_image_url = device_info.get(CONF_STILL_IMAGE_URL)
 
         self._auth = None
         if self._username and self._password:
@@ -77,6 +80,37 @@ class MjpegCamera(Camera):
                     self._username, password=self._password
                 )
 
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        # DigestAuth is not supported
+        if self._authentication == HTTP_DIGEST_AUTHENTICATION or \
+           self._still_image_url is None:
+            image = yield from self.hass.loop.run_in_executor(
+                None, self.camera_image)
+            return image
+
+        websession = async_get_clientsession(self.hass)
+        response = None
+        try:
+            with async_timeout.timeout(10, loop=self.hass.loop):
+                response = yield from websession.get(
+                    self._still_image_url, auth=self._auth)
+
+                image = yield from response.read()
+                return image
+
+        except asyncio.TimeoutError:
+            _LOGGER.error('Timeout getting camera image')
+
+        except (aiohttp.errors.ClientError,
+                aiohttp.errors.ClientDisconnectedError) as err:
+            _LOGGER.error('Error getting new camera image: %s', err)
+
+        finally:
+            if response is not None:
+                yield from response.release()
+
     def camera_image(self):
         """Return a still image response from the camera."""
         if self._username and self._password:
@@ -101,30 +135,10 @@ class MjpegCamera(Camera):
             return
 
         # connect to stream
-        try:
-            with async_timeout.timeout(10, loop=self.hass.loop):
-                stream = yield from self.hass.websession.get(
-                    self._mjpeg_url,
-                    auth=self._auth
-                )
-        except asyncio.TimeoutError:
-            raise HTTPGatewayTimeout()
+        websession = async_get_clientsession(self.hass)
+        stream_coro = websession.get(self._mjpeg_url, auth=self._auth)
 
-        response = web.StreamResponse()
-        response.content_type = stream.headers.get(CONTENT_TYPE_HEADER)
-        response.enable_chunked_encoding()
-
-        yield from response.prepare(request)
-
-        try:
-            while True:
-                data = yield from stream.content.read(102400)
-                if not data:
-                    break
-                response.write(data)
-        finally:
-            self.hass.loop.create_task(stream.release())
-            yield from response.write_eof()
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)
 
     @property
     def name(self):

homeassistant/components/camera/nest.py

@@ -0,0 +1,109 @@
+"""
+Support for Nest Cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.nest/
+"""
+import logging
+from datetime import timedelta
+
+import requests
+
+import homeassistant.components.nest as nest
+from homeassistant.components.camera import (PLATFORM_SCHEMA, Camera)
+from homeassistant.util.dt import utcnow
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['nest']
+
+NEST_BRAND = 'Nest'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a Nest Cam."""
+    if discovery_info is None:
+        return
+
+    camera_devices = hass.data[nest.DATA_NEST].cameras()
+    cameras = [NestCamera(structure, device)
+               for structure, device in camera_devices]
+    add_devices(cameras, True)
+
+
+class NestCamera(Camera):
+    """Representation of a Nest Camera."""
+
+    def __init__(self, structure, device):
+        """Initialize a Nest Camera."""
+        super(NestCamera, self).__init__()
+        self.structure = structure
+        self.device = device
+        self._location = None
+        self._name = None
+        self._online = None
+        self._is_streaming = None
+        self._is_video_history_enabled = False
+        # Default to non-NestAware subscribed, but will be fixed during update
+        self._time_between_snapshots = timedelta(seconds=30)
+        self._last_image = None
+        self._next_snapshot_at = None
+
+    @property
+    def name(self):
+        """Return the name of the nest, if any."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Nest camera should poll periodically."""
+        return True
+
+    @property
+    def is_recording(self):
+        """Return true if the device is recording."""
+        return self._is_streaming
+
+    @property
+    def brand(self):
+        """Return the brand of the camera."""
+        return NEST_BRAND
+
+    # This doesn't seem to be getting called regularly, for some reason
+    def update(self):
+        """Cache value from Python-nest."""
+        self._location = self.device.where
+        self._name = self.device.name
+        self._online = self.device.online
+        self._is_streaming = self.device.is_streaming
+        self._is_video_history_enabled = self.device.is_video_history_enabled
+
+        if self._is_video_history_enabled:
+            # NestAware allowed 10/min
+            self._time_between_snapshots = timedelta(seconds=6)
+        else:
+            # Otherwise, 2/min
+            self._time_between_snapshots = timedelta(seconds=30)
+
+    def _ready_for_snapshot(self, now):
+        return (self._next_snapshot_at is None or
+                now > self._next_snapshot_at)
+
+    def camera_image(self):
+        """Return a still image response from the camera."""
+        now = utcnow()
+        if self._ready_for_snapshot(now):
+            url = self.device.snapshot_url
+
+            try:
+                response = requests.get(url)
+            except requests.exceptions.RequestException as error:
+                _LOGGER.error("Error getting camera image: %s", error)
+                return None
+
+            self._next_snapshot_at = now + self._time_between_snapshots
+            self._last_image = response.content
+
+        return self._last_image

homeassistant/components/camera/netatmo.py

@@ -1,15 +1,16 @@
 """
-Support for the Netatmo Welcome camera.
+Support for the Netatmo cameras.
 
 For more details about this platform, please refer to the documentation at
-https://home-assistant.io/components/camera.netatmo/
+https://home-assistant.io/components/camera.netatmo/.
 """
 import logging
 
 import requests
 import voluptuous as vol
 
-from homeassistant.components.netatmo import WelcomeData
+from homeassistant.const import CONF_VERIFY_SSL
+from homeassistant.components.netatmo import CameraData
 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
 from homeassistant.loader import get_component
 from homeassistant.helpers import config_validation as cv
@@ -22,6 +23,7 @@ CONF_HOME = 'home'
 CONF_CAMERAS = 'cameras'
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
     vol.Optional(CONF_HOME): cv.string,
     vol.Optional(CONF_CAMERAS, default=[]):
         vol.All(cv.ensure_list, [cv.string]),
@@ -30,41 +32,46 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 
 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup access to Netatmo Welcome cameras."""
+    """Setup access to Netatmo cameras."""
     netatmo = get_component('netatmo')
     home = config.get(CONF_HOME)
+    verify_ssl = config.get(CONF_VERIFY_SSL, True)
     import lnetatmo
     try:
-        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        data = CameraData(netatmo.NETATMO_AUTH, home)
         for camera_name in data.get_camera_names():
+            camera_type = data.get_camera_type(camera=camera_name, home=home)
             if CONF_CAMERAS in config:
                 if config[CONF_CAMERAS] != [] and \
                    camera_name not in config[CONF_CAMERAS]:
                     continue
-            add_devices([WelcomeCamera(data, camera_name, home)])
+            add_devices([NetatmoCamera(data, camera_name, home,
+                                       camera_type, verify_ssl)])
     except lnetatmo.NoDevice:
         return None
 
 
-class WelcomeCamera(Camera):
-    """Representation of the images published from Welcome camera."""
+class NetatmoCamera(Camera):
+    """Representation of the images published from a Netatmo camera."""
 
-    def __init__(self, data, camera_name, home):
+    def __init__(self, data, camera_name, home, camera_type, verify_ssl):
         """Setup for access to the Netatmo camera images."""
-        super(WelcomeCamera, self).__init__()
+        super(NetatmoCamera, self).__init__()
         self._data = data
         self._camera_name = camera_name
+        self._verify_ssl = verify_ssl
         if home:
             self._name = home + ' / ' + camera_name
         else:
             self._name = camera_name
-        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+        camera_id = data.camera_data.cameraByName(camera=camera_name,
                                                   home=home)['id']
         self._unique_id = "Welcome_camera {0} - {1}".format(self._name,
                                                             camera_id)
-        self._vpnurl, self._localurl = self._data.welcomedata.cameraUrls(
+        self._vpnurl, self._localurl = self._data.camera_data.cameraUrls(
             camera=camera_name
             )
+        self._cameratype = camera_type
 
     def camera_image(self):
         """Return a still image response from the camera."""
@@ -72,22 +79,43 @@ class WelcomeCamera(Camera):
             if self._localurl:
                 response = requests.get('{0}/live/snapshot_720.jpg'.format(
                     self._localurl), timeout=10)
-            else:
+            elif self._vpnurl:
                 response = requests.get('{0}/live/snapshot_720.jpg'.format(
-                    self._vpnurl), timeout=10)
+                    self._vpnurl), timeout=10, verify=self._verify_ssl)
+            else:
+                _LOGGER.error('Welcome VPN url is None')
+                self._data.update()
+                (self._vpnurl, self._localurl) = \
+                    self._data.camera_data.cameraUrls(camera=self._camera_name)
+                return None
         except requests.exceptions.RequestException as error:
-            _LOGGER.error('Welcome VPN url changed: %s', error)
+            _LOGGER.error('Welcome url changed: %s', error)
             self._data.update()
             (self._vpnurl, self._localurl) = \
-                self._data.welcomedata.cameraUrls(camera=self._camera_name)
+                self._data.camera_data.cameraUrls(camera=self._camera_name)
             return None
         return response.content
 
     @property
     def name(self):
-        """Return the name of this Netatmo Welcome device."""
+        """Return the name of this Netatmo camera device."""
         return self._name
 
+    @property
+    def brand(self):
+        """Camera brand."""
+        return "Netatmo"
+
+    @property
+    def model(self):
+        """Camera model."""
+        if self._cameratype == "NOC":
+            return "Presence"
+        elif self._cameratype == "NACamera":
+            return "Welcome"
+        else:
+            return None
+
     @property
     def unique_id(self):
         """Return the unique ID for this sensor."""

homeassistant/components/camera/rpi_camera.py

@@ -39,7 +39,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_FILE_PATH): cv.string,
     vol.Optional(CONF_HORIZONTAL_FLIP, default=DEFAULT_HORIZONTAL_FLIP):
         vol.All(vol.Coerce(int), vol.Range(min=0, max=1)),
-    vol.Optional(CONF_IMAGE_HEIGHT, default=DEFAULT_HORIZONTAL_FLIP):
+    vol.Optional(CONF_IMAGE_HEIGHT, default=DEFAULT_IMAGE_HEIGHT):
         vol.Coerce(int),
     vol.Optional(CONF_IMAGE_QUALITY, default=DEFAULT_IMAGE_QUALITIY):
         vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),

homeassistant/components/camera/synology.py

@@ -9,8 +9,7 @@ import logging
 
 import voluptuous as vol
 
-from aiohttp import web
-from aiohttp.web_exceptions import HTTPGatewayTimeout
+import aiohttp
 import async_timeout
 
 from homeassistant.const import (
@@ -18,6 +17,9 @@ from homeassistant.const import (
     CONF_URL, CONF_WHITELIST, CONF_VERIFY_SSL)
 from homeassistant.components.camera import (
     Camera, PLATFORM_SCHEMA)
+from homeassistant.helpers.aiohttp_client import (
+    async_get_clientsession, async_create_clientsession,
+    async_aiohttp_proxy_stream)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util.async import run_coroutine_threadsafe
 
@@ -57,6 +59,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 @asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     """Setup a Synology IP Camera."""
+    verify_ssl = config.get(CONF_VERIFY_SSL)
+    websession_init = async_get_clientsession(hass, verify_ssl)
+
     # Determine API to use for authentication
     syno_api_url = SYNO_API_URL.format(
         config.get(CONF_URL), WEBAPI_PATH, QUERY_CGI)
@@ -67,25 +72,27 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
         'version': '1',
         'query': 'SYNO.'
     }
+    query_req = None
     try:
         with async_timeout.timeout(TIMEOUT, loop=hass.loop):
-            query_req = yield from hass.websession.get(
+            query_req = yield from websession_init.get(
                 syno_api_url,
-                params=query_payload,
-                verify_ssl=config.get(CONF_VERIFY_SSL)
+                params=query_payload
             )
-    except asyncio.TimeoutError:
-        _LOGGER.error("Timeout on %s", syno_api_url)
+
+        query_resp = yield from query_req.json()
+        auth_path = query_resp['data'][AUTH_API]['path']
+        camera_api = query_resp['data'][CAMERA_API]['path']
+        camera_path = query_resp['data'][CAMERA_API]['path']
+        streaming_path = query_resp['data'][STREAMING_API]['path']
+
+    except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+        _LOGGER.exception("Error on %s", syno_api_url)
         return False
 
-    query_resp = yield from query_req.json()
-    auth_path = query_resp['data'][AUTH_API]['path']
-    camera_api = query_resp['data'][CAMERA_API]['path']
-    camera_path = query_resp['data'][CAMERA_API]['path']
-    streaming_path = query_resp['data'][STREAMING_API]['path']
-
-    # cleanup
-    yield from query_req.release()
+    finally:
+        if query_req is not None:
+            yield from query_req.release()
 
     # Authticate to NAS to get a session id
     syno_auth_url = SYNO_API_URL.format(
@@ -93,12 +100,16 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 
     session_id = yield from get_session_id(
         hass,
+        websession_init,
         config.get(CONF_USERNAME),
         config.get(CONF_PASSWORD),
-        syno_auth_url,
-        config.get(CONF_VERIFY_SSL)
+        syno_auth_url
     )
 
+    # init websession
+    websession = async_create_clientsession(
+        hass, verify_ssl, cookies={'id': session_id})
+
     # Use SessionID to get cameras in system
     syno_camera_url = SYNO_API_URL.format(
         config.get(CONF_URL), WEBAPI_PATH, camera_api)
@@ -110,14 +121,12 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     }
     try:
         with async_timeout.timeout(TIMEOUT, loop=hass.loop):
-            camera_req = yield from hass.websession.get(
+            camera_req = yield from websession.get(
                 syno_camera_url,
-                params=camera_payload,
-                verify_ssl=config.get(CONF_VERIFY_SSL),
-                cookies={'id': session_id}
+                params=camera_payload
             )
-    except asyncio.TimeoutError:
-        _LOGGER.error("Timeout on %s", syno_camera_url)
+    except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+        _LOGGER.exception("Error on %s", syno_camera_url)
         return False
 
     camera_resp = yield from camera_req.json()
@@ -126,13 +135,14 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 
     # add cameras
     devices = []
-    tasks = []
     for camera in cameras:
         if not config.get(CONF_WHITELIST):
             camera_id = camera['id']
             snapshot_path = camera['snapshot_path']
 
             device = SynologyCamera(
+                hass,
+                websession,
                 config,
                 camera_id,
                 camera['name'],
@@ -141,15 +151,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                 camera_path,
                 auth_path
             )
-            tasks.append(device.async_read_sid())
             devices.append(device)
 
-    yield from asyncio.gather(*tasks, loop=hass.loop)
-    hass.loop.create_task(async_add_devices(devices))
+    yield from async_add_devices(devices)
 
 
 @asyncio.coroutine
-def get_session_id(hass, username, password, login_url, valid_cert):
+def get_session_id(hass, websession, username, password, login_url):
     """Get a session id."""
     auth_payload = {
         'api': AUTH_API,
@@ -160,56 +168,44 @@ def get_session_id(hass, username, password, login_url, valid_cert):
         'session': 'SurveillanceStation',
         'format': 'sid'
     }
+    auth_req = None
     try:
         with async_timeout.timeout(TIMEOUT, loop=hass.loop):
-            auth_req = yield from hass.websession.get(
+            auth_req = yield from websession.get(
                 login_url,
-                params=auth_payload,
-                verify_ssl=valid_cert
+                params=auth_payload
             )
-    except asyncio.TimeoutError:
-        _LOGGER.error("Timeout on %s", login_url)
+        auth_resp = yield from auth_req.json()
+        return auth_resp['data']['sid']
+
+    except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+        _LOGGER.exception("Error on %s", login_url)
         return False
 
-    auth_resp = yield from auth_req.json()
-    yield from auth_req.release()
-
-    return auth_resp['data']['sid']
+    finally:
+        if auth_req is not None:
+            yield from auth_req.release()
 
 
 class SynologyCamera(Camera):
     """An implementation of a Synology NAS based IP camera."""
 
-    def __init__(self, config, camera_id, camera_name,
-                 snapshot_path, streaming_path, camera_path, auth_path):
+    def __init__(self, hass, websession, config, camera_id,
+                 camera_name, snapshot_path, streaming_path, camera_path,
+                 auth_path):
         """Initialize a Synology Surveillance Station camera."""
         super().__init__()
+        self.hass = hass
+        self._websession = websession
         self._name = camera_name
-        self._username = config.get(CONF_USERNAME)
-        self._password = config.get(CONF_PASSWORD)
         self._synology_url = config.get(CONF_URL)
-        self._api_url = config.get(CONF_URL) + 'webapi/'
-        self._login_url = config.get(CONF_URL) + '/webapi/' + 'auth.cgi'
         self._camera_name = config.get(CONF_CAMERA_NAME)
         self._stream_id = config.get(CONF_STREAM_ID)
-        self._valid_cert = config.get(CONF_VERIFY_SSL)
         self._camera_id = camera_id
         self._snapshot_path = snapshot_path
         self._streaming_path = streaming_path
         self._camera_path = camera_path
         self._auth_path = auth_path
-        self._session_id = None
-
-    @asyncio.coroutine
-    def async_read_sid(self):
-        """Get a session id."""
-        self._session_id = yield from get_session_id(
-            self.hass,
-            self._username,
-            self._password,
-            self._login_url,
-            self._valid_cert
-        )
 
     def camera_image(self):
         """Return bytes of camera image."""
@@ -230,14 +226,12 @@ class SynologyCamera(Camera):
         }
         try:
             with async_timeout.timeout(TIMEOUT, loop=self.hass.loop):
-                response = yield from self.hass.websession.get(
+                response = yield from self._websession.get(
                     image_url,
-                    params=image_payload,
-                    verify_ssl=self._valid_cert,
-                    cookies={'id': self._session_id}
+                    params=image_payload
                 )
-        except asyncio.TimeoutError:
-            _LOGGER.error("Timeout on %s", image_url)
+        except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+            _LOGGER.exception("Error on %s", image_url)
             return None
 
         image = yield from response.read()
@@ -258,32 +252,10 @@ class SynologyCamera(Camera):
             'cameraId': self._camera_id,
             'format': 'mjpeg'
         }
-        try:
-            with async_timeout.timeout(TIMEOUT, loop=self.hass.loop):
-                stream = yield from self.hass.websession.get(
-                    streaming_url,
-                    payload=streaming_payload,
-                    verify_ssl=self._valid_cert,
-                    cookies={'id': self._session_id}
-                )
-        except asyncio.TimeoutError:
-            raise HTTPGatewayTimeout()
+        stream_coro = self._websession.get(
+            streaming_url, params=streaming_payload)
 
-        response = web.StreamResponse()
-        response.content_type = stream.headers.get(CONTENT_TYPE_HEADER)
-        response.enable_chunked_encoding()
-
-        yield from response.prepare(request)
-
-        try:
-            while True:
-                data = yield from stream.content.read(102400)
-                if not data:
-                    break
-                response.write(data)
-        finally:
-            self.hass.loop.create_task(stream.release())
-            yield from response.write_eof()
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)
 
     @property
     def name(self):

homeassistant/components/camera/uvc.py

@@ -14,7 +14,7 @@ from homeassistant.const import CONF_PORT
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['uvcclient==0.9.0']
+REQUIREMENTS = ['uvcclient==0.10.0']
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/climate/__init__.py

@@ -4,15 +4,18 @@ Provides functionality to interact with climate devices.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/climate/
 """
+import asyncio
+from datetime import timedelta
 import logging
 import os
+import functools as ft
 from numbers import Number
-import voluptuous as vol
 
-from homeassistant.helpers.entity_component import EntityComponent
+import voluptuous as vol
 
 from homeassistant.config import load_yaml_config_file
 from homeassistant.util.temperature import convert as convert_temperature
+from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
@@ -23,12 +26,13 @@ from homeassistant.const import (
 DOMAIN = "climate"
 
 ENTITY_ID_FORMAT = DOMAIN + ".{}"
-SCAN_INTERVAL = 60
+SCAN_INTERVAL = timedelta(seconds=60)
 
 SERVICE_SET_AWAY_MODE = "set_away_mode"
 SERVICE_SET_AUX_HEAT = "set_aux_heat"
 SERVICE_SET_TEMPERATURE = "set_temperature"
 SERVICE_SET_FAN_MODE = "set_fan_mode"
+SERVICE_SET_HOLD_MODE = "set_hold_mode"
 SERVICE_SET_OPERATION_MODE = "set_operation_mode"
 SERVICE_SET_SWING_MODE = "set_swing_mode"
 SERVICE_SET_HUMIDITY = "set_humidity"
@@ -53,11 +57,17 @@ ATTR_CURRENT_HUMIDITY = "current_humidity"
 ATTR_HUMIDITY = "humidity"
 ATTR_MAX_HUMIDITY = "max_humidity"
 ATTR_MIN_HUMIDITY = "min_humidity"
+ATTR_HOLD_MODE = "hold_mode"
 ATTR_OPERATION_MODE = "operation_mode"
 ATTR_OPERATION_LIST = "operation_list"
 ATTR_SWING_MODE = "swing_mode"
 ATTR_SWING_LIST = "swing_list"
 
+# The degree of precision for each platform
+PRECISION_WHOLE = 1
+PRECISION_HALVES = 0.5
+PRECISION_TENTHS = 0.1
+
 CONVERTIBLE_ATTRIBUTE = [
     ATTR_TEMPERATURE,
     ATTR_TARGET_TEMP_LOW,
@@ -85,6 +95,10 @@ SET_FAN_MODE_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Required(ATTR_FAN_MODE): cv.string,
 })
+SET_HOLD_MODE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_HOLD_MODE): cv.string,
+})
 SET_OPERATION_MODE_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Required(ATTR_OPERATION_MODE): cv.string,
@@ -111,6 +125,18 @@ def set_away_mode(hass, away_mode, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_AWAY_MODE, data)
 
 
+def set_hold_mode(hass, hold_mode, entity_id=None):
+    """Set new hold mode."""
+    data = {
+        ATTR_HOLD_MODE: hold_mode
+    }
+
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_SET_HOLD_MODE, data)
+
+
 def set_aux_heat(hass, aux_heat, entity_id=None):
     """Turn all or specified climate devices auxillary heater on."""
     data = {
@@ -180,69 +206,95 @@ def set_swing_mode(hass, swing_mode, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_SET_SWING_MODE, data)
 
 
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Setup climate devices."""
     component = EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)
-    component.setup(config)
+    yield from component.async_setup(config)
 
-    descriptions = load_yaml_config_file(
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file,
         os.path.join(os.path.dirname(__file__), 'services.yaml'))
 
-    def away_mode_set_service(service):
+    @asyncio.coroutine
+    def _async_update_climate(target_climate):
+        """Update climate entity after service stuff."""
+        update_tasks = []
+        for climate in target_climate:
+            if not climate.should_poll:
+                continue
+
+            update_coro = hass.loop.create_task(
+                climate.async_update_ha_state(True))
+            if hasattr(climate, 'async_update'):
+                update_tasks.append(update_coro)
+            else:
+                yield from update_coro
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    @asyncio.coroutine
+    def async_away_mode_set_service(service):
         """Set away mode on target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         away_mode = service.data.get(ATTR_AWAY_MODE)
 
-        if away_mode is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_AWAY_MODE, ATTR_AWAY_MODE)
-            return
-
         for climate in target_climate:
             if away_mode:
-                climate.turn_away_mode_on()
+                yield from climate.async_turn_away_mode_on()
             else:
-                climate.turn_away_mode_off()
+                yield from climate.async_turn_away_mode_off()
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_AWAY_MODE, away_mode_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_AWAY_MODE, async_away_mode_set_service,
         descriptions.get(SERVICE_SET_AWAY_MODE),
         schema=SET_AWAY_MODE_SCHEMA)
 
-    def aux_heat_set_service(service):
+    @asyncio.coroutine
+    def async_hold_mode_set_service(service):
+        """Set hold mode on target climate devices."""
+        target_climate = component.async_extract_from_service(service)
+
+        hold_mode = service.data.get(ATTR_HOLD_MODE)
+
+        for climate in target_climate:
+            yield from climate.async_set_hold_mode(hold_mode)
+
+        yield from _async_update_climate(target_climate)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_HOLD_MODE, async_hold_mode_set_service,
+        descriptions.get(SERVICE_SET_HOLD_MODE),
+        schema=SET_HOLD_MODE_SCHEMA)
+
+    @asyncio.coroutine
+    def async_aux_heat_set_service(service):
         """Set auxillary heater on target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         aux_heat = service.data.get(ATTR_AUX_HEAT)
 
-        if aux_heat is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_AUX_HEAT, ATTR_AUX_HEAT)
-            return
-
         for climate in target_climate:
             if aux_heat:
-                climate.turn_aux_heat_on()
+                yield from climate.async_turn_aux_heat_on()
             else:
-                climate.turn_aux_heat_off()
+                yield from climate.async_turn_aux_heat_off()
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_AUX_HEAT, aux_heat_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_AUX_HEAT, async_aux_heat_set_service,
         descriptions.get(SERVICE_SET_AUX_HEAT),
         schema=SET_AUX_HEAT_SCHEMA)
 
-    def temperature_set_service(service):
+    @asyncio.coroutine
+    def async_temperature_set_service(service):
         """Set temperature on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         for climate in target_climate:
             kwargs = {}
@@ -256,106 +308,83 @@ def setup(hass, config):
                 else:
                     kwargs[value] = temp
 
-            climate.set_temperature(**kwargs)
-            if climate.should_poll:
-                climate.update_ha_state(True)
+            yield from climate.async_set_temperature(**kwargs)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_TEMPERATURE, temperature_set_service,
+        yield from _async_update_climate(target_climate)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_TEMPERATURE, async_temperature_set_service,
         descriptions.get(SERVICE_SET_TEMPERATURE),
         schema=SET_TEMPERATURE_SCHEMA)
 
-    def humidity_set_service(service):
+    @asyncio.coroutine
+    def async_humidity_set_service(service):
         """Set humidity on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         humidity = service.data.get(ATTR_HUMIDITY)
 
-        if humidity is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_HUMIDITY, ATTR_HUMIDITY)
-            return
-
         for climate in target_climate:
-            climate.set_humidity(humidity)
+            yield from climate.async_set_humidity(humidity)
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_HUMIDITY, humidity_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_HUMIDITY, async_humidity_set_service,
         descriptions.get(SERVICE_SET_HUMIDITY),
         schema=SET_HUMIDITY_SCHEMA)
 
-    def fan_mode_set_service(service):
+    @asyncio.coroutine
+    def async_fan_mode_set_service(service):
         """Set fan mode on target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         fan = service.data.get(ATTR_FAN_MODE)
 
-        if fan is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_FAN_MODE, ATTR_FAN_MODE)
-            return
-
         for climate in target_climate:
-            climate.set_fan_mode(fan)
+            yield from climate.async_set_fan_mode(fan)
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_FAN_MODE, fan_mode_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_FAN_MODE, async_fan_mode_set_service,
         descriptions.get(SERVICE_SET_FAN_MODE),
         schema=SET_FAN_MODE_SCHEMA)
 
-    def operation_set_service(service):
+    @asyncio.coroutine
+    def async_operation_set_service(service):
         """Set operating mode on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         operation_mode = service.data.get(ATTR_OPERATION_MODE)
 
-        if operation_mode is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_OPERATION_MODE, ATTR_OPERATION_MODE)
-            return
-
         for climate in target_climate:
-            climate.set_operation_mode(operation_mode)
+            yield from climate.async_set_operation_mode(operation_mode)
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_OPERATION_MODE, operation_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_OPERATION_MODE, async_operation_set_service,
         descriptions.get(SERVICE_SET_OPERATION_MODE),
         schema=SET_OPERATION_MODE_SCHEMA)
 
-    def swing_set_service(service):
+    @asyncio.coroutine
+    def async_swing_set_service(service):
         """Set swing mode on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)
 
         swing_mode = service.data.get(ATTR_SWING_MODE)
 
-        if swing_mode is None:
-            _LOGGER.error(
-                "Received call to %s without attribute %s",
-                SERVICE_SET_SWING_MODE, ATTR_SWING_MODE)
-            return
-
         for climate in target_climate:
-            climate.set_swing_mode(swing_mode)
+            yield from climate.async_set_swing_mode(swing_mode)
 
-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)
 
-    hass.services.register(
-        DOMAIN, SERVICE_SET_SWING_MODE, swing_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_SWING_MODE, async_swing_set_service,
         descriptions.get(SERVICE_SET_SWING_MODE),
         schema=SET_SWING_MODE_SCHEMA)
+
     return True
 
 
@@ -371,6 +400,14 @@ class ClimateDevice(Entity):
         else:
             return STATE_UNKNOWN
 
+    @property
+    def precision(self):
+        """Return the precision of the system."""
+        if self.unit_of_measurement == TEMP_CELSIUS:
+            return PRECISION_TENTHS
+        else:
+            return PRECISION_WHOLE
+
     @property
     def state_attributes(self):
         """Return the optional state attributes."""
@@ -408,6 +445,10 @@ class ClimateDevice(Entity):
             if self.operation_list:
                 data[ATTR_OPERATION_LIST] = self.operation_list
 
+        is_hold = self.current_hold_mode
+        if is_hold is not None:
+            data[ATTR_HOLD_MODE] = is_hold
+
         swing_mode = self.current_swing_mode
         if swing_mode is not None:
             data[ATTR_SWING_MODE] = swing_mode
@@ -479,6 +520,11 @@ class ClimateDevice(Entity):
         """Return true if away mode is on."""
         return None
 
+    @property
+    def current_hold_mode(self):
+        """Return the current hold mode, e.g., home, away, temp."""
+        return None
+
     @property
     def is_aux_heat_on(self):
         """Return true if aux heater."""
@@ -508,38 +554,122 @@ class ClimateDevice(Entity):
         """Set new target temperature."""
         raise NotImplementedError()
 
+    def async_set_temperature(self, **kwargs):
+        """Set new target temperature.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.set_temperature, **kwargs))
+
     def set_humidity(self, humidity):
         """Set new target humidity."""
         raise NotImplementedError()
 
+    def async_set_humidity(self, humidity):
+        """Set new target humidity.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_humidity, humidity)
+
     def set_fan_mode(self, fan):
         """Set new target fan mode."""
         raise NotImplementedError()
 
+    def async_set_fan_mode(self, fan):
+        """Set new target fan mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_fan_mode, fan)
+
     def set_operation_mode(self, operation_mode):
         """Set new target operation mode."""
         raise NotImplementedError()
 
+    def async_set_operation_mode(self, operation_mode):
+        """Set new target operation mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_operation_mode, operation_mode)
+
     def set_swing_mode(self, swing_mode):
         """Set new target swing operation."""
         raise NotImplementedError()
 
+    def async_set_swing_mode(self, swing_mode):
+        """Set new target swing operation.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_swing_mode, swing_mode)
+
     def turn_away_mode_on(self):
         """Turn away mode on."""
         raise NotImplementedError()
 
+    def async_turn_away_mode_on(self):
+        """Turn away mode on.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_away_mode_on)
+
     def turn_away_mode_off(self):
         """Turn away mode off."""
         raise NotImplementedError()
 
+    def async_turn_away_mode_off(self):
+        """Turn away mode off.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_away_mode_off)
+
+    def set_hold_mode(self, hold_mode):
+        """Set new target hold mode."""
+        raise NotImplementedError()
+
+    def async_set_hold_mode(self, hold_mode):
+        """Set new target hold mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_hold_mode, hold_mode)
+
     def turn_aux_heat_on(self):
         """Turn auxillary heater on."""
         raise NotImplementedError()
 
+    def async_turn_aux_heat_on(self):
+        """Turn auxillary heater on.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_aux_heat_on)
+
     def turn_aux_heat_off(self):
         """Turn auxillary heater off."""
         raise NotImplementedError()
 
+    def async_turn_aux_heat_off(self):
+        """Turn auxillary heater off.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_aux_heat_off)
+
     @property
     def min_temp(self):
         """Return the minimum temperature."""
@@ -562,16 +692,18 @@ class ClimateDevice(Entity):
 
     def _convert_for_display(self, temp):
         """Convert temperature into preferred units for display purposes."""
-        if temp is None or not isinstance(temp, Number):
+        if (temp is None or not isinstance(temp, Number) or
+                self.temperature_unit == self.unit_of_measurement):
             return temp
 
         value = convert_temperature(temp, self.temperature_unit,
                                     self.unit_of_measurement)
 
-        if self.unit_of_measurement is TEMP_CELSIUS:
-            decimal_count = 1
+        # Round in the units appropriate
+        if self.precision == PRECISION_HALVES:
+            return round(value * 2) / 2.0
+        elif self.precision == PRECISION_TENTHS:
+            return round(value, 1)
         else:
-            # Users of fahrenheit generally expect integer units.
-            decimal_count = 0
-
-        return round(value, decimal_count)
+            # PRECISION_WHOLE as a fall back
+            return round(value)

homeassistant/components/climate/demo.py

@@ -12,11 +12,11 @@ from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Demo climate devices."""
     add_devices([
-        DemoClimate("HeatPump", 68, TEMP_FAHRENHEIT, None, 77, "Auto Low",
-                    None, None, "Auto", "heat", None, None, None),
-        DemoClimate("Hvac", 21, TEMP_CELSIUS, True, 22, "On High",
+        DemoClimate("HeatPump", 68, TEMP_FAHRENHEIT, None, None, 77,
+                    "Auto Low", None, None, "Auto", "heat", None, None, None),
+        DemoClimate("Hvac", 21, TEMP_CELSIUS, True, None, 22, "On High",
                     67, 54, "Off", "cool", False, None, None),
-        DemoClimate("Ecobee", None, TEMP_CELSIUS, None, 23, "Auto Low",
+        DemoClimate("Ecobee", None, TEMP_CELSIUS, None, None, 23, "Auto Low",
                     None, None, "Auto", "auto", None, 24, 21)
     ])
 
@@ -25,7 +25,7 @@ class DemoClimate(ClimateDevice):
     """Representation of a demo climate device."""
 
     def __init__(self, name, target_temperature, unit_of_measurement,
-                 away, current_temperature, current_fan_mode,
+                 away, hold, current_temperature, current_fan_mode,
                  target_humidity, current_humidity, current_swing_mode,
                  current_operation, aux, target_temp_high, target_temp_low):
         """Initialize the climate device."""
@@ -34,6 +34,7 @@ class DemoClimate(ClimateDevice):
         self._target_humidity = target_humidity
         self._unit_of_measurement = unit_of_measurement
         self._away = away
+        self._hold = hold
         self._current_temperature = current_temperature
         self._current_humidity = current_humidity
         self._current_fan_mode = current_fan_mode
@@ -106,6 +107,11 @@ class DemoClimate(ClimateDevice):
         """Return if away mode is on."""
         return self._away
 
+    @property
+    def current_hold_mode(self):
+        """Return hold mode setting."""
+        return self._hold
+
     @property
     def is_aux_heat_on(self):
         """Return true if away mode is on."""
@@ -129,27 +135,27 @@ class DemoClimate(ClimateDevice):
            kwargs.get(ATTR_TARGET_TEMP_LOW) is not None:
             self._target_temperature_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
             self._target_temperature_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def set_humidity(self, humidity):
         """Set new target temperature."""
         self._target_humidity = humidity
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def set_swing_mode(self, swing_mode):
         """Set new target temperature."""
         self._current_swing_mode = swing_mode
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def set_fan_mode(self, fan):
         """Set new target temperature."""
         self._current_fan_mode = fan
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def set_operation_mode(self, operation_mode):
         """Set new target temperature."""
         self._current_operation = operation_mode
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     @property
     def current_swing_mode(self):
@@ -164,19 +170,24 @@ class DemoClimate(ClimateDevice):
     def turn_away_mode_on(self):
         """Turn away mode on."""
         self._away = True
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def turn_away_mode_off(self):
         """Turn away mode off."""
         self._away = False
-        self.update_ha_state()
+        self.schedule_update_ha_state()
+
+    def set_hold_mode(self, hold):
+        """Update hold mode on."""
+        self._hold = hold
+        self.schedule_update_ha_state()
 
     def turn_aux_heat_on(self):
         """Turn away auxillary heater on."""
         self._aux = True
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def turn_aux_heat_off(self):
         """Turn auxillary heater off."""
         self._aux = False
-        self.update_ha_state()
+        self.schedule_update_ha_state()

homeassistant/components/climate/ecobee.py

@@ -11,10 +11,10 @@ import voluptuous as vol
 
 from homeassistant.components import ecobee
 from homeassistant.components.climate import (
-    DOMAIN, STATE_COOL, STATE_HEAT, STATE_IDLE, ClimateDevice,
+    DOMAIN, STATE_COOL, STATE_HEAT, STATE_AUTO, STATE_IDLE, ClimateDevice,
     ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH)
 from homeassistant.const import (
-    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, TEMP_FAHRENHEIT)
+    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, ATTR_TEMPERATURE, TEMP_FAHRENHEIT)
 from homeassistant.config import load_yaml_config_file
 import homeassistant.helpers.config_validation as cv
 
@@ -22,16 +22,25 @@ _CONFIGURING = {}
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_FAN_MIN_ON_TIME = 'fan_min_on_time'
+ATTR_RESUME_ALL = 'resume_all'
+
+DEFAULT_RESUME_ALL = False
 
 DEPENDENCIES = ['ecobee']
 
 SERVICE_SET_FAN_MIN_ON_TIME = 'ecobee_set_fan_min_on_time'
+SERVICE_RESUME_PROGRAM = 'ecobee_resume_program'
 
 SET_FAN_MIN_ON_TIME_SCHEMA = vol.Schema({
     vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
     vol.Required(ATTR_FAN_MIN_ON_TIME): vol.Coerce(int),
 })
 
+RESUME_PROGRAM_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Optional(ATTR_RESUME_ALL, default=DEFAULT_RESUME_ALL): cv.boolean,
+})
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Ecobee Thermostat Platform."""
@@ -48,20 +57,35 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     def fan_min_on_time_set_service(service):
         """Set the minimum fan on time on the target thermostats."""
-        entity_id = service.data.get('entity_id')
+        entity_id = service.data.get(ATTR_ENTITY_ID)
+        fan_min_on_time = service.data[ATTR_FAN_MIN_ON_TIME]
 
         if entity_id:
             target_thermostats = [device for device in devices
-                                  if device.entity_id == entity_id]
+                                  if device.entity_id in entity_id]
         else:
             target_thermostats = devices
 
-        fan_min_on_time = service.data[ATTR_FAN_MIN_ON_TIME]
-
         for thermostat in target_thermostats:
             thermostat.set_fan_min_on_time(str(fan_min_on_time))
 
-            thermostat.update_ha_state(True)
+            thermostat.schedule_update_ha_state(True)
+
+    def resume_program_set_service(service):
+        """Resume the program on the target thermostats."""
+        entity_id = service.data.get(ATTR_ENTITY_ID)
+        resume_all = service.data.get(ATTR_RESUME_ALL)
+
+        if entity_id:
+            target_thermostats = [device for device in devices
+                                  if device.entity_id in entity_id]
+        else:
+            target_thermostats = devices
+
+        for thermostat in target_thermostats:
+            thermostat.resume_program(resume_all)
+
+            thermostat.schedule_update_ha_state(True)
 
     descriptions = load_yaml_config_file(
         path.join(path.dirname(__file__), 'services.yaml'))
@@ -71,6 +95,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         descriptions.get(SERVICE_SET_FAN_MIN_ON_TIME),
         schema=SET_FAN_MIN_ON_TIME_SCHEMA)
 
+    hass.services.register(
+        DOMAIN, SERVICE_RESUME_PROGRAM, resume_program_set_service,
+        descriptions.get(SERVICE_RESUME_PROGRAM),
+        schema=RESUME_PROGRAM_SCHEMA)
+
 
 class Thermostat(ClimateDevice):
     """A thermostat class for Ecobee."""
@@ -116,12 +145,30 @@ class Thermostat(ClimateDevice):
     @property
     def target_temperature_low(self):
         """Return the lower bound temperature we try to reach."""
-        return int(self.thermostat['runtime']['desiredHeat'] / 10)
+        if self.current_operation == STATE_AUTO:
+            return int(self.thermostat['runtime']['desiredHeat'] / 10)
+        else:
+            return None
 
     @property
     def target_temperature_high(self):
         """Return the upper bound temperature we try to reach."""
-        return int(self.thermostat['runtime']['desiredCool'] / 10)
+        if self.current_operation == STATE_AUTO:
+            return int(self.thermostat['runtime']['desiredCool'] / 10)
+        else:
+            return None
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        if self.current_operation == STATE_AUTO:
+            return None
+        if self.current_operation == STATE_HEAT:
+            return int(self.thermostat['runtime']['desiredHeat'] / 10)
+        elif self.current_operation == STATE_COOL:
+            return int(self.thermostat['runtime']['desiredCool'] / 10)
+        else:
+            return None
 
     @property
     def desired_fan_mode(self):
@@ -136,6 +183,34 @@ class Thermostat(ClimateDevice):
         else:
             return STATE_OFF
 
+    @property
+    def current_hold_mode(self):
+        """Return current hold mode."""
+        events = self.thermostat['events']
+        if any((event['holdClimateRef'] == 'away' and
+                int(event['endDate'][0:4])-int(event['startDate'][0:4]) <= 1)
+               or event['type'] == 'autoAway'
+               for event in events):
+            # away hold is auto away or a temporary hold from away climate
+            hold = 'away'
+        elif any(event['holdClimateRef'] == 'away' and
+                 int(event['endDate'][0:4])-int(event['startDate'][0:4]) > 1
+                 for event in events):
+            # a permanent away is not considered a hold, but away_mode
+            hold = None
+        elif any(event['holdClimateRef'] == 'home' or
+                 event['type'] == 'autoHome'
+                 for event in events):
+            # home mode is auto home or any home hold
+            hold = 'home'
+        elif any(event['type'] == 'hold' and event['running']
+                 for event in events):
+            hold = 'temp'
+            # temperature hold is any other hold not based on climate
+        else:
+            hold = None
+        return hold
+
     @property
     def current_operation(self):
         """Return current operation."""
@@ -189,24 +264,24 @@ class Thermostat(ClimateDevice):
             "fan_min_on_time": self.fan_min_on_time
         }
 
+    def is_vacation_on(self):
+        """Return true if vacation mode is on."""
+        events = self.thermostat['events']
+        return any(event['type'] == 'vacation' and event['running']
+                   for event in events)
+
     @property
     def is_away_mode_on(self):
         """Return true if away mode is on."""
-        mode = self.mode
         events = self.thermostat['events']
-        for event in events:
-            if event['running']:
-                mode = event['holdClimateRef']
-                break
-        return 'away' in mode
+        return any(event['holdClimateRef'] == 'away' and
+                   int(event['endDate'][0:4])-int(event['startDate'][0:4]) > 1
+                   for event in events)
 
     def turn_away_mode_on(self):
         """Turn away on."""
-        if self.hold_temp:
-            self.data.ecobee.set_climate_hold(self.thermostat_index,
-                                              "away", "indefinite")
-        else:
-            self.data.ecobee.set_climate_hold(self.thermostat_index, "away")
+        self.data.ecobee.set_climate_hold(self.thermostat_index,
+                                          "away", 'indefinite')
         self.update_without_throttle = True
 
     def turn_away_mode_off(self):
@@ -214,28 +289,69 @@ class Thermostat(ClimateDevice):
         self.data.ecobee.resume_program(self.thermostat_index)
         self.update_without_throttle = True
 
+    def set_hold_mode(self, hold_mode):
+        """Set hold mode (away, home, temp)."""
+        hold = self.current_hold_mode
+
+        if hold == hold_mode:
+            # no change, so no action required
+            return
+        elif hold_mode == 'away':
+            self.data.ecobee.set_climate_hold(self.thermostat_index,
+                                              "away", self.hold_preference())
+        elif hold_mode == 'home':
+            self.data.ecobee.set_climate_hold(self.thermostat_index,
+                                              "home", self.hold_preference())
+        elif hold_mode == 'temp':
+            self.set_temp_hold(int(self.current_temperature))
+        else:
+            self.data.ecobee.resume_program(self.thermostat_index)
+            self.update_without_throttle = True
+
+    def set_auto_temp_hold(self, heat_temp, cool_temp):
+        """Set temperature hold in auto mode."""
+        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
+                                       heat_temp, self.hold_preference())
+        _LOGGER.debug("Setting ecobee hold_temp to: heat=%s, is=%s, "
+                      "cool=%s, is=%s", heat_temp, isinstance(
+                          heat_temp, (int, float)), cool_temp,
+                      isinstance(cool_temp, (int, float)))
+
+        self.update_without_throttle = True
+
+    def set_temp_hold(self, temp):
+        """Set temperature hold in modes other than auto."""
+        # Set arbitrary range when not in auto mode
+        if self.current_operation == STATE_HEAT:
+            heat_temp = temp
+            cool_temp = temp + 20
+        elif self.current_operation == STATE_COOL:
+            heat_temp = temp - 20
+            cool_temp = temp
+
+        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
+                                       heat_temp, self.hold_preference())
+        _LOGGER.debug("Setting ecobee hold_temp to: low=%s, is=%s, "
+                      "cool=%s, is=%s", heat_temp, isinstance(
+                          heat_temp, (int, float)), cool_temp,
+                      isinstance(cool_temp, (int, float)))
+
+        self.update_without_throttle = True
+
     def set_temperature(self, **kwargs):
         """Set new target temperature."""
-        if kwargs.get(ATTR_TARGET_TEMP_LOW) is not None and \
-           kwargs.get(ATTR_TARGET_TEMP_HIGH) is not None:
-            high_temp = int(kwargs.get(ATTR_TARGET_TEMP_LOW))
-            low_temp = int(kwargs.get(ATTR_TARGET_TEMP_HIGH))
+        low_temp = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        high_temp = kwargs.get(ATTR_TARGET_TEMP_HIGH)
+        temp = kwargs.get(ATTR_TEMPERATURE)
 
-        if self.hold_temp:
-            self.data.ecobee.set_hold_temp(self.thermostat_index, low_temp,
-                                           high_temp, "indefinite")
-            _LOGGER.debug("Setting ecobee hold_temp to: low=%s, is=%s, "
-                          "high=%s, is=%s", low_temp, isinstance(
-                              low_temp, (int, float)), high_temp,
-                          isinstance(high_temp, (int, float)))
+        if self.current_operation == STATE_AUTO and low_temp is not None \
+           and high_temp is not None:
+            self.set_auto_temp_hold(int(low_temp), int(high_temp))
+        elif temp is not None:
+            self.set_temp_hold(int(temp))
         else:
-            self.data.ecobee.set_hold_temp(self.thermostat_index, low_temp,
-                                           high_temp)
-            _LOGGER.debug("Setting ecobee temp to: low=%s, is=%s, "
-                          "high=%s, is=%s", low_temp, isinstance(
-                              low_temp, (int, float)), high_temp,
-                          isinstance(high_temp, (int, float)))
-        self.update_without_throttle = True
+            _LOGGER.error(
+                'Missing valid arguments for set_temperature in %s', kwargs)
 
     def set_operation_mode(self, operation_mode):
         """Set HVAC mode (auto, auxHeatOnly, cool, heat, off)."""
@@ -248,20 +364,21 @@ class Thermostat(ClimateDevice):
                                              fan_min_on_time)
         self.update_without_throttle = True
 
-    # Home and Sleep mode aren't used in UI yet:
+    def resume_program(self, resume_all):
+        """Resume the thermostat schedule program."""
+        self.data.ecobee.resume_program(self.thermostat_index,
+                                        str(resume_all).lower())
+        self.update_without_throttle = True
 
-    # def turn_home_mode_on(self):
-    #     """ Turns home mode on. """
-    #     self.data.ecobee.set_climate_hold(self.thermostat_index, "home")
-
-    # def turn_home_mode_off(self):
-    #     """ Turns home mode off. """
-    #     self.data.ecobee.resume_program(self.thermostat_index)
-
-    # def turn_sleep_mode_on(self):
-    #     """ Turns sleep mode on. """
-    #     self.data.ecobee.set_climate_hold(self.thermostat_index, "sleep")
-
-    # def turn_sleep_mode_off(self):
-    #     """ Turns sleep mode off. """
-    #     self.data.ecobee.resume_program(self.thermostat_index)
+    def hold_preference(self):
+        """Return user preference setting for hold time."""
+        # Values returned from thermostat are 'useEndTime4hour',
+        # 'useEndTime2hour', 'nextTransition', 'indefinite', 'askMe'
+        default = self.thermostat['settings']['holdAction']
+        if default == 'nextTransition':
+            return default
+        # add further conditions if other hold durations should be
+        # supported; note that this should not include 'indefinite'
+        # as an indefinite away hold is interpreted as away_mode
+        else:
+            return 'nextTransition'

homeassistant/components/climate/eq3btsmart.py

@@ -8,18 +8,28 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, PRECISION_HALVES,
+    STATE_AUTO, STATE_ON, STATE_OFF,
+)
 from homeassistant.const import (
     CONF_MAC, TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE)
-from homeassistant.util.temperature import convert
+
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['bluepy_devices==0.2.0']
+REQUIREMENTS = ['python-eq3bt==0.1.5']
 
 _LOGGER = logging.getLogger(__name__)
 
-ATTR_MODE = 'mode'
-ATTR_MODE_READABLE = 'mode_readable'
+STATE_BOOST = "boost"
+STATE_AWAY = "away"
+STATE_MANUAL = "manual"
+
+ATTR_STATE_WINDOW_OPEN = "window_open"
+ATTR_STATE_VALVE = "valve"
+ATTR_STATE_LOCKED = "is_locked"
+ATTR_STATE_LOW_BAT = "low_battery"
+ATTR_STATE_AWAY_END = "away_end"
 
 DEVICE_SCHEMA = vol.Schema({
     vol.Required(CONF_MAC): cv.string,
@@ -48,10 +58,25 @@ class EQ3BTSmartThermostat(ClimateDevice):
 
     def __init__(self, _mac, _name):
         """Initialize the thermostat."""
-        from bluepy_devices.devices import eq3btsmart
+        # we want to avoid name clash with this module..
+        import eq3bt as eq3
+
+        self.modes = {eq3.Mode.Open: STATE_ON,
+                      eq3.Mode.Closed: STATE_OFF,
+                      eq3.Mode.Auto: STATE_AUTO,
+                      eq3.Mode.Manual: STATE_MANUAL,
+                      eq3.Mode.Boost: STATE_BOOST,
+                      eq3.Mode.Away: STATE_AWAY}
+
+        self.reverse_modes = {v: k for k, v in self.modes.items()}
 
         self._name = _name
-        self._thermostat = eq3btsmart.EQ3BTSmartThermostat(_mac)
+        self._thermostat = eq3.Thermostat(_mac)
+
+    @property
+    def available(self) -> bool:
+        """Return if thermostat is available."""
+        return self.current_operation is not None
 
     @property
     def name(self):
@@ -63,6 +88,11 @@ class EQ3BTSmartThermostat(ClimateDevice):
         """Return the unit of measurement that is used."""
         return TEMP_CELSIUS
 
+    @property
+    def precision(self):
+        """Return eq3bt's precision 0.5."""
+        return PRECISION_HALVES
+
     @property
     def current_temperature(self):
         """Can not report temperature, so return target_temperature."""
@@ -81,24 +111,56 @@ class EQ3BTSmartThermostat(ClimateDevice):
         self._thermostat.target_temperature = temperature
 
     @property
-    def device_state_attributes(self):
-        """Return the device specific state attributes."""
-        return {
-            ATTR_MODE: self._thermostat.mode,
-            ATTR_MODE_READABLE: self._thermostat.mode_readable,
-        }
+    def current_operation(self):
+        """Current mode."""
+        if self._thermostat.mode < 0:
+            return None
+        return self.modes[self._thermostat.mode]
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return [x for x in self.modes.values()]
+
+    def set_operation_mode(self, operation_mode):
+        """Set operation mode."""
+        self._thermostat.mode = self.reverse_modes[operation_mode]
+
+    def turn_away_mode_off(self):
+        """Away mode off turns to AUTO mode."""
+        self.set_operation_mode(STATE_AUTO)
+
+    def turn_away_mode_on(self):
+        """Set away mode on."""
+        self.set_operation_mode(STATE_AWAY)
+
+    @property
+    def is_away_mode_on(self):
+        """Return if we are away."""
+        return self.current_operation == STATE_AWAY
 
     @property
     def min_temp(self):
         """Return the minimum temperature."""
-        return convert(self._thermostat.min_temp, TEMP_CELSIUS,
-                       self.unit_of_measurement)
+        return self._thermostat.min_temp
 
     @property
     def max_temp(self):
         """Return the maximum temperature."""
-        return convert(self._thermostat.max_temp, TEMP_CELSIUS,
-                       self.unit_of_measurement)
+        return self._thermostat.max_temp
+
+    @property
+    def device_state_attributes(self):
+        """Return the device specific state attributes."""
+        dev_specific = {
+            ATTR_STATE_LOCKED: self._thermostat.locked,
+            ATTR_STATE_LOW_BAT: self._thermostat.low_battery,
+            ATTR_STATE_VALVE: self._thermostat.valve_state,
+            ATTR_STATE_WINDOW_OPEN: self._thermostat.window_open,
+            ATTR_STATE_AWAY_END: self._thermostat.away_end,
+        }
+
+        return dev_specific
 
     def update(self):
         """Update the data from the thermostat."""

homeassistant/components/climate/generic_thermostat.py

@@ -4,27 +4,29 @@ Adds support for generic thermostat units.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.generic_thermostat/
 """
+import asyncio
 import logging
 
 import voluptuous as vol
 
+from homeassistant.core import callback
 from homeassistant.components import switch
 from homeassistant.components.climate import (
     STATE_HEAT, STATE_COOL, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA)
 from homeassistant.const import (
     ATTR_UNIT_OF_MEASUREMENT, STATE_ON, STATE_OFF, ATTR_TEMPERATURE)
 from homeassistant.helpers import condition
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
 import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ['switch', 'sensor']
 
-TOL_TEMP = 0.3
+DEFAULT_TOLERANCE = 0.3
+DEFAULT_NAME = 'Generic Thermostat'
 
 CONF_NAME = 'name'
-DEFAULT_NAME = 'Generic Thermostat'
 CONF_HEATER = 'heater'
 CONF_SENSOR = 'target_sensor'
 CONF_MIN_TEMP = 'min_temp'
@@ -32,6 +34,7 @@ CONF_MAX_TEMP = 'max_temp'
 CONF_TARGET_TEMP = 'target_temp'
 CONF_AC_MODE = 'ac_mode'
 CONF_MIN_DUR = 'min_cycle_duration'
+CONF_TOLERANCE = 'tolerance'
 
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -42,11 +45,13 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_MIN_DUR): vol.All(cv.time_period, cv.positive_timedelta),
     vol.Optional(CONF_MIN_TEMP): vol.Coerce(float),
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(float),
     vol.Optional(CONF_TARGET_TEMP): vol.Coerce(float),
 })
 
 
-def setup_platform(hass, config, add_devices, discovery_info=None):
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
     """Setup the generic thermostat."""
     name = config.get(CONF_NAME)
     heater_entity_id = config.get(CONF_HEATER)
@@ -56,23 +61,26 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     target_temp = config.get(CONF_TARGET_TEMP)
     ac_mode = config.get(CONF_AC_MODE)
     min_cycle_duration = config.get(CONF_MIN_DUR)
+    tolerance = config.get(CONF_TOLERANCE)
 
-    add_devices([GenericThermostat(
+    yield from async_add_devices([GenericThermostat(
         hass, name, heater_entity_id, sensor_entity_id, min_temp, max_temp,
-        target_temp, ac_mode, min_cycle_duration)])
+        target_temp, ac_mode, min_cycle_duration, tolerance)])
 
 
 class GenericThermostat(ClimateDevice):
     """Representation of a GenericThermostat device."""
 
     def __init__(self, hass, name, heater_entity_id, sensor_entity_id,
-                 min_temp, max_temp, target_temp, ac_mode, min_cycle_duration):
+                 min_temp, max_temp, target_temp, ac_mode, min_cycle_duration,
+                 tolerance):
         """Initialize the thermostat."""
         self.hass = hass
         self._name = name
         self.heater_entity_id = heater_entity_id
         self.ac_mode = ac_mode
         self.min_cycle_duration = min_cycle_duration
+        self._tolerance = tolerance
 
         self._active = False
         self._cur_temp = None
@@ -81,11 +89,14 @@ class GenericThermostat(ClimateDevice):
         self._target_temp = target_temp
         self._unit = hass.config.units.temperature_unit
 
-        track_state_change(hass, sensor_entity_id, self._sensor_changed)
+        async_track_state_change(
+            hass, sensor_entity_id, self._async_sensor_changed)
+        async_track_state_change(
+            hass, heater_entity_id, self._async_switch_changed)
 
         sensor_state = hass.states.get(sensor_entity_id)
         if sensor_state:
-            self._update_temp(sensor_state)
+            self._async_update_temp(sensor_state)
 
     @property
     def should_poll(self):
@@ -122,14 +133,15 @@ class GenericThermostat(ClimateDevice):
         """Return the temperature we try to reach."""
         return self._target_temp
 
-    def set_temperature(self, **kwargs):
+    @asyncio.coroutine
+    def async_set_temperature(self, **kwargs):
         """Set new target temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
         if temperature is None:
             return
         self._target_temp = temperature
-        self._control_heating()
-        self.update_ha_state()
+        self._async_control_heating()
+        yield from self.async_update_ha_state()
 
     @property
     def min_temp(self):
@@ -145,22 +157,31 @@ class GenericThermostat(ClimateDevice):
     def max_temp(self):
         """Return the maximum temperature."""
         # pylint: disable=no-member
-        if self._min_temp:
+        if self._max_temp:
             return self._max_temp
         else:
             # Get default temp from super class
             return ClimateDevice.max_temp.fget(self)
 
-    def _sensor_changed(self, entity_id, old_state, new_state):
+    @asyncio.coroutine
+    def _async_sensor_changed(self, entity_id, old_state, new_state):
         """Called when temperature changes."""
         if new_state is None:
             return
 
-        self._update_temp(new_state)
-        self._control_heating()
-        self.update_ha_state()
+        self._async_update_temp(new_state)
+        self._async_control_heating()
+        yield from self.async_update_ha_state()
 
-    def _update_temp(self, state):
+    @callback
+    def _async_switch_changed(self, entity_id, old_state, new_state):
+        """Called when heater switch changes state."""
+        if new_state is None:
+            return
+        self.hass.async_add_job(self.async_update_ha_state())
+
+    @callback
+    def _async_update_temp(self, state):
         """Update thermostat with latest state from sensor."""
         unit = state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
 
@@ -170,7 +191,8 @@ class GenericThermostat(ClimateDevice):
         except ValueError as ex:
             _LOGGER.error('Unable to update from sensor: %s', ex)
 
-    def _control_heating(self):
+    @callback
+    def _async_control_heating(self):
         """Check if we need to turn heating on or off."""
         if not self._active and None not in (self._cur_temp,
                                              self._target_temp):
@@ -186,31 +208,37 @@ class GenericThermostat(ClimateDevice):
                 current_state = STATE_ON
             else:
                 current_state = STATE_OFF
-            long_enough = condition.state(self.hass, self.heater_entity_id,
-                                          current_state,
-                                          self.min_cycle_duration)
+            long_enough = condition.state(
+                self.hass, self.heater_entity_id, current_state,
+                self.min_cycle_duration)
             if not long_enough:
                 return
 
         if self.ac_mode:
-            too_hot = self._cur_temp - self._target_temp > TOL_TEMP
             is_cooling = self._is_device_active
-            if too_hot and not is_cooling:
-                _LOGGER.info('Turning on AC %s', self.heater_entity_id)
-                switch.turn_on(self.hass, self.heater_entity_id)
-            elif not too_hot and is_cooling:
-                _LOGGER.info('Turning off AC %s', self.heater_entity_id)
-                switch.turn_off(self.hass, self.heater_entity_id)
+            if is_cooling:
+                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                if too_cold:
+                    _LOGGER.info('Turning off AC %s', self.heater_entity_id)
+                    switch.async_turn_off(self.hass, self.heater_entity_id)
+            else:
+                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                if too_hot:
+                    _LOGGER.info('Turning on AC %s', self.heater_entity_id)
+                    switch.async_turn_on(self.hass, self.heater_entity_id)
         else:
-            too_cold = self._target_temp - self._cur_temp > TOL_TEMP
             is_heating = self._is_device_active
-
-            if too_cold and not is_heating:
-                _LOGGER.info('Turning on heater %s', self.heater_entity_id)
-                switch.turn_on(self.hass, self.heater_entity_id)
-            elif not too_cold and is_heating:
-                _LOGGER.info('Turning off heater %s', self.heater_entity_id)
-                switch.turn_off(self.hass, self.heater_entity_id)
+            if is_heating:
+                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                if too_hot:
+                    _LOGGER.info('Turning off heater %s',
+                                 self.heater_entity_id)
+                    switch.async_turn_off(self.hass, self.heater_entity_id)
+            else:
+                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                if too_cold:
+                    _LOGGER.info('Turning on heater %s', self.heater_entity_id)
+                    switch.async_turn_on(self.hass, self.heater_entity_id)
 
     @property
     def _is_device_active(self):

homeassistant/components/climate/homematic.py

@@ -5,10 +5,11 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.homematic/
 """
 import logging
-import homeassistant.components.homematic as homematic
 from homeassistant.components.climate import ClimateDevice, STATE_AUTO
+from homeassistant.components.homematic import HMDevice
 from homeassistant.util.temperature import convert
 from homeassistant.const import TEMP_CELSIUS, STATE_UNKNOWN, ATTR_TEMPERATURE
+from homeassistant.loader import get_component
 
 DEPENDENCIES = ['homematic']
 
@@ -29,14 +30,16 @@ def setup_platform(hass, config, add_callback_devices, discovery_info=None):
     if discovery_info is None:
         return
 
+    homematic = get_component("homematic")
     return homematic.setup_hmdevice_discovery_helper(
+        hass,
         HMThermostat,
         discovery_info,
         add_callback_devices
     )
 
 
-class HMThermostat(homematic.HMDevice, ClimateDevice):
+class HMThermostat(HMDevice, ClimateDevice):
     """Representation of a Homematic thermostat."""
 
     @property
@@ -94,13 +97,9 @@ class HMThermostat(homematic.HMDevice, ClimateDevice):
     def set_temperature(self, **kwargs):
         """Set new target temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
-        if not self.available:
+        if not self.available or temperature is None:
             return None
-        if temperature is None:
-            return
 
-        if self.current_operation == STATE_AUTO:
-            return self._hmdevice.actionNodeData('MANU_MODE', temperature)
         self._hmdevice.set_temperature(temperature)
 
     def set_operation_mode(self, operation_mode):

homeassistant/components/climate/honeywell.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
 import homeassistant.helpers.config_validation as cv
 
 REQUIREMENTS = ['evohomeclient==0.2.5',
-                'somecomfort==0.3.2']
+                'somecomfort==0.4.1']
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -223,7 +223,6 @@ class HoneywellUSThermostat(ClimateDevice):
     @property
     def current_temperature(self):
         """Return the current temperature."""
-        self._device.refresh()
         return self._device.current_temperature
 
     @property
@@ -274,3 +273,7 @@ class HoneywellUSThermostat(ClimateDevice):
         """Set the system mode (Cool, Heat, etc)."""
         if hasattr(self._device, ATTR_SYSTEM_MODE):
             self._device.system_mode = operation_mode
+
+    def update(self):
+        """Update the state."""
+        self._device.refresh()

homeassistant/components/climate/knx.py

@@ -56,6 +56,8 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
         self._unit_of_measurement = TEMP_CELSIUS  # KNX always used celsius
         self._away = False  # not yet supported
         self._is_fan_on = False  # not yet supported
+        self._current_temp = None
+        self._target_temp = None
 
     @property
     def should_poll(self):
@@ -70,16 +72,12 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
     @property
     def current_temperature(self):
         """Return the current temperature."""
-        from knxip.conversion import knx2_to_float
-
-        return knx2_to_float(self.value('temperature'))
+        return self._current_temp
 
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
-        from knxip.conversion import knx2_to_float
-
-        return knx2_to_float(self.value('setpoint'))
+        return self._target_temp
 
     def set_temperature(self, **kwargs):
         """Set new target temperature."""
@@ -94,3 +92,12 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
     def set_operation_mode(self, operation_mode):
         """Set operation mode."""
         raise NotImplementedError()
+
+    def update(self):
+        """Update KNX climate."""
+        from knxip.conversion import knx2_to_float
+
+        super().update()
+
+        self._current_temp = knx2_to_float(self.value('temperature'))
+        self._target_temp = knx2_to_float(self.value('setpoint'))

homeassistant/components/climate/mysensors.py

@@ -24,7 +24,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the mysensors climate."""
     if discovery_info is None:
         return
-    for gateway in mysensors.GATEWAYS.values():
+
+    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
+    if not gateways:
+        return
+
+    for gateway in gateways:
         if float(gateway.protocol_version) < 1.5:
             continue
         pres = gateway.const.Presentation
@@ -34,7 +39,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         }
         devices = {}
         gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsHVAC))
+            map_sv_types, devices, MySensorsHVAC, add_devices))
 
 
 class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
@@ -130,7 +135,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
             if self.gateway.optimistic:
                 # optimistically assume that switch has changed state
                 self._values[value_type] = value
-                self.update_ha_state()
+                self.schedule_update_ha_state()
 
     def set_fan_mode(self, fan):
         """Set new target temperature."""
@@ -140,7 +145,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
         if self.gateway.optimistic:
             # optimistically assume that switch has changed state
             self._values[set_req.V_HVAC_SPEED] = fan
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def set_operation_mode(self, operation_mode):
         """Set new target temperature."""
@@ -151,7 +156,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
         if self.gateway.optimistic:
             # optimistically assume that switch has changed state
             self._values[set_req.V_HVAC_FLOW_STATE] = operation_mode
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def update(self):
         """Update the controller with the latest value from a sensor."""

homeassistant/components/climate/nest.py

@@ -14,7 +14,8 @@ from homeassistant.components.climate import (
     PLATFORM_SCHEMA, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
     ATTR_TEMPERATURE)
 from homeassistant.const import (
-    TEMP_CELSIUS, CONF_SCAN_INTERVAL, STATE_ON, STATE_OFF, STATE_UNKNOWN)
+    TEMP_CELSIUS, TEMP_FAHRENHEIT,
+    CONF_SCAN_INTERVAL, STATE_ON, STATE_OFF, STATE_UNKNOWN)
 
 DEPENDENCIES = ['nest']
 _LOGGER = logging.getLogger(__name__)
@@ -24,13 +25,22 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
         vol.All(vol.Coerce(int), vol.Range(min=1)),
 })
 
+STATE_ECO = 'eco'
+STATE_HEAT_COOL = 'heat-cool'
+
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Nest thermostat."""
+    if discovery_info is None:
+        return
+
+    _LOGGER.debug("Setting up nest thermostat")
+
     temp_unit = hass.config.units.temperature_unit
+
     add_devices(
         [NestThermostat(structure, device, temp_unit)
-         for structure, device in hass.data[DATA_NEST].devices()],
+         for structure, device in hass.data[DATA_NEST].thermostats()],
         True
     )
 
@@ -58,9 +68,9 @@ class NestThermostat(ClimateDevice):
         if self.device.can_heat and self.device.can_cool:
             self._operation_list.append(STATE_AUTO)
 
+        self._operation_list.append(STATE_ECO)
+
         # feature of device
-        self._has_humidifier = self.device.has_humidifier
-        self._has_dehumidifier = self.device.has_dehumidifier
         self._has_fan = self.device.has_fan
 
         # data attributes
@@ -68,41 +78,26 @@ class NestThermostat(ClimateDevice):
         self._location = None
         self._name = None
         self._humidity = None
-        self._target_humidity = None
         self._target_temperature = None
         self._temperature = None
+        self._temperature_scale = None
         self._mode = None
         self._fan = None
-        self._away_temperature = None
+        self._eco_temperature = None
+        self._is_locked = None
+        self._locked_temperature = None
+        self._min_temperature = None
+        self._max_temperature = None
 
     @property
     def name(self):
         """Return the name of the nest, if any."""
-        if self._location is None:
-            return self._name
-        else:
-            if self._name == '':
-                return self._location.capitalize()
-            else:
-                return self._location.capitalize() + '(' + self._name + ')'
+        return self._name
 
     @property
     def temperature_unit(self):
         """Return the unit of measurement."""
-        return TEMP_CELSIUS
-
-    @property
-    def device_state_attributes(self):
-        """Return the device specific state attributes."""
-        if self._has_humidifier or self._has_dehumidifier:
-            # Move these to Thermostat Device and make them global
-            return {
-                "humidity": self._humidity,
-                "target_humidity": self._target_humidity,
-            }
-        else:
-            # No way to control humidity not show setting
-            return {}
+        return self._temperature_scale
 
     @property
     def current_temperature(self):
@@ -112,21 +107,17 @@ class NestThermostat(ClimateDevice):
     @property
     def current_operation(self):
         """Return current operation ie. heat, cool, idle."""
-        if self._mode == 'cool':
-            return STATE_COOL
-        elif self._mode == 'heat':
-            return STATE_HEAT
-        elif self._mode == 'range':
+        if self._mode in [STATE_HEAT, STATE_COOL, STATE_OFF, STATE_ECO]:
+            return self._mode
+        elif self._mode == STATE_HEAT_COOL:
             return STATE_AUTO
-        elif self._mode == 'off':
-            return STATE_OFF
         else:
             return STATE_UNKNOWN
 
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
-        if self._mode != 'range' and not self.is_away_mode_on:
+        if self._mode != STATE_HEAT_COOL and not self.is_away_mode_on:
             return self._target_temperature
         else:
             return None
@@ -134,10 +125,11 @@ class NestThermostat(ClimateDevice):
     @property
     def target_temperature_low(self):
         """Return the lower bound temperature we try to reach."""
-        if self.is_away_mode_on and self._away_temperature[0]:
-            # away_temperature is always a low, high tuple
-            return self._away_temperature[0]
-        if self._mode == 'range':
+        if (self.is_away_mode_on or self._mode == STATE_ECO) and \
+                self._eco_temperature[0]:
+            # eco_temperature is always a low, high tuple
+            return self._eco_temperature[0]
+        if self._mode == STATE_HEAT_COOL:
             return self._target_temperature[0]
         else:
             return None
@@ -145,10 +137,11 @@ class NestThermostat(ClimateDevice):
     @property
     def target_temperature_high(self):
         """Return the upper bound temperature we try to reach."""
-        if self.is_away_mode_on and self._away_temperature[1]:
-            # away_temperature is always a low, high tuple
-            return self._away_temperature[1]
-        if self._mode == 'range':
+        if (self.is_away_mode_on or self._mode == STATE_ECO) and \
+                self._eco_temperature[1]:
+            # eco_temperature is always a low, high tuple
+            return self._eco_temperature[1]
+        if self._mode == STATE_HEAT_COOL:
             return self._target_temperature[1]
         else:
             return None
@@ -162,9 +155,8 @@ class NestThermostat(ClimateDevice):
         """Set new target temperature."""
         target_temp_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
         target_temp_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
-        if target_temp_low is not None and target_temp_high is not None:
-
-            if self._mode == 'range':
+        if self._mode == STATE_HEAT_COOL:
+            if target_temp_low is not None and target_temp_high is not None:
                 temp = (target_temp_low, target_temp_high)
         else:
             temp = kwargs.get(ATTR_TEMPERATURE)
@@ -173,14 +165,11 @@ class NestThermostat(ClimateDevice):
 
     def set_operation_mode(self, operation_mode):
         """Set operation mode."""
-        if operation_mode == STATE_HEAT:
-            self.device.mode = 'heat'
-        elif operation_mode == STATE_COOL:
-            self.device.mode = 'cool'
+        if operation_mode in [STATE_HEAT, STATE_COOL, STATE_OFF, STATE_ECO]:
+            device_mode = operation_mode
         elif operation_mode == STATE_AUTO:
-            self.device.mode = 'range'
-        elif operation_mode == STATE_OFF:
-            self.device.mode = 'off'
+            device_mode = STATE_HEAT_COOL
+        self.device.mode = device_mode
 
     @property
     def operation_list(self):
@@ -217,30 +206,29 @@ class NestThermostat(ClimateDevice):
     @property
     def min_temp(self):
         """Identify min_temp in Nest API or defaults if not available."""
-        temp = self._away_temperature[0]
-        if temp is None:
-            return super().min_temp
-        else:
-            return temp
+        return self._min_temperature
 
     @property
     def max_temp(self):
         """Identify max_temp in Nest API or defaults if not available."""
-        temp = self._away_temperature[1]
-        if temp is None:
-            return super().max_temp
-        else:
-            return temp
+        return self._max_temperature
 
     def update(self):
         """Cache value from Python-nest."""
         self._location = self.device.where
         self._name = self.device.name
         self._humidity = self.device.humidity,
-        self._target_humidity = self.device.target_humidity,
         self._temperature = self.device.temperature
         self._mode = self.device.mode
         self._target_temperature = self.device.target
         self._fan = self.device.fan
-        self._away = self.structure.away
-        self._away_temperature = self.device.away_temperature
+        self._away = self.structure.away == 'away'
+        self._eco_temperature = self.device.eco_temperature
+        self._locked_temperature = self.device.locked_temperature
+        self._min_temperature = self.device.min_temperature
+        self._max_temperature = self.device.max_temperature
+        self._is_locked = self.device.is_locked
+        if self.device.temperature_scale == 'C':
+            self._temperature_scale = TEMP_CELSIUS
+        else:
+            self._temperature_scale = TEMP_FAHRENHEIT

homeassistant/components/climate/netatmo.py

@@ -111,7 +111,6 @@ class NetatmoThermostat(ClimateDevice):
         temp = None
         self._data.thermostatdata.setthermpoint(mode, temp, endTimeOffset=None)
         self._away = True
-        self.update_ha_state()
 
     def turn_away_mode_off(self):
         """Turn away off."""
@@ -119,7 +118,6 @@ class NetatmoThermostat(ClimateDevice):
         temp = None
         self._data.thermostatdata.setthermpoint(mode, temp, endTimeOffset=None)
         self._away = False
-        self.update_ha_state()
 
     def set_temperature(self, endTimeOffset=DEFAULT_TIME_OFFSET, **kwargs):
         """Set new target temperature for 2 hours."""
@@ -131,7 +129,6 @@ class NetatmoThermostat(ClimateDevice):
             mode, temperature, endTimeOffset)
         self._target_temperature = temperature
         self._away = False
-        self.update_ha_state()
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     def update(self):

homeassistant/components/climate/proliphix.py

@@ -7,12 +7,13 @@ https://home-assistant.io/components/climate.proliphix/
 import voluptuous as vol
 
 from homeassistant.components.climate import (
-    STATE_COOL, STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA)
+    PRECISION_TENTHS, STATE_COOL, STATE_HEAT, STATE_IDLE,
+    ClimateDevice, PLATFORM_SCHEMA)
 from homeassistant.const import (
     CONF_HOST, CONF_PASSWORD, CONF_USERNAME, TEMP_FAHRENHEIT, ATTR_TEMPERATURE)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['proliphix==0.4.0']
+REQUIREMENTS = ['proliphix==0.4.1']
 
 ATTR_FAN = 'fan'
 
@@ -60,6 +61,15 @@ class ProliphixThermostat(ClimateDevice):
         """Return the name of the thermostat."""
         return self._name
 
+    @property
+    def precision(self):
+        """Return the precision of the system.
+
+        Proliphix temperature values are passed back and forth in the
+        API as tenths of degrees F (i.e. 690 for 69 degrees).
+        """
+        return PRECISION_TENTHS
+
     @property
     def device_state_attributes(self):
         """Return the device specific state attributes."""

homeassistant/components/climate/radiotherm.py

@@ -23,10 +23,19 @@ ATTR_FAN = 'fan'
 ATTR_MODE = 'mode'
 
 CONF_HOLD_TEMP = 'hold_temp'
+CONF_AWAY_TEMPERATURE_HEAT = 'away_temperature_heat'
+CONF_AWAY_TEMPERATURE_COOL = 'away_temperature_cool'
+
+DEFAULT_AWAY_TEMPERATURE_HEAT = 60
+DEFAULT_AWAY_TEMPERATURE_COOL = 85
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
     vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
+    vol.Optional(CONF_AWAY_TEMPERATURE_HEAT,
+                 default=DEFAULT_AWAY_TEMPERATURE_HEAT): vol.Coerce(float),
+    vol.Optional(CONF_AWAY_TEMPERATURE_COOL,
+                 default=DEFAULT_AWAY_TEMPERATURE_COOL): vol.Coerce(float),
 })
 
 
@@ -45,12 +54,16 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         return False
 
     hold_temp = config.get(CONF_HOLD_TEMP)
+    away_temps = [
+        config.get(CONF_AWAY_TEMPERATURE_HEAT),
+        config.get(CONF_AWAY_TEMPERATURE_COOL)
+    ]
     tstats = []
 
     for host in hosts:
         try:
             tstat = radiotherm.get_thermostat(host)
-            tstats.append(RadioThermostat(tstat, hold_temp))
+            tstats.append(RadioThermostat(tstat, hold_temp, away_temps))
         except OSError:
             _LOGGER.exception("Unable to connect to Radio Thermostat: %s",
                               host)
@@ -61,7 +74,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class RadioThermostat(ClimateDevice):
     """Representation of a Radio Thermostat."""
 
-    def __init__(self, device, hold_temp):
+    def __init__(self, device, hold_temp, away_temps):
         """Initialize the thermostat."""
         self.device = device
         self.set_time()
@@ -69,7 +82,12 @@ class RadioThermostat(ClimateDevice):
         self._current_temperature = None
         self._current_operation = STATE_IDLE
         self._name = None
-        self.hold_temp = hold_temp
+        self._fmode = None
+        self._tmode = None
+        self._hold_temp = hold_temp
+        self._away = False
+        self._away_temps = away_temps
+        self._prev_temp = None
         self.update()
         self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
 
@@ -87,8 +105,8 @@ class RadioThermostat(ClimateDevice):
     def device_state_attributes(self):
         """Return the device specific state attributes."""
         return {
-            ATTR_FAN: self.device.fmode['human'],
-            ATTR_MODE: self.device.tmode['human']
+            ATTR_FAN: self._fmode,
+            ATTR_MODE: self._tmode,
         }
 
     @property
@@ -111,14 +129,22 @@ class RadioThermostat(ClimateDevice):
         """Return the temperature we try to reach."""
         return self._target_temperature
 
+    @property
+    def is_away_mode_on(self):
+        """Return true if away mode is on."""
+        return self._away
+
     def update(self):
         """Update the data from the thermostat."""
         self._current_temperature = self.device.temp['raw']
         self._name = self.device.name['raw']
-        if self.device.tmode['human'] == 'Cool':
+        self._fmode = self.device.fmode['human']
+        self._tmode = self.device.tmode['human']
+
+        if self._tmode == 'Cool':
             self._target_temperature = self.device.t_cool['raw']
             self._current_operation = STATE_COOL
-        elif self.device.tmode['human'] == 'Heat':
+        elif self._tmode == 'Heat':
             self._target_temperature = self.device.t_heat['raw']
             self._current_operation = STATE_HEAT
         else:
@@ -130,10 +156,10 @@ class RadioThermostat(ClimateDevice):
         if temperature is None:
             return
         if self._current_operation == STATE_COOL:
-            self.device.t_cool = temperature
+            self.device.t_cool = round(temperature * 2.0) / 2.0
         elif self._current_operation == STATE_HEAT:
-            self.device.t_heat = temperature
-        if self.hold_temp:
+            self.device.t_heat = round(temperature * 2.0) / 2.0
+        if self._hold_temp or self._away:
             self.device.hold = 1
         else:
             self.device.hold = 0
@@ -154,6 +180,26 @@ class RadioThermostat(ClimateDevice):
         elif operation_mode == STATE_AUTO:
             self.device.tmode = 3
         elif operation_mode == STATE_COOL:
-            self.device.t_cool = self._target_temperature
+            self.device.t_cool = round(self._target_temperature * 2.0) / 2.0
         elif operation_mode == STATE_HEAT:
-            self.device.t_heat = self._target_temperature
+            self.device.t_heat = round(self._target_temperature * 2.0) / 2.0
+
+    def turn_away_mode_on(self):
+        """Turn away on.
+
+        The RTCOA app simulates away mode by using a hold.
+        """
+        away_temp = None
+        if not self._away:
+            self._prev_temp = self._target_temperature
+            if self._current_operation == STATE_HEAT:
+                away_temp = self._away_temps[0]
+            elif self._current_operation == STATE_COOL:
+                away_temp = self._away_temps[1]
+        self._away = True
+        self.set_temperature(temperature=away_temp)
+
+    def turn_away_mode_off(self):
+        """Turn away off."""
+        self._away = False
+        self.set_temperature(temperature=self._prev_temp)

homeassistant/components/climate/services.yaml

@@ -22,6 +22,18 @@ set_away_mode:
       description: New value of away mode
       example: true
 
+set_hold_mode:
+  description: Turn hold mode for climate device
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to change
+      example: 'climate.kitchen'
+
+    hold_mode:
+      description: New value of hold mode
+      example: 'away'
+
 set_temperature:
   description: Set target temperature of climate device
 
@@ -66,7 +78,7 @@ set_fan_mode:
       description: Name(s) of entities to change
       example: 'climate.nest'
 
-    fan:
+    fan_mode:
       description: New value of fan mode
       example: On Low
 
@@ -76,7 +88,7 @@ set_operation_mode:
   fields:
     entity_id:
       description: Name(s) of entities to change
-      example: 'climet.nest'
+      example: 'climate.nest'
 
     operation_mode:
       description: New value of operation mode
@@ -94,3 +106,27 @@ set_swing_mode:
     swing_mode:
     description: New value of swing mode
     example: 1
+
+ecobee_set_fan_min_on_time:
+  description: Set the minimum fan on time
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to change
+      example: 'climate.kitchen'
+
+    fan_min_on_time:
+      description: New value of fan min on time
+      example: 5
+
+ecobee_resume_program:
+  description: Resume the programmed schedule
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to change
+      example: 'climate.kitchen'
+
+    resume_all:
+      description: Resume all events and return to the scheduled program. This default to false which removes only the top event.
+      example: true

homeassistant/components/climate/wink.py

@@ -0,0 +1,468 @@
+"""
+Support for Wink thermostats.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.wink/
+"""
+from homeassistant.components.wink import WinkDevice, DOMAIN
+from homeassistant.components.climate import (
+    STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
+    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
+    ATTR_TEMPERATURE,
+    ATTR_CURRENT_HUMIDITY)
+from homeassistant.const import (
+    TEMP_CELSIUS, STATE_ON,
+    STATE_OFF, STATE_UNKNOWN)
+
+DEPENDENCIES = ['wink']
+
+STATE_AUX = 'aux'
+STATE_ECO = 'eco'
+STATE_FAN = 'fan'
+SPEED_LOWEST = 'lowest'
+SPEED_LOW = 'low'
+SPEED_MEDIUM = 'medium'
+SPEED_HIGH = 'high'
+
+ATTR_EXTERNAL_TEMPERATURE = "external_temperature"
+ATTR_SMART_TEMPERATURE = "smart_temperature"
+ATTR_ECO_TARGET = "eco_target"
+ATTR_OCCUPIED = "occupied"
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Wink thermostat."""
+    import pywink
+    temp_unit = hass.config.units.temperature_unit
+    for climate in pywink.get_thermostats():
+        _id = climate.object_id() + climate.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkThermostat(climate, hass, temp_unit)])
+    for climate in pywink.get_air_conditioners():
+        _id = climate.object_id() + climate.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkAC(climate, hass, temp_unit)])
+
+
+# pylint: disable=abstract-method,too-many-public-methods, too-many-branches
+class WinkThermostat(WinkDevice, ClimateDevice):
+    """Representation of a Wink thermostat."""
+
+    def __init__(self, wink, hass, temp_unit):
+        """Initialize the Wink device."""
+        super().__init__(wink, hass)
+        self._config_temp_unit = temp_unit
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        # The Wink API always returns temp in Celsius
+        return TEMP_CELSIUS
+
+    @property
+    def device_state_attributes(self):
+        """Return the optional state attributes."""
+        data = {}
+        target_temp_high = self.target_temperature_high
+        target_temp_low = self.target_temperature_low
+        if target_temp_high is not None:
+            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
+                self.target_temperature_high)
+        if target_temp_low is not None:
+            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
+                self.target_temperature_low)
+
+        if self.external_temperature:
+            data[ATTR_EXTERNAL_TEMPERATURE] = self._convert_for_display(
+                self.external_temperature)
+
+        if self.smart_temperature:
+            data[ATTR_SMART_TEMPERATURE] = self.smart_temperature
+
+        if self.occupied:
+            data[ATTR_OCCUPIED] = self.occupied
+
+        if self.eco_target:
+            data[ATTR_ECO_TARGET] = self.eco_target
+
+        current_humidity = self.current_humidity
+        if current_humidity is not None:
+            data[ATTR_CURRENT_HUMIDITY] = current_humidity
+
+        return data
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self.wink.current_temperature()
+
+    @property
+    def current_humidity(self):
+        """Return the current humidity."""
+        if self.wink.current_humidity() is not None:
+            # The API states humidity will be a float 0-1
+            # the only example API response with humidity listed show an int
+            # This will address both possibilities
+            if self.wink.current_humidity() < 1:
+                return self.wink.current_humidity() * 100
+            else:
+                return self.wink.current_humidity()
+
+    @property
+    def external_temperature(self):
+        """Return the current external temperature."""
+        return self.wink.current_external_temperature()
+
+    @property
+    def smart_temperature(self):
+        """Return the current average temp of all remote sensor."""
+        return self.wink.current_smart_temperature()
+
+    @property
+    def eco_target(self):
+        """Return status of eco target (Is the termostat in eco mode)."""
+        return self.wink.eco_target()
+
+    @property
+    def occupied(self):
+        """Return status of if the thermostat has detected occupancy."""
+        return self.wink.occupied()
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if not self.wink.is_on():
+            current_op = STATE_OFF
+        elif self.wink.current_hvac_mode() == 'cool_only':
+            current_op = STATE_COOL
+        elif self.wink.current_hvac_mode() == 'heat_only':
+            current_op = STATE_HEAT
+        elif self.wink.current_hvac_mode() == 'aux':
+            current_op = STATE_HEAT
+        elif self.wink.current_hvac_mode() == 'auto':
+            current_op = STATE_AUTO
+        elif self.wink.current_hvac_mode() == 'eco':
+            current_op = STATE_ECO
+        else:
+            current_op = STATE_UNKNOWN
+        return current_op
+
+    @property
+    def target_humidity(self):
+        """Return the humidity we try to reach."""
+        target_hum = None
+        if self.wink.current_humidifier_mode() == 'on':
+            if self.wink.current_humidifier_set_point() is not None:
+                target_hum = self.wink.current_humidifier_set_point() * 100
+        elif self.wink.current_dehumidifier_mode() == 'on':
+            if self.wink.current_dehumidifier_set_point() is not None:
+                target_hum = self.wink.current_dehumidifier_set_point() * 100
+        else:
+            target_hum = None
+        return target_hum
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        if self.current_operation != STATE_AUTO and not self.is_away_mode_on:
+            if self.current_operation == STATE_COOL:
+                return self.wink.current_max_set_point()
+            elif self.current_operation == STATE_HEAT:
+                return self.wink.current_min_set_point()
+            else:
+                return None
+        else:
+            return None
+
+    @property
+    def target_temperature_low(self):
+        """Return the lower bound temperature we try to reach."""
+        if self.current_operation == STATE_AUTO:
+            return self.wink.current_min_set_point()
+        return None
+
+    @property
+    def target_temperature_high(self):
+        """Return the higher bound temperature we try to reach."""
+        if self.current_operation == STATE_AUTO:
+            return self.wink.current_max_set_point()
+        return None
+
+    @property
+    def is_away_mode_on(self):
+        """Return if away mode is on."""
+        return self.wink.away()
+
+    @property
+    def is_aux_heat_on(self):
+        """Return true if aux heater."""
+        if self.wink.current_hvac_mode() == 'aux' and self.wink.is_on():
+            return True
+        elif self.wink.current_hvac_mode() == 'aux' and not self.wink.is_on():
+            return False
+        else:
+            return None
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        target_temp = kwargs.get(ATTR_TEMPERATURE)
+        target_temp_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        target_temp_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
+        if target_temp is not None:
+            if self.current_operation == STATE_COOL:
+                target_temp_high = target_temp
+            if self.current_operation == STATE_HEAT:
+                target_temp_low = target_temp
+        if target_temp_low is not None:
+            target_temp_low = target_temp_low
+        if target_temp_high is not None:
+            target_temp_high = target_temp_high
+        self.wink.set_temperature(target_temp_low, target_temp_high)
+
+    def set_operation_mode(self, operation_mode):
+        """Set operation mode."""
+        if operation_mode == STATE_HEAT:
+            self.wink.set_operation_mode('heat_only')
+        elif operation_mode == STATE_COOL:
+            self.wink.set_operation_mode('cool_only')
+        elif operation_mode == STATE_AUTO:
+            self.wink.set_operation_mode('auto')
+        elif operation_mode == STATE_OFF:
+            self.wink.set_operation_mode('off')
+        elif operation_mode == STATE_AUX:
+            self.wink.set_operation_mode('aux')
+        elif operation_mode == STATE_ECO:
+            self.wink.set_operation_mode('eco')
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        op_list = ['off']
+        modes = self.wink.hvac_modes()
+        if 'cool_only' in modes:
+            op_list.append(STATE_COOL)
+        if 'heat_only' in modes or 'aux' in modes:
+            op_list.append(STATE_HEAT)
+        if 'auto' in modes:
+            op_list.append(STATE_AUTO)
+        if 'eco' in modes:
+            op_list.append(STATE_ECO)
+        return op_list
+
+    def turn_away_mode_on(self):
+        """Turn away on."""
+        self.wink.set_away_mode()
+
+    def turn_away_mode_off(self):
+        """Turn away off."""
+        self.wink.set_away_mode(False)
+
+    @property
+    def current_fan_mode(self):
+        """Return whether the fan is on."""
+        if self.wink.current_fan_mode() == 'on':
+            return STATE_ON
+        elif self.wink.current_fan_mode() == 'auto':
+            return STATE_AUTO
+        else:
+            # No Fan available so disable slider
+            return None
+
+    @property
+    def fan_list(self):
+        """List of available fan modes."""
+        if self.wink.has_fan():
+            return self.wink.fan_modes()
+        return None
+
+    def set_fan_mode(self, fan):
+        """Turn fan on/off."""
+        self.wink.set_fan_mode(fan.lower())
+
+    def turn_aux_heat_on(self):
+        """Turn auxillary heater on."""
+        self.set_operation_mode(STATE_AUX)
+
+    def turn_aux_heat_off(self):
+        """Turn auxillary heater off."""
+        self.set_operation_mode(STATE_AUTO)
+
+    @property
+    def min_temp(self):
+        """Return the minimum temperature."""
+        minimum = 7  # Default minimum
+        min_min = self.wink.min_min_set_point()
+        min_max = self.wink.min_max_set_point()
+        return_value = minimum
+        if self.current_operation == STATE_HEAT:
+            if min_min:
+                return_value = min_min
+            else:
+                return_value = minimum
+        elif self.current_operation == STATE_COOL:
+            if min_max:
+                return_value = min_max
+            else:
+                return_value = minimum
+        elif self.current_operation == STATE_AUTO:
+            if min_min and min_max:
+                return_value = min(min_min, min_max)
+            else:
+                return_value = minimum
+        else:
+            return_value = minimum
+        return return_value
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        maximum = 35  # Default maximum
+        max_min = self.wink.max_min_set_point()
+        max_max = self.wink.max_max_set_point()
+        return_value = maximum
+        if self.current_operation == STATE_HEAT:
+            if max_min:
+                return_value = max_min
+            else:
+                return_value = maximum
+        elif self.current_operation == STATE_COOL:
+            if max_max:
+                return_value = max_max
+            else:
+                return_value = maximum
+        elif self.current_operation == STATE_AUTO:
+            if max_min and max_max:
+                return_value = min(max_min, max_max)
+            else:
+                return_value = maximum
+        else:
+            return_value = maximum
+        return return_value
+
+
+class WinkAC(WinkDevice, ClimateDevice):
+    """Representation of a Wink air conditioner."""
+
+    def __init__(self, wink, hass, temp_unit):
+        """Initialize the Wink device."""
+        super().__init__(wink, hass)
+        self._config_temp_unit = temp_unit
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        # The Wink API always returns temp in Celsius
+        return TEMP_CELSIUS
+
+    @property
+    def device_state_attributes(self):
+        """Return the optional state attributes."""
+        data = {}
+        target_temp_high = self.target_temperature_high
+        target_temp_low = self.target_temperature_low
+        if target_temp_high is not None:
+            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
+                self.target_temperature_high)
+        if target_temp_low is not None:
+            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
+                self.target_temperature_low)
+        data["total_consumption"] = self.wink.toatl_consumption()
+        data["schedule_enabled"] = self.wink.toatl_consumption()
+
+        return data
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self.wink.current_temperature()
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if not self.wink.is_on():
+            current_op = STATE_OFF
+        elif self.wink.current_mode() == 'cool_only':
+            current_op = STATE_COOL
+        elif self.wink.current_mode() == 'auto_eco':
+            current_op = STATE_ECO
+        elif self.wink.current_mode() == 'fan_only':
+            current_op = STATE_FAN
+        else:
+            current_op = STATE_UNKNOWN
+        return current_op
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        op_list = ['off']
+        modes = self.wink.modes()
+        if 'cool_only' in modes:
+            op_list.append(STATE_COOL)
+        if 'auto_eco' in modes:
+            op_list.append(STATE_ECO)
+        if 'fan_eco' in modes:
+            op_list.append(STATE_FAN)
+        return op_list
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        target_temp = kwargs.get(ATTR_TEMPERATURE)
+        self.wink.set_temperature(target_temp)
+
+    def set_operation_mode(self, operation_mode):
+        """Set operation mode."""
+        if operation_mode == STATE_COOL:
+            self.wink.set_operation_mode('cool_only')
+        elif operation_mode == STATE_ECO:
+            self.wink.set_operation_mode('auto_eco')
+        elif operation_mode == STATE_OFF:
+            self.wink.set_operation_mode('off')
+        elif operation_mode == STATE_FAN:
+            self.wink.set_operation_mode('fan_only')
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self.wink.current_max_set_point()
+
+    @property
+    def target_temperature_low(self):
+        """Only supports cool."""
+        return None
+
+    @property
+    def target_temperature_high(self):
+        """Only supports cool."""
+        return None
+
+    @property
+    def current_fan_mode(self):
+        """Return the current fan mode."""
+        speed = self.wink.current_fan_speed()
+        if speed <= 0.3 and speed >= 0.0:
+            return SPEED_LOWEST
+        elif speed <= 0.5 and speed > 0.3:
+            return SPEED_LOW
+        elif speed <= 0.8 and speed > 0.5:
+            return SPEED_MEDIUM
+        elif speed <= 1.0 and speed > 0.8:
+            return SPEED_HIGH
+        else:
+            return STATE_UNKNOWN
+
+    @property
+    def fan_list(self):
+        """List of available fan modes."""
+        return [SPEED_LOWEST, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
+
+    def set_fan_mode(self, mode):
+        """Set fan speed."""
+        if mode == SPEED_LOWEST:
+            speed = 0.3
+        elif mode == SPEED_LOW:
+            speed = 0.5
+        elif mode == SPEED_MEDIUM:
+            speed = 0.8
+        elif mode == SPEED_HIGH:
+            speed = 1.0
+        self.wink.set_ac_fan_speed(speed)

homeassistant/components/climate/zwave.py

@@ -1,5 +1,5 @@
 """
-Support for ZWave climate devices.
+Support for Z-Wave climate devices.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.zwave/
@@ -8,8 +8,7 @@ https://home-assistant.io/components/climate.zwave/
 # pylint: disable=import-error
 import logging
 from homeassistant.components.climate import DOMAIN
-from homeassistant.components.climate import (
-    ClimateDevice, ATTR_OPERATION_MODE)
+from homeassistant.components.climate import ClimateDevice
 from homeassistant.components.zwave import ZWaveDeviceEntity
 from homeassistant.components import zwave
 from homeassistant.const import (
@@ -18,44 +17,23 @@ from homeassistant.const import (
 _LOGGER = logging.getLogger(__name__)
 
 CONF_NAME = 'name'
-DEFAULT_NAME = 'ZWave Climate'
+DEFAULT_NAME = 'Z-Wave Climate'
 
 REMOTEC = 0x5254
 REMOTEC_ZXT_120 = 0x8377
 REMOTEC_ZXT_120_THERMOSTAT = (REMOTEC, REMOTEC_ZXT_120)
-
-HORSTMANN = 0x0059
-HORSTMANN_HRT4_ZW = 0x3
-HORSTMANN_HRT4_ZW_THERMOSTAT = (HORSTMANN, HORSTMANN_HRT4_ZW)
+ATTR_OPERATING_STATE = 'operating_state'
+ATTR_FAN_STATE = 'fan_state'
 
 WORKAROUND_ZXT_120 = 'zxt_120'
-WORKAROUND_HRT4_ZW = 'hrt4_zw'
 
 DEVICE_MAPPINGS = {
-    REMOTEC_ZXT_120_THERMOSTAT: WORKAROUND_ZXT_120,
-    HORSTMANN_HRT4_ZW_THERMOSTAT: WORKAROUND_HRT4_ZW
-}
-
-SET_TEMP_TO_INDEX = {
-    'Heat': 1,
-    'Cool': 2,
-    'Auto': 3,
-    'Aux Heat': 4,
-    'Resume': 5,
-    'Fan Only': 6,
-    'Furnace': 7,
-    'Dry Air': 8,
-    'Moist Air': 9,
-    'Auto Changeover': 10,
-    'Heat Econ': 11,
-    'Cool Econ': 12,
-    'Away': 13,
-    'Unknown': 14
+    REMOTEC_ZXT_120_THERMOSTAT: WORKAROUND_ZXT_120
 }
 
 
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the ZWave Climate devices."""
+    """Set up the Z-Wave Climate devices."""
     if discovery_info is None or zwave.NETWORK is None:
         _LOGGER.debug("No discovery_info=%s or no NETWORK=%s",
                       discovery_info, zwave.NETWORK)
@@ -70,13 +48,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
 
 class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
-    """Represents a ZWave Climate device."""
+    """Representation of a Z-Wave Climate device."""
 
     def __init__(self, value, temp_unit):
-        """Initialize the zwave climate device."""
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
+        """Initialize the Z-Wave climate device."""
         ZWaveDeviceEntity.__init__(self, value, DOMAIN)
+        self._index = value.index
         self._node = value.node
         self._target_temperature = None
         self._current_temperature = None
@@ -85,17 +62,13 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
         self._operating_state = None
         self._current_fan_mode = None
         self._fan_list = None
+        self._fan_state = None
         self._current_swing_mode = None
         self._swing_list = None
         self._unit = temp_unit
-        self._index_operation = None
         _LOGGER.debug("temp_unit is %s", self._unit)
         self._zxt_120 = None
-        self._hrt4_zw = None
         self.update_properties()
-        # register listener
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
         # Make sure that we have values for the key before converting to int
         if (value.node.manufacturer_id.strip() and
                 value.node.product_id.strip()):
@@ -106,90 +79,87 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
                     _LOGGER.debug("Remotec ZXT-120 Zwave Thermostat"
                                   " workaround")
                     self._zxt_120 = 1
-                if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_HRT4_ZW:
-                    _LOGGER.debug("Horstmann HRT4-ZW Zwave Thermostat"
-                                  " workaround")
-                    self._hrt4_zw = 1
-
-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.update_properties()
-            self.update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)
 
     def update_properties(self):
-        """Callback on data change for the registered node/value pair."""
+        """Callback on data changes for node values."""
         # Operation Mode
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE).values():
-            self._current_operation = value.data
-            self._index_operation = SET_TEMP_TO_INDEX.get(
-                self._current_operation)
-            self._operation_list = list(value.data_items)
-            _LOGGER.debug("self._operation_list=%s", self._operation_list)
-            _LOGGER.debug("self._current_operation=%s",
-                          self._current_operation)
+        self._current_operation = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE, member='data')
+        operation_list = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE,
+            member='data_items')
+        if operation_list:
+            self._operation_list = list(operation_list)
+        _LOGGER.debug("self._operation_list=%s", self._operation_list)
+        _LOGGER.debug("self._current_operation=%s", self._current_operation)
+
         # Current Temp
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_SENSOR_MULTILEVEL)
-                      .values()):
-            if value.label == 'Temperature':
-                self._current_temperature = int(value.data)
-                self._unit = value.units
+        self._current_temperature = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_SENSOR_MULTILEVEL,
+            label=['Temperature'], member='data')
+        self._unit = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_SENSOR_MULTILEVEL,
+            label=['Temperature'], member='units')
+
         # Fan Mode
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE)
-                      .values()):
-            self._current_fan_mode = value.data
-            self._fan_list = list(value.data_items)
-            _LOGGER.debug("self._fan_list=%s", self._fan_list)
-            _LOGGER.debug("self._current_fan_mode=%s",
-                          self._current_fan_mode)
+        self._current_fan_mode = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE,
+            member='data')
+        fan_list = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE,
+            member='data_items')
+        if fan_list:
+            self._fan_list = list(fan_list)
+        _LOGGER.debug("self._fan_list=%s", self._fan_list)
+        _LOGGER.debug("self._current_fan_mode=%s",
+                      self._current_fan_mode)
         # Swing mode
         if self._zxt_120 == 1:
-            for value in (self._node.get_values(
-                    class_id=zwave.const.COMMAND_CLASS_CONFIGURATION)
-                          .values()):
-                if value.command_class == \
-                   zwave.const.COMMAND_CLASS_CONFIGURATION and \
-                   value.index == 33:
-                    self._current_swing_mode = value.data
-                    self._swing_list = list(value.data_items)
-                    _LOGGER.debug("self._swing_list=%s", self._swing_list)
-                    _LOGGER.debug("self._current_swing_mode=%s",
-                                  self._current_swing_mode)
+            self._current_swing_mode = (
+                self.get_value(
+                    class_id=zwave.const.COMMAND_CLASS_CONFIGURATION,
+                    index=33,
+                    member='data'))
+            swing_list = self.get_value(class_id=zwave.const
+                                        .COMMAND_CLASS_CONFIGURATION,
+                                        index=33,
+                                        member='data_items')
+            if swing_list:
+                self._swing_list = list(swing_list)
+            _LOGGER.debug("self._swing_list=%s", self._swing_list)
+            _LOGGER.debug("self._current_swing_mode=%s",
+                          self._current_swing_mode)
         # Set point
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT)
-                      .values()):
-            if value.data == 0:
-                _LOGGER.debug("Setpoint is 0, setting default to "
-                              "current_temperature=%s",
-                              self._current_temperature)
-                self._target_temperature = int(self._current_temperature)
-                break
-            if self.current_operation is not None and \
-               self.current_operation != 'Off':
-                if self._index_operation != value.index:
-                    continue
-                if self._zxt_120:
+        temps = []
+        for value in (
+                self._node.get_values(
+                    class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT)
+                .values()):
+            temps.append((round(float(value.data)), 1))
+            if value.index == self._index:
+                if value.data == 0:
+                    _LOGGER.debug("Setpoint is 0, setting default to "
+                                  "current_temperature=%s",
+                                  self._current_temperature)
+                    self._target_temperature = (
+                        round((float(self._current_temperature)), 1))
                     break
-                self._target_temperature = int(value.data)
-                break
-            _LOGGER.debug("Device can't set setpoint based on operation mode."
-                          " Defaulting to index=1")
-            self._target_temperature = int(value.data)
+                else:
+                    self._target_temperature = round((float(value.data)), 1)
+
         # Operating state
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_OPERATING_STATE)
-                      .values()):
-            self._operating_state = value.data
+        self._operating_state = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_OPERATING_STATE,
+            member='data')
+
+        # Fan operating state
+        self._fan_state = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_STATE,
+            member='data')
 
     @property
     def should_poll(self):
-        """No polling on ZWave."""
+        """No polling on Z-Wave."""
         return False
 
     @property
@@ -248,92 +218,37 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
             temperature = kwargs.get(ATTR_TEMPERATURE)
         else:
             return
-        operation_mode = kwargs.get(ATTR_OPERATION_MODE)
-        _LOGGER.debug("set_temperature operation_mode=%s", operation_mode)
 
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT)
-                      .values()):
-            if operation_mode is not None:
-                setpoint_mode = SET_TEMP_TO_INDEX.get(operation_mode)
-                if value.index != setpoint_mode:
-                    continue
-                _LOGGER.debug("setpoint_mode=%s", setpoint_mode)
-                value.data = temperature
-                break
-
-            if self.current_operation is not None:
-                if self._hrt4_zw and self.current_operation == 'Off':
-                    # HRT4-ZW can change setpoint when off.
-                    value.data = int(temperature)
-                if self._index_operation != value.index:
-                    continue
-                _LOGGER.debug("self._index_operation=%s and"
-                              " self._current_operation=%s",
-                              self._index_operation,
-                              self._current_operation)
-                if self._zxt_120:
-                    _LOGGER.debug("zxt_120: Setting new setpoint for %s, "
-                                  " operation=%s, temp=%s",
-                                  self._index_operation,
-                                  self._current_operation, temperature)
-                    # ZXT-120 does not support get setpoint
-                    self._target_temperature = temperature
-                    # ZXT-120 responds only to whole int
-                    value.data = round(temperature, 0)
-                    self.update_ha_state()
-                    break
-                else:
-                    _LOGGER.debug("Setting new setpoint for %s, "
-                                  "operation=%s, temp=%s",
-                                  self._index_operation,
-                                  self._current_operation, temperature)
-                    value.data = temperature
-                    break
-            else:
-                _LOGGER.debug("Setting new setpoint for no known "
-                              "operation mode. Index=1 and "
-                              "temperature=%s", temperature)
-                value.data = temperature
-                break
+        self.set_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_SETPOINT,
+            index=self._index, data=temperature)
+        self.update_ha_state()
 
     def set_fan_mode(self, fan):
         """Set new target fan mode."""
-        for value in (self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE).
-                      values()):
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE and \
-               value.index == 0:
-                value.data = bytes(fan, 'utf-8')
-                break
+        self.set_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_FAN_MODE,
+            index=0, data=bytes(fan, 'utf-8'))
 
     def set_operation_mode(self, operation_mode):
         """Set new target operation mode."""
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE).values():
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_THERMOSTAT_MODE and value.index == 0:
-                value.data = bytes(operation_mode, 'utf-8')
-                break
+        self.set_value(
+            class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE,
+            index=0, data=bytes(operation_mode, 'utf-8'))
 
     def set_swing_mode(self, swing_mode):
         """Set new target swing mode."""
         if self._zxt_120 == 1:
-            for value in self._node.get_values(
-                    class_id=zwave.const.COMMAND_CLASS_CONFIGURATION).values():
-                if value.command_class == \
-                   zwave.const.COMMAND_CLASS_CONFIGURATION and \
-                   value.index == 33:
-                    value.data = bytes(swing_mode, 'utf-8')
-                    break
+            self.set_value(
+                class_id=zwave.const.COMMAND_CLASS_CONFIGURATION,
+                index=33, data=bytes(swing_mode, 'utf-8'))
 
     @property
     def device_state_attributes(self):
         """Return the device specific state attributes."""
+        data = super().device_state_attributes
         if self._operating_state:
-            return {
-                "operating_state": self._operating_state,
-            }
-        else:
-            return {}
+            data[ATTR_OPERATING_STATE] = self._operating_state,
+        if self._fan_state:
+            data[ATTR_FAN_STATE] = self._fan_state
+        return data

homeassistant/components/conversation.py

@@ -15,7 +15,7 @@ from homeassistant.const import (
     ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
 import homeassistant.helpers.config_validation as cv
 
-REQUIREMENTS = ['fuzzywuzzy==0.12.0']
+REQUIREMENTS = ['fuzzywuzzy==0.14.0']
 
 ATTR_TEXT = 'text'
 

homeassistant/components/cover/__init__.py

@@ -4,8 +4,11 @@ Support for Cover devices.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover/
 """
-import os
+import asyncio
+from datetime import timedelta
+import functools as ft
 import logging
+import os
 
 import voluptuous as vol
 
@@ -23,7 +26,7 @@ from homeassistant.const import (
 
 
 DOMAIN = 'cover'
-SCAN_INTERVAL = 15
+SCAN_INTERVAL = timedelta(seconds=15)
 
 GROUP_NAME_ALL_COVERS = 'all covers'
 ENTITY_ID_ALL_COVERS = group.ENTITY_ID_FORMAT.format('all_covers')
@@ -52,17 +55,17 @@ COVER_SET_COVER_TILT_POSITION_SCHEMA = COVER_SERVICE_SCHEMA.extend({
 })
 
 SERVICE_TO_METHOD = {
-    SERVICE_OPEN_COVER: {'method': 'open_cover'},
-    SERVICE_CLOSE_COVER: {'method': 'close_cover'},
+    SERVICE_OPEN_COVER: {'method': 'async_open_cover'},
+    SERVICE_CLOSE_COVER: {'method': 'async_close_cover'},
     SERVICE_SET_COVER_POSITION: {
-        'method': 'set_cover_position',
+        'method': 'async_set_cover_position',
         'schema': COVER_SET_COVER_POSITION_SCHEMA},
-    SERVICE_STOP_COVER: {'method': 'stop_cover'},
-    SERVICE_OPEN_COVER_TILT: {'method': 'open_cover_tilt'},
-    SERVICE_CLOSE_COVER_TILT: {'method': 'close_cover_tilt'},
-    SERVICE_STOP_COVER_TILT: {'method': 'stop_cover_tilt'},
+    SERVICE_STOP_COVER: {'method': 'async_stop_cover'},
+    SERVICE_OPEN_COVER_TILT: {'method': 'async_open_cover_tilt'},
+    SERVICE_CLOSE_COVER_TILT: {'method': 'async_close_cover_tilt'},
+    SERVICE_STOP_COVER_TILT: {'method': 'async_stop_cover_tilt'},
     SERVICE_SET_COVER_TILT_POSITION: {
-        'method': 'set_cover_tilt_position',
+        'method': 'async_set_cover_tilt_position',
         'schema': COVER_SET_COVER_TILT_POSITION_SCHEMA},
 }
 
@@ -123,33 +126,53 @@ def stop_cover_tilt(hass, entity_id=None):
     hass.services.call(DOMAIN, SERVICE_STOP_COVER_TILT, data)
 
 
-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
     """Track states and offer events for covers."""
     component = EntityComponent(
         _LOGGER, DOMAIN, hass, SCAN_INTERVAL, GROUP_NAME_ALL_COVERS)
-    component.setup(config)
 
-    def handle_cover_service(service):
+    yield from component.async_setup(config)
+
+    @asyncio.coroutine
+    def async_handle_cover_service(service):
         """Handle calls to the cover services."""
+        covers = component.async_extract_from_service(service)
         method = SERVICE_TO_METHOD.get(service.service)
         params = service.data.copy()
         params.pop(ATTR_ENTITY_ID, None)
 
-        if method:
-            for cover in component.extract_from_service(service):
-                getattr(cover, method['method'])(**params)
+        # call method
+        for cover in covers:
+            yield from getattr(cover, method['method'])(**params)
 
-                if cover.should_poll:
-                    cover.update_ha_state(True)
+        update_tasks = []
 
-    descriptions = load_yaml_config_file(
-        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+        for cover in covers:
+            if not cover.should_poll:
+                continue
+
+            update_coro = hass.loop.create_task(
+                cover.async_update_ha_state(True))
+            if hasattr(cover, 'async_update'):
+                update_tasks.append(update_coro)
+            else:
+                yield from update_coro
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)
+
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml'))
 
     for service_name in SERVICE_TO_METHOD:
         schema = SERVICE_TO_METHOD[service_name].get(
             'schema', COVER_SERVICE_SCHEMA)
-        hass.services.register(DOMAIN, service_name, handle_cover_service,
-                               descriptions.get(service_name), schema=schema)
+        hass.services.async_register(
+            DOMAIN, service_name, async_handle_cover_service,
+            descriptions.get(service_name), schema=schema)
+
     return True
 
 
@@ -207,30 +230,94 @@ class CoverDevice(Entity):
         """Open the cover."""
         raise NotImplementedError()
 
+    def async_open_cover(self, **kwargs):
+        """Open the cover.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.open_cover, **kwargs))
+
     def close_cover(self, **kwargs):
         """Close cover."""
         raise NotImplementedError()
 
+    def async_close_cover(self, **kwargs):
+        """Close cover.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.close_cover, **kwargs))
+
     def set_cover_position(self, **kwargs):
         """Move the cover to a specific position."""
         pass
 
+    def async_set_cover_position(self, **kwargs):
+        """Move the cover to a specific position.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.set_cover_position, **kwargs))
+
     def stop_cover(self, **kwargs):
         """Stop the cover."""
         pass
 
+    def async_stop_cover(self, **kwargs):
+        """Stop the cover.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.stop_cover, **kwargs))
+
     def open_cover_tilt(self, **kwargs):
         """Open the cover tilt."""
         pass
 
+    def async_open_cover_tilt(self, **kwargs):
+        """Open the cover tilt.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.open_cover_tilt, **kwargs))
+
     def close_cover_tilt(self, **kwargs):
         """Close the cover tilt."""
         pass
 
+    def async_close_cover_tilt(self, **kwargs):
+        """Close the cover tilt.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.close_cover_tilt, **kwargs))
+
     def set_cover_tilt_position(self, **kwargs):
         """Move the cover tilt to a specific position."""
         pass
 
+    def async_set_cover_tilt_position(self, **kwargs):
+        """Move the cover tilt to a specific position.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.set_cover_tilt_position, **kwargs))
+
     def stop_cover_tilt(self, **kwargs):
         """Stop the cover."""
         pass
+
+    def async_stop_cover_tilt(self, **kwargs):
+        """Stop the cover.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.stop_cover_tilt, **kwargs))

homeassistant/components/cover/demo.py

@@ -149,7 +149,7 @@ class DemoCover(CoverDevice):
 
         if self._position in (100, 0, self._set_position):
             self.stop_cover()
-        self.update_ha_state()
+        self.schedule_update_ha_state()
 
     def _listen_cover_tilt(self):
         """Listen for changes in cover tilt."""
@@ -167,4 +167,4 @@ class DemoCover(CoverDevice):
         if self._tilt_position in (100, 0, self._set_tilt_position):
             self.stop_cover_tilt()
 
-        self.update_ha_state()
+        self.schedule_update_ha_state()

homeassistant/components/cover/garadget.py

@@ -199,8 +199,7 @@ class GaradgetCover(CoverDevice):
 
     def _check_state(self, now):
         """Check the state of the service during an operation."""
-        self.update()
-        self.update_ha_state()
+        self.schedule_update_ha_state(True)
 
     def close_cover(self):
         """Close the cover."""

homeassistant/components/cover/homematic.py

@@ -12,7 +12,8 @@ import logging
 from homeassistant.const import STATE_UNKNOWN
 from homeassistant.components.cover import CoverDevice,\
     ATTR_POSITION
-import homeassistant.components.homematic as homematic
+from homeassistant.components.homematic import HMDevice
+from homeassistant.loader import get_component
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,14 +25,16 @@ def setup_platform(hass, config, add_callback_devices, discovery_info=None):
     if discovery_info is None:
         return
 
+    homematic = get_component("homematic")
     return homematic.setup_hmdevice_discovery_helper(
+        hass,
         HMCover,
         discovery_info,
         add_callback_devices
     )
 
 
-class HMCover(homematic.HMDevice, CoverDevice):
+class HMCover(HMDevice, CoverDevice):
     """Represents a Homematic Cover in Home Assistant."""
 
     @property

homeassistant/components/cover/mqtt.py

@@ -8,6 +8,7 @@ import logging
 
 import voluptuous as vol
 
+from homeassistant.core import callback
 import homeassistant.components.mqtt as mqtt
 from homeassistant.components.cover import CoverDevice
 from homeassistant.const import (
@@ -89,29 +90,30 @@ class MqttCover(CoverDevice):
         self._retain = retain
         self._optimistic = optimistic or state_topic is None
 
+        @callback
         def message_received(topic, payload, qos):
             """A new MQTT message has been received."""
             if value_template is not None:
-                payload = value_template.render_with_possible_json_value(
+                payload = value_template.async_render_with_possible_json_value(
                     payload)
             if payload == self._state_open:
                 self._state = False
-                _LOGGER.warning("state=%s", int(self._state))
-                self.update_ha_state()
+                hass.async_add_job(self.async_update_ha_state())
             elif payload == self._state_closed:
                 self._state = True
-                self.update_ha_state()
+                hass.async_add_job(self.async_update_ha_state())
             elif payload.isnumeric() and 0 <= int(payload) <= 100:
                 if int(payload) > 0:
                     self._state = False
                 else:
                     self._state = True
                 self._position = int(payload)
-                self.update_ha_state()
+                hass.async_add_job(self.async_update_ha_state())
             else:
                 _LOGGER.warning(
                     "Payload is not True, False, or integer (0-100): %s",
                     payload)
+
         if self._state_topic is None:
             # Force into optimistic mode.
             self._optimistic = True
@@ -149,7 +151,7 @@ class MqttCover(CoverDevice):
         if self._optimistic:
             # Optimistically assume that cover has changed state.
             self._state = False
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def close_cover(self, **kwargs):
         """Move the cover down."""
@@ -158,7 +160,7 @@ class MqttCover(CoverDevice):
         if self._optimistic:
             # Optimistically assume that cover has changed state.
             self._state = True
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def stop_cover(self, **kwargs):
         """Stop the device."""

homeassistant/components/cover/mysensors.py

@@ -18,7 +18,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the mysensors platform for covers."""
     if discovery_info is None:
         return
-    for gateway in mysensors.GATEWAYS.values():
+
+    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
+    if not gateways:
+        return
+
+    for gateway in gateways:
         pres = gateway.const.Presentation
         set_req = gateway.const.SetReq
         map_sv_types = {
@@ -30,7 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             })
         devices = {}
         gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsCover))
+            map_sv_types, devices, MySensorsCover, add_devices))
 
 
 class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
@@ -70,7 +75,7 @@ class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
                 self._values[set_req.V_DIMMER] = 100
             else:
                 self._values[set_req.V_LIGHT] = STATE_ON
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def close_cover(self, **kwargs):
         """Move the cover down."""
@@ -83,7 +88,7 @@ class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
                 self._values[set_req.V_DIMMER] = 0
             else:
                 self._values[set_req.V_LIGHT] = STATE_OFF
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def set_cover_position(self, **kwargs):
         """Move the cover to a specific position."""
@@ -94,7 +99,7 @@ class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
         if self.gateway.optimistic:
             # Optimistically assume that cover has changed state.
             self._values[set_req.V_DIMMER] = position
-            self.update_ha_state()
+            self.schedule_update_ha_state()
 
     def stop_cover(self, **kwargs):
         """Stop the device."""

homeassistant/components/cover/tellduslive.py

@@ -0,0 +1,46 @@
+"""
+Support for Tellstick covers using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/cover.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.cover import CoverDevice
+from homeassistant.components.tellduslive import TelldusLiveEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup covers."""
+    if discovery_info is None:
+        return
+    add_devices(TelldusLiveCover(hass, cover) for cover in discovery_info)
+
+
+class TelldusLiveCover(TelldusLiveEntity, CoverDevice):
+    """Representation of a cover."""
+
+    @property
+    def is_closed(self):
+        """Return the current position of the cover."""
+        return self.device.is_down
+
+    def close_cover(self, **kwargs):
+        """Close the cover."""
+        self.device.down()
+        self.changed()
+
+    def open_cover(self, **kwargs):
+        """Open the cover."""
+        self.device.up()
+        self.changed()
+
+    def stop_cover(self, **kwargs):
+        """Stop the cover."""
+        self.device.stop()
+        self.changed()

homeassistant/components/cover/wink.py

@@ -6,7 +6,7 @@ https://home-assistant.io/components/cover.wink/
 """
 
 from homeassistant.components.cover import CoverDevice
-from homeassistant.components.wink import WinkDevice
+from homeassistant.components.wink import WinkDevice, DOMAIN
 
 DEPENDENCIES = ['wink']
 
@@ -15,18 +15,22 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
     """Setup the Wink cover platform."""
     import pywink
 
-    add_devices(WinkCoverDevice(shade) for shade in
-                pywink.get_shades())
-    add_devices(WinkCoverDevice(door) for door in
-                pywink.get_garage_doors())
+    for shade in pywink.get_shades():
+        _id = shade.object_id() + shade.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkCoverDevice(shade, hass)])
+    for door in pywink.get_garage_doors():
+        _id = door.object_id() + door.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkCoverDevice(door, hass)])
 
 
 class WinkCoverDevice(WinkDevice, CoverDevice):
     """Representation of a Wink cover device."""
 
-    def __init__(self, wink):
+    def __init__(self, wink, hass):
         """Initialize the cover."""
-        WinkDevice.__init__(self, wink)
+        super().__init__(wink, hass)
 
     def close_cover(self):
         """Close the shade."""
@@ -36,13 +40,17 @@ class WinkCoverDevice(WinkDevice, CoverDevice):
         """Open the shade."""
         self.wink.set_state(1)
 
+    def set_cover_position(self, position, **kwargs):
+        """Move the roller shutter to a specific position."""
+        self.wink.set_state(float(position)/100)
+
+    @property
+    def current_cover_position(self):
+        """Return the current position of roller shutter."""
+        return int(self.wink.state()*100)
+
     @property
     def is_closed(self):
         """Return if the cover is closed."""
         state = self.wink.state()
-        if state == 0:
-            return True
-        elif state == 1:
-            return False
-        else:
-            return None
+        return bool(state == 0)

homeassistant/components/cover/zwave.py

@@ -36,15 +36,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
             and value.index == 0):
         value.set_change_verified(False)
         add_devices([ZwaveRollershutter(value)])
-    elif value.node.specific == zwave.const.GENERIC_TYPE_ENTRY_CONTROL:
-        if (value.command_class == zwave.const.COMMAND_CLASS_SWITCH_BINARY or
-                value.command_class ==
-                zwave.const.COMMAND_CLASS_BARRIER_OPERATOR):
-            if (value.type != zwave.const.TYPE_BOOL and
-                    value.genre != zwave.const.GENRE_USER):
-                return
-            value.set_change_verified(False)
-            add_devices([ZwaveGarageDoor(value)])
+    elif (value.command_class == zwave.const.COMMAND_CLASS_SWITCH_BINARY or
+          value.command_class == zwave.const.COMMAND_CLASS_BARRIER_OPERATOR):
+        if (value.type != zwave.const.TYPE_BOOL and
+                value.genre != zwave.const.GENRE_USER):
+            return
+        value.set_change_verified(False)
+        add_devices([ZwaveGarageDoor(value)])
     else:
         return
 
@@ -54,18 +52,13 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
 
     def __init__(self, value):
         """Initialize the zwave rollershutter."""
-        import libopenzwave
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
         ZWaveDeviceEntity.__init__(self, value, DOMAIN)
         # pylint: disable=no-member
-        self._lozwmgr = libopenzwave.PyManager()
-        self._lozwmgr.create()
         self._node = value.node
+        self._open_id = None
+        self._close_id = None
         self._current_position = None
         self._workaround = None
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
         if (value.node.manufacturer_id.strip() and
                 value.node.product_id.strip()):
             specific_sensor_key = (int(value.node.manufacturer_id, 16),
@@ -76,23 +69,18 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
                     _LOGGER.debug("Controller without positioning feedback")
                     self._workaround = 1
 
-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.update_properties()
-            self.update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)
-
     def update_properties(self):
-        """Callback on data change for the registered node/value pair."""
+        """Callback on data changes for node values."""
         # Position value
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and \
-               value.label == 'Level':
-                self._current_position = value.data
+        self._current_position = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL,
+            label=['Level'], member='data')
+        self._open_id = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL,
+            label=['Open', 'Up'], member='value_id')
+        self._close_id = self.get_value(
+            class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL,
+            label=['Close', 'Down'], member='value_id')
 
     @property
     def is_closed(self):
@@ -118,27 +106,11 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
 
     def open_cover(self, **kwargs):
         """Move the roller shutter up."""
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Open' or value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Up':
-                self._lozwmgr.pressButton(value.value_id)
-                break
+        zwave.NETWORK.manager.pressButton(self._open_id)
 
     def close_cover(self, **kwargs):
         """Move the roller shutter down."""
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Down' or value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Close':
-                self._lozwmgr.pressButton(value.value_id)
-                break
+        zwave.NETWORK.manager.pressButton(self._close_id)
 
     def set_cover_position(self, position, **kwargs):
         """Move the roller shutter to a specific position."""
@@ -146,15 +118,7 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
 
     def stop_cover(self, **kwargs):
         """Stop the roller shutter."""
-        for value in self._node.get_values(
-                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
-            if value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Open' or value.command_class == \
-               zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL and value.label == \
-               'Down':
-                self._lozwmgr.releaseButton(value.value_id)
-                break
+        zwave.NETWORK.manager.releaseButton(self._open_id)
 
 
 class ZwaveGarageDoor(zwave.ZWaveDeviceEntity, CoverDevice):
@@ -162,24 +126,12 @@ class ZwaveGarageDoor(zwave.ZWaveDeviceEntity, CoverDevice):
 
     def __init__(self, value):
         """Initialize the zwave garage door."""
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
         ZWaveDeviceEntity.__init__(self, value, DOMAIN)
-        self._state = value.data
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
-
-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id:
-            self._state = value.data
-            self.update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)
 
     @property
     def is_closed(self):
         """Return the current position of Zwave garage door."""
-        return not self._state
+        return not self._value.data
 
     def close_cover(self):
         """Close the garage door."""