Merge pull request #20 from USA-RedDragon/start-error-handling

Add preliminary error handling support

.github/workflows/release.yml

@@ -12,6 +12,6 @@ jobs:
         run: zip -r badnest.zip hacs.json info.md custom_components
       - uses: JasonEtco/upload-to-release@master
         with:
-          args: badnest.zip
+          args: badnest.zip application/zip
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

custom_components/badnest/api.py

@@ -1,4 +1,5 @@
 import requests
+import logging
 
 API_URL = "https://home.nest.com"
 CAMERA_WEBAPI_BASE = "https://webapi.camera.home.nest.com"
@@ -8,18 +9,34 @@ USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) " \
              "Chrome/75.0.3770.100 Safari/537.36"
 URL_JWT = "https://nestauthproxyservice-pa.googleapis.com/v1/issue_jwt"
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class NestAPI:
-    def __init__(self, email, password, issue_token, cookie, api_key):
+    def __init__(self,
+                 email,
+                 password,
+                 issue_token,
+                 cookie,
+                 api_key,
+                 device_id=None):
         self._user_id = None
         self._access_token = None
         self._session = requests.Session()
         self._session.headers.update({"Referer": "https://home.nest.com/"})
-        self._device_id = None
+        self._device_id = device_id
-        if not email and not password:
+        self._email = email
-            self._login_google(issue_token, cookie, api_key)
+        self._password = password
+        self._issue_token = issue_token
+        self._cookie = cookie
+        self._api_key = api_key
+        self.login()
+
+    def login(self):
+        if not self._email and not self._password:
+            self._login_google(self._issue_token, self._cookie, self._api_key)
         else:
-            self._login_nest(email, password)
+            self._login_nest(self._email, self._password)
 
     def _login_nest(self, email, password):
         r = self._session.post(
@@ -57,14 +74,20 @@ class NestAPI:
 
 
 class NestThermostatAPI(NestAPI):
-    def __init__(self, email, password, issue_token, cookie, api_key):
+    def __init__(self,
+                 email,
+                 password,
+                 issue_token,
+                 cookie,
+                 api_key,
+                 device_id=None):
         super(NestThermostatAPI, self).__init__(
             email,
             password,
             issue_token,
             cookie,
-            api_key)
+            api_key,
-        self._shared_id = None
+            device_id)
         self._czfe_url = None
         self._compressor_lockout_enabled = None
         self._compressor_lockout_time = None
@@ -77,7 +100,6 @@ class NestThermostatAPI(NestAPI):
         self.can_cool = None
         self.has_fan = None
         self.fan = None
-        self.away = None
         self.current_temperature = None
         self.target_temperature = None
         self.target_temperature_high = None
@@ -85,6 +107,29 @@ class NestThermostatAPI(NestAPI):
         self.current_humidity = None
         self.update()
 
+    def get_devices(self):
+        try:
+            r = self._session.post(
+                f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
+                json={
+                    "known_bucket_types": ["buckets"],
+                    "known_bucket_versions": [],
+                },
+                headers={"Authorization": f"Basic {self._access_token}"},
+            )
+            devices = []
+            buckets = r.json()['updated_buckets'][0]['value']['buckets']
+            for bucket in buckets:
+                if bucket.startswith('device.'):
+                    devices.append(bucket.replace('device.', ''))
+
+            return devices
+        except requests.exceptions.RequestException as e:
+            _LOGGER.error(e)
+            _LOGGER.error('Failed to get devices, trying to log in again')
+            self.login()
+            return self.get_devices()
+
     def get_action(self):
         if self._hvac_ac_state:
             return "cooling"
@@ -94,49 +139,62 @@ class NestThermostatAPI(NestAPI):
             return "off"
 
     def update(self):
-        r = self._session.post(
+        try:
-            f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
+            r = self._session.post(
-            json={
+                f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
-                "known_bucket_types": ["shared", "device"],
+                json={
-                "known_bucket_versions": [],
+                    "known_bucket_types": ["shared", "device"],
-            },
+                    "known_bucket_versions": [],
-            headers={"Authorization": f"Basic {self._access_token}"},
+                },
-        )
+                headers={"Authorization": f"Basic {self._access_token}"},
+            )
 
-        self._czfe_url = r.json()["service_urls"]["urls"]["czfe_url"]
+            self._czfe_url = r.json()["service_urls"]["urls"]["czfe_url"]
 
-        for bucket in r.json()["updated_buckets"]:
+            temp_mode = None
-            if bucket["object_key"].startswith("shared."):
+            for bucket in r.json()["updated_buckets"]:
-                self._shared_id = bucket["object_key"]
+                if bucket["object_key"] \
-                thermostat_data = bucket["value"]
+                        .startswith(f"shared.{self._device_id}"):
-                self.current_temperature = \
+                    thermostat_data = bucket["value"]
-                    thermostat_data["current_temperature"]
+                    self.current_temperature = \
-                self.target_temperature = thermostat_data["target_temperature"]
+                        thermostat_data["current_temperature"]
-                self._compressor_lockout_enabled = thermostat_data[
+                    self.target_temperature = \
-                    "compressor_lockout_enabled"
+                        thermostat_data["target_temperature"]
-                ]
+                    self._compressor_lockout_enabled = thermostat_data[
-                self._compressor_lockout_time = thermostat_data[
+                        "compressor_lockout_enabled"
-                    "compressor_lockout_timeout"
+                    ]
-                ]
+                    self._compressor_lockout_time = thermostat_data[
-                self._hvac_ac_state = thermostat_data["hvac_ac_state"]
+                        "compressor_lockout_timeout"
-                self._hvac_heater_state = thermostat_data["hvac_heater_state"]
+                    ]
-                self.mode = thermostat_data["target_temperature_type"]
+                    self._hvac_ac_state = thermostat_data["hvac_ac_state"]
-                self.target_temperature_high = thermostat_data[
+                    self._hvac_heater_state = \
-                    "target_temperature_high"
+                        thermostat_data["hvac_heater_state"]
-                ]
+                    temp_mode = thermostat_data["target_temperature_type"]
-                self.target_temperature_low = \
+                    self.target_temperature_high = thermostat_data[
-                    thermostat_data["target_temperature_low"]
+                        "target_temperature_high"
-                self.can_heat = thermostat_data["can_heat"]
+                    ]
-                self.can_cool = thermostat_data["can_cool"]
+                    self.target_temperature_low = \
-            elif bucket["object_key"].startswith("device."):
+                        thermostat_data["target_temperature_low"]
-                self._device_id = bucket["object_key"]
+                    self.can_heat = thermostat_data["can_heat"]
-                thermostat_data = bucket["value"]
+                    self.can_cool = thermostat_data["can_cool"]
-                self._time_to_target = thermostat_data["time_to_target"]
+                elif bucket["object_key"] \
-                self._fan_timer_timeout = thermostat_data["fan_timer_timeout"]
+                        .startswith(f"device.{self._device_id}"):
-                self.has_fan = thermostat_data["has_fan"]
+                    thermostat_data = bucket["value"]
-                self.fan = thermostat_data["fan_timer_timeout"] > 0
+                    self._time_to_target = thermostat_data["time_to_target"]
-                self.current_humidity = thermostat_data["current_humidity"]
+                    self._fan_timer_timeout = \
-                self.away = thermostat_data["home_away_input"]
+                        thermostat_data["fan_timer_timeout"]
+                    self.has_fan = thermostat_data["has_fan"]
+                    self.fan = thermostat_data["fan_timer_timeout"] > 0
+                    self.current_humidity = thermostat_data["current_humidity"]
+                    if thermostat_data["eco"]["mode"] == 'manual-eco' or \
+                            thermostat_data["eco"]["mode"] == 'auto-eco':
+                        temp_mode = 'eco'
+            self.mode = temp_mode
+        except requests.exceptions.RequestException as e:
+            _LOGGER.error(e)
+            _LOGGER.error('Failed to update, trying to log in again')
+            self.login()
+            self.update()
 
     def set_temp(self, temp, temp_high=None):
         if temp_high is None:
@@ -145,7 +203,7 @@ class NestThermostatAPI(NestAPI):
                 json={
                     "objects": [
                         {
-                            "object_key": self._shared_id,
+                            "object_key": f'shared.{self._device_id}',
                             "op": "MERGE",
                             "value": {"target_temperature": temp},
                         }
@@ -159,7 +217,7 @@ class NestThermostatAPI(NestAPI):
                 json={
                     "objects": [
                         {
-                            "object_key": self._shared_id,
+                            "object_key": f'shared.{self._device_id}',
                             "op": "MERGE",
                             "value": {
                                 "target_temperature_low": temp,
@@ -177,7 +235,7 @@ class NestThermostatAPI(NestAPI):
             json={
                 "objects": [
                     {
-                        "object_key": self._shared_id,
+                        "object_key": f'shared.{self._device_id}',
                         "op": "MERGE",
                         "value": {"target_temperature_type": mode},
                     }
@@ -192,7 +250,7 @@ class NestThermostatAPI(NestAPI):
             json={
                 "objects": [
                     {
-                        "object_key": self._device_id,
+                        "object_key": f'device.{self._device_id}',
                         "op": "MERGE",
                         "value": {"fan_timer_timeout": date},
                     }
@@ -201,15 +259,16 @@ class NestThermostatAPI(NestAPI):
             headers={"Authorization": f"Basic {self._access_token}"},
         )
 
-    def set_eco_mode(self):
+    def set_eco_mode(self, state):
+        mode = 'manual-eco' if state else 'schedule'
         self._session.post(
             f"{self._czfe_url}/v5/put",
             json={
                 "objects": [
                     {
-                        "object_key": self._device_id,
+                        "object_key": f'device.{self._device_id}',
                         "op": "MERGE",
-                        "value": {"eco": {"mode": "manual-eco"}},
+                        "value": {"eco": {"mode": mode}},
                     }
                 ]
             },
@@ -217,6 +276,60 @@ class NestThermostatAPI(NestAPI):
         )
 
 
+class NestTemperatureSensorAPI(NestAPI):
+    def __init__(self,
+                 email,
+                 password,
+                 issue_token,
+                 cookie,
+                 api_key,
+                 device_id=None):
+        super(NestTemperatureSensorAPI, self).__init__(
+            email,
+            password,
+            issue_token,
+            cookie,
+            api_key,
+            device_id)
+        self.temperature = None
+        self._device_id = device_id
+        self.update()
+
+    def get_devices(self):
+        r = self._session.post(
+            f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
+            json={
+                "known_bucket_types": ["buckets"],
+                "known_bucket_versions": [],
+            },
+            headers={"Authorization": f"Basic {self._access_token}"},
+        )
+        devices = []
+        buckets = r.json()['updated_buckets'][0]['value']['buckets']
+        for bucket in buckets:
+            if bucket.startswith('kryptonite.'):
+                devices.append(bucket.replace('kryptonite.', ''))
+
+        return devices
+
+    def update(self):
+        r = self._session.post(
+            f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
+            json={
+                "known_bucket_types": ["kryptonite"],
+                "known_bucket_versions": [],
+            },
+            headers={"Authorization": f"Basic {self._access_token}"},
+        )
+
+        for bucket in r.json()["updated_buckets"]:
+            if bucket["object_key"].startswith(
+                    f"kryptonite.{self._device_id}"):
+                sensor_data = bucket["value"]
+                self.temperature = sensor_data["current_temperature"]
+                self.battery_level = sensor_data["battery_level"]
+
+
 class NestCameraAPI(NestAPI):
     def __init__(self, email, password, issue_token, cookie, api_key):
         super(NestCameraAPI, self).__init__(

custom_components/badnest/climate.py

@@ -13,9 +13,9 @@ from homeassistant.components.climate.const import (
     HVAC_MODE_HEAT,
     HVAC_MODE_OFF,
     SUPPORT_FAN_MODE,
+    SUPPORT_PRESET_MODE,
     SUPPORT_TARGET_TEMPERATURE,
     SUPPORT_TARGET_TEMPERATURE_RANGE,
-    PRESET_AWAY,
     PRESET_ECO,
     PRESET_NONE,
     CURRENT_HVAC_HEAT,
@@ -53,9 +53,7 @@ ACTION_NEST_TO_HASS = {
 
 MODE_NEST_TO_HASS = {v: k for k, v in MODE_HASS_TO_NEST.items()}
 
-PRESET_AWAY_AND_ECO = "Away and Eco"
+PRESET_MODES = [PRESET_NONE, PRESET_ECO]
-
-PRESET_MODES = [PRESET_NONE, PRESET_AWAY, PRESET_ECO, PRESET_AWAY_AND_ECO]
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -65,7 +63,7 @@ async def async_setup_platform(hass,
                                async_add_entities,
                                discovery_info=None):
     """Set up the Nest climate device."""
-    nest = NestThermostatAPI(
+    api = NestThermostatAPI(
         hass.data[DOMAIN][CONF_EMAIL],
         hass.data[DOMAIN][CONF_PASSWORD],
         hass.data[DOMAIN][CONF_ISSUE_TOKEN],
@@ -73,21 +71,34 @@ async def async_setup_platform(hass,
         hass.data[DOMAIN][CONF_APIKEY]
     )
 
-    async_add_entities([NestClimate(nest)])
+    thermostats = []
+    _LOGGER.info("Adding thermostats")
+    for thermostat in api.get_devices():
+        _LOGGER.info(f"Adding nest thermostat uuid: {thermostat}")
+        thermostats.append(NestClimate(thermostat, NestThermostatAPI(
+            hass.data[DOMAIN][CONF_EMAIL],
+            hass.data[DOMAIN][CONF_PASSWORD],
+            hass.data[DOMAIN][CONF_ISSUE_TOKEN],
+            hass.data[DOMAIN][CONF_COOKIE],
+            hass.data[DOMAIN][CONF_APIKEY],
+            thermostat
+        )))
+
+    async_add_entities(thermostats)
 
 
 class NestClimate(ClimateDevice):
     """Representation of a Nest climate device."""
 
-    def __init__(self, api):
+    def __init__(self, device_id, api):
         """Initialize the thermostat."""
         self._name = "Nest Thermostat"
         self._unit_of_measurement = TEMP_CELSIUS
         self._fan_modes = [FAN_ON, FAN_AUTO]
+        self.device_id = device_id
 
         # Set the default supported features
-        self._support_flags = SUPPORT_TARGET_TEMPERATURE
+        self._support_flags = SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE
-        # | SUPPORT_PRESET_MODE
 
         # Not all nest devices support cooling and heating remove unused
         self._operation_list = []
@@ -111,6 +122,11 @@ class NestClimate(ClimateDevice):
         if self.device.has_fan:
             self._support_flags = self._support_flags | SUPPORT_FAN_MODE
 
+    @property
+    def unique_id(self):
+        """Return an unique ID."""
+        return self.device_id
+
     @property
     def supported_features(self):
         """Return the list of supported features."""
@@ -124,7 +140,7 @@ class NestClimate(ClimateDevice):
     @property
     def name(self):
         """Return the name of the climate device."""
-        return self._name
+        return self.device_id
 
     @property
     def temperature_unit(self):
@@ -136,6 +152,11 @@ class NestClimate(ClimateDevice):
         """Return the current temperature."""
         return self.device.current_temperature
 
+    @property
+    def current_humidity(self):
+        """Return the current humidity."""
+        return self.device.current_humidity
+
     @property
     def target_temperature(self):
         """Return the temperature we try to reach."""
@@ -185,16 +206,10 @@ class NestClimate(ClimateDevice):
     @property
     def preset_mode(self):
         """Return current preset mode."""
-        if self.device.away and self.device.mode == NEST_MODE_ECO:
-            return PRESET_AWAY_AND_ECO
-
-        if self.device.away:
-            return PRESET_AWAY
-
         if self.device.mode == NEST_MODE_ECO:
             return PRESET_ECO
 
-        return None
+        return PRESET_NONE
 
     @property
     def preset_modes(self):
@@ -244,20 +259,11 @@ class NestClimate(ClimateDevice):
 
     def set_preset_mode(self, preset_mode):
         """Set preset mode."""
-        need_away = preset_mode in (PRESET_AWAY, PRESET_AWAY_AND_ECO)
+        need_eco = preset_mode in (PRESET_ECO)
-        need_eco = preset_mode in (PRESET_ECO, PRESET_AWAY_AND_ECO)
-        is_away = self.device.away
         is_eco = self.device.mode == NEST_MODE_ECO
 
-        if is_away != need_away:
-            pass
-            # self.device.set_away()
-
         if is_eco != need_eco:
-            if need_eco:
+            self.device.set_eco_mode(need_eco)
-                self.device.set_eco_mode()
-            else:
-                self.device.mode = MODE_HASS_TO_NEST[self._operation_list[0]]
 
     def update(self):
         """Updates data"""

custom_components/badnest/sensor.py

@@ -0,0 +1,88 @@
+import logging
+
+from homeassistant.helpers.entity import Entity
+
+from .api import NestTemperatureSensorAPI
+from .const import DOMAIN, CONF_APIKEY, CONF_COOKIE, CONF_ISSUE_TOKEN
+
+from homeassistant.const import (
+    ATTR_BATTERY_LEVEL,
+    DEVICE_CLASS_TEMPERATURE,
+    CONF_EMAIL,
+    CONF_PASSWORD,
+    TEMP_CELSIUS
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_platform(hass,
+                               config,
+                               async_add_entities,
+                               discovery_info=None):
+    """Set up the Nest climate device."""
+    api = NestTemperatureSensorAPI(
+        hass.data[DOMAIN][CONF_EMAIL],
+        hass.data[DOMAIN][CONF_PASSWORD],
+        hass.data[DOMAIN][CONF_ISSUE_TOKEN],
+        hass.data[DOMAIN][CONF_COOKIE],
+        hass.data[DOMAIN][CONF_APIKEY]
+    )
+
+    sensors = []
+    _LOGGER.info("Adding temperature sensors")
+    for sensor in api.get_devices():
+        _LOGGER.info(f"Adding nest temp sensor uuid: {sensor}")
+        sensors.append(
+            NestTemperatureSensor(
+                sensor,
+                NestTemperatureSensorAPI(
+                    hass.data[DOMAIN][CONF_EMAIL],
+                    hass.data[DOMAIN][CONF_PASSWORD],
+                    hass.data[DOMAIN][CONF_ISSUE_TOKEN],
+                    hass.data[DOMAIN][CONF_COOKIE],
+                    hass.data[DOMAIN][CONF_APIKEY],
+                    sensor
+                )))
+
+    async_add_entities(sensors)
+
+
+class NestTemperatureSensor(Entity):
+    """Implementation of the DHT sensor."""
+
+    def __init__(self, device_id, api):
+        """Initialize the sensor."""
+        self._name = "Nest Temperature Sensor"
+        self._unit_of_measurement = TEMP_CELSIUS
+        self.device_id = device_id
+        self.device = api
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self.device_id
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self.device.temperature
+
+    @property
+    def device_class(self):
+        """Return the device class of this entity."""
+        return DEVICE_CLASS_TEMPERATURE
+
+    @property
+    def unit_of_measurement(self):
+        """Return the unit of measurement of this entity, if any."""
+        return self._unit_of_measurement
+
+    def update(self):
+        """Get the latest data from the DHT and updates the states."""
+        self.device.update()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {ATTR_BATTERY_LEVEL: self.device.battery_level}

hacs.json

@@ -1,4 +1,4 @@
 {
     "name": "Bad Nest Thermostat",
-    "domains": ["climate", "camera"]
+    "domains": ["climate", "camera", "sensor"]
 }

info.md

@@ -28,6 +28,9 @@ climate:
 
 camera:
   - platform: badnest
+
+sensor:
+  - platform: badnest
 ```
 
 ## Example configuration.yaml - When you are using the Google Auth Login
@@ -44,6 +47,9 @@ climate:
 
 camera:
   - platform: badnest
+
+sensor:
+  - platform: badnest
 ```
 
 Google Login support added with many thanks to: chrisjshull from <https://github.com/chrisjshull/homebridge-nest/>