Merge pull request #24 from USA-RedDragon/cameras-multiple-api-instances

Attempt to make the camera's use different API instances

.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

@@ -25,10 +25,18 @@ class NestAPI:
         self._session = requests.Session()
         self._session.headers.update({"Referer": "https://home.nest.com/"})
         self._device_id = device_id
-        if not email and not password:
-            self._login_google(issue_token, cookie, api_key)
+        self._email = email
+        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(
@@ -92,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
@@ -101,21 +108,30 @@ class NestThermostatAPI(NestAPI):
         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('device.'):
-                devices.append(bucket.replace('device.', ''))
+        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
+            return devices
+        except requests.exceptions.RequestException as e:
+            _LOGGER.error(e)
+            _LOGGER.error('Failed to get devices, trying again')
+            return self.get_devices()
+        except KeyError:
+            _LOGGER.debug('Failed to get devices, trying to log in again')
+            self.login()
+            return self.get_devices()
 
     def get_action(self):
         if self._hvac_ac_state:
@@ -126,47 +142,66 @@ class NestThermostatAPI(NestAPI):
             return "off"
 
     def update(self):
-        r = self._session.post(
-            f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
-            json={
-                "known_bucket_types": ["shared", "device"],
-                "known_bucket_versions": [],
-            },
-            headers={"Authorization": f"Basic {self._access_token}"},
-        )
+        try:
+            r = self._session.post(
+                f"{API_URL}/api/0.1/user/{self._user_id}/app_launch",
+                json={
+                    "known_bucket_types": ["shared", "device"],
+                    "known_bucket_versions": [],
+                },
+                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"]:
-            if bucket["object_key"].startswith(f"shared.{self._device_id}"):
-                thermostat_data = bucket["value"]
-                self.current_temperature = \
-                    thermostat_data["current_temperature"]
-                self.target_temperature = thermostat_data["target_temperature"]
-                self._compressor_lockout_enabled = thermostat_data[
-                    "compressor_lockout_enabled"
-                ]
-                self._compressor_lockout_time = thermostat_data[
-                    "compressor_lockout_timeout"
-                ]
-                self._hvac_ac_state = thermostat_data["hvac_ac_state"]
-                self._hvac_heater_state = thermostat_data["hvac_heater_state"]
-                self.mode = thermostat_data["target_temperature_type"]
-                self.target_temperature_high = thermostat_data[
-                    "target_temperature_high"
-                ]
-                self.target_temperature_low = \
-                    thermostat_data["target_temperature_low"]
-                self.can_heat = thermostat_data["can_heat"]
-                self.can_cool = thermostat_data["can_cool"]
-            elif bucket["object_key"].startswith(f"device.{self._device_id}"):
-                thermostat_data = bucket["value"]
-                self._time_to_target = thermostat_data["time_to_target"]
-                self._fan_timer_timeout = 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"]
-                self.away = thermostat_data["home_away_input"]
+            temp_mode = None
+            for bucket in r.json()["updated_buckets"]:
+                if bucket["object_key"] \
+                        .startswith(f"shared.{self._device_id}"):
+                    thermostat_data = bucket["value"]
+                    self.current_temperature = \
+                        thermostat_data["current_temperature"]
+                    self.target_temperature = \
+                        thermostat_data["target_temperature"]
+                    self._compressor_lockout_enabled = thermostat_data[
+                        "compressor_lockout_enabled"
+                    ]
+                    self._compressor_lockout_time = thermostat_data[
+                        "compressor_lockout_timeout"
+                    ]
+                    self._hvac_ac_state = thermostat_data["hvac_ac_state"]
+                    self._hvac_heater_state = \
+                        thermostat_data["hvac_heater_state"]
+                    if temp_mode is None:
+                        temp_mode = thermostat_data["target_temperature_type"]
+                    self.target_temperature_high = thermostat_data[
+                        "target_temperature_high"
+                    ]
+                    self.target_temperature_low = \
+                        thermostat_data["target_temperature_low"]
+                    self.can_heat = thermostat_data["can_heat"]
+                    self.can_cool = thermostat_data["can_cool"]
+                elif bucket["object_key"] \
+                        .startswith(f"device.{self._device_id}"):
+                    thermostat_data = bucket["value"]
+                    self._time_to_target = thermostat_data["time_to_target"]
+                    self._fan_timer_timeout = \
+                        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 again')
+            self.update()
+        except KeyError:
+            _LOGGER.debug('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:
@@ -231,7 +266,8 @@ 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={
@@ -239,7 +275,7 @@ class NestThermostatAPI(NestAPI):
                     {
                         "object_key": f'device.{self._device_id}',
                         "op": "MERGE",
-                        "value": {"eco": {"mode": "manual-eco"}},
+                        "value": {"eco": {"mode": mode}},
                     }
                 ]
             },
@@ -267,53 +303,79 @@ class NestTemperatureSensorAPI(NestAPI):
         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.', ''))
+        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('kryptonite.'):
+                    devices.append(bucket.replace('kryptonite.', ''))
 
-        return devices
+            return devices
+        except requests.exceptions.RequestException as e:
+            _LOGGER.error(e)
+            _LOGGER.error('Failed to get devices, trying again')
+            return self.get_devices()
+        except KeyError:
+            _LOGGER.debug('Failed to get devices, trying to log in again')
+            self.login()
+            return self.get_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}"},
-        )
+        try:
+            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"]
+            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"]
+        except requests.exceptions.RequestException as e:
+            _LOGGER.error(e)
+            _LOGGER.error('Failed to update, trying again')
+            self.update()
+        except KeyError:
+            _LOGGER.debug('Failed to update, trying to log in again')
+            self.login()
+            self.update()
 
 
 class NestCameraAPI(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(NestCameraAPI, self).__init__(
             email,
             password,
             issue_token,
             cookie,
-            api_key)
+            api_key,
+            device_id)
         # log into dropcam
         self._session.post(
             f"{API_URL}/dropcam/api/login",
             data={"access_token": self._access_token}
         )
+        self._device_id = device_id
         self.location = None
         self.name = "Nest Camera"
         self.online = None
@@ -323,10 +385,6 @@ class NestCameraAPI(NestAPI):
         self.data_tier = None
         self.update()
 
-    def set_device(self, uuid):
-        self._device_id = uuid
-        self.update()
-
     def update(self):
         if self._device_id:
             props = self.get_properties()

custom_components/badnest/camera.py

@@ -13,7 +13,6 @@ from .const import DOMAIN, CONF_ISSUE_TOKEN, CONF_COOKIE, CONF_APIKEY
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME = "Nest Camera"
-DATA_KEY = "camera.badnest"
 
 
 async def async_setup_platform(hass,
@@ -21,8 +20,6 @@ async def async_setup_platform(hass,
                                async_add_entities,
                                discovery_info=None):
     """Set up a Nest Camera."""
-    hass.data[DATA_KEY] = dict()
-
     api = NestCameraAPI(
         hass.data[DOMAIN][CONF_EMAIL],
         hass.data[DOMAIN][CONF_PASSWORD],
@@ -36,9 +33,15 @@ async def async_setup_platform(hass,
     _LOGGER.info("Adding cameras")
     for camera in api.get_cameras():
         _LOGGER.info("Adding nest cam uuid: %s", camera["uuid"])
-        device = NestCamera(camera["uuid"], api)
+        device = NestCamera(camera["uuid"], NestCameraAPI(
+            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],
+            camera["uuid"]
+        ))
         cameras.append(device)
-        hass.data[DATA_KEY][camera["uuid"]] = device
 
     async_add_entities(cameras)
 
@@ -50,7 +53,6 @@ class NestCamera(Camera):
         """Initialize a Nest camera."""
         super().__init__()
         self._uuid = uuid
-        api.set_device(self._uuid)
         self._device = api
         self._time_between_snapshots = timedelta(seconds=30)
         self._last_image = None

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_AWAY, PRESET_ECO, PRESET_AWAY_AND_ECO]
+PRESET_MODES = [PRESET_NONE, PRESET_ECO]
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -100,8 +98,7 @@ class NestClimate(ClimateDevice):
         self.device_id = device_id
 
         # Set the default supported features
-        self._support_flags = SUPPORT_TARGET_TEMPERATURE
-        # | SUPPORT_PRESET_MODE
+        self._support_flags = SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE
 
         # Not all nest devices support cooling and heating remove unused
         self._operation_list = []
@@ -209,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):
@@ -268,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, PRESET_AWAY_AND_ECO)
-        is_away = self.device.away
+        need_eco = preset_mode in (PRESET_ECO)
         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()
-            else:
-                self.device.mode = MODE_HASS_TO_NEST[self._operation_list[0]]
+            self.device.set_eco_mode(need_eco)
 
     def update(self):
         """Updates data"""