Compare commits

..

No commits in common. "main" and "v1.1.0.beta.3" have entirely different histories.

23 changed files with 293 additions and 6985 deletions

2
.github/FUNDING.yml vendored
View File

@ -1,2 +0,0 @@
github: CodeFoodPixels
ko_fi: codefoodpixels

View File

@ -29,3 +29,13 @@ jobs:
uses: "hacs/action@main" uses: "hacs/action@main"
with: with:
category: "integration" category: "integration"
# Runs a single command using the runners shell
- name: Run a one-line script
run: echo Hello, world!
# Runs a set of commands using the runners shell
- name: Run a multi-line script
run: |
echo Add other actions to build,
echo test, and deploy your project.

View File

@ -1,19 +0,0 @@
on:
push:
branches:
- main
workflow_dispatch:
jobs:
create-release:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version-file: ".nvmrc"
- run: npm ci
- name: Release
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: npx semantic-release

1
.gitignore vendored
View File

@ -1 +0,0 @@
/node_modules

1
.nvmrc
View File

@ -1 +0,0 @@
20

View File

@ -1,20 +0,0 @@
{
"branches": [
"main",
{
"name": "*",
"channel": "beta",
"prerelease": true
}
],
"plugins": [
[
"@semantic-release/commit-analyzer",
{
"preset": "conventionalcommits"
}
],
"@semantic-release/release-notes-generator",
"@semantic-release/github"
]
}

View File

@ -1,10 +1,5 @@
[![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs) [![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs)
<a href='https://ko-fi.com/O5O3O08PA' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi3.png?v=3' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
[![Sponsor me on Github Sponsors](https://img.shields.io/badge/Sponsor-ea4aaa?style=for-the-badge&logo=github-sponsors&logoColor=%23EA4AAA&labelColor=white)](https://github.com/sponsors/CodeFoodPixels)
[![Tip me through ko-fi](https://img.shields.io/badge/KoFi-FF5E5B?style=for-the-badge&logo=kofi&logoColor=%23FF5E5B&labelColor=white)](https://ko-fi.com/O5O3O08PA)
[![Tip me through PayPal](https://img.shields.io/badge/Paypal.me-00457C?style=for-the-badge&logo=paypal&logoColor=%2300457C&labelColor=white)](https://paypal.me/CodeFoodPixels)
[![Tip me through Monzo](https://img.shields.io/badge/Monzo.me-14233C?style=for-the-badge&logo=monzo&logoColor=%2314233C&labelColor=white)](https://monzo.me/codefoodpixels)
# Eufy RobovVac control for Home Assistant # Eufy RobovVac control for Home Assistant
A brand new version Eufy RoboVac integration for Home Assistant that includes a Config Flow to add your RoboVac(s) and the local key and ID required. All you need to do is enter your Eufy app credentials and the Config Flow will look up the details for you. After the initial config use the configuration button on the Integration to enter the RoboVac IP address when prompted. A brand new version Eufy RoboVac integration for Home Assistant that includes a Config Flow to add your RoboVac(s) and the local key and ID required. All you need to do is enter your Eufy app credentials and the Config Flow will look up the details for you. After the initial config use the configuration button on the Integration to enter the RoboVac IP address when prompted.

View File

@ -24,12 +24,12 @@ from .const import CONF_VACS, DOMAIN
from .tuyalocaldiscovery import TuyaLocalDiscovery from .tuyalocaldiscovery import TuyaLocalDiscovery
PLATFORMS = [Platform.VACUUM, Platform.SENSOR] PLATFORM = Platform.VACUUM
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
async def async_setup(hass, entry) -> bool: async def async_setup(hass, entry) -> bool:
hass.data.setdefault(DOMAIN, {CONF_VACS:{}}) hass.data.setdefault(DOMAIN, {})
async def update_device(device): async def update_device(device):
entry = async_get_config_entry_for_device(hass, device["gwId"]) entry = async_get_config_entry_for_device(hass, device["gwId"])
@ -41,11 +41,7 @@ async def async_setup(hass, entry) -> bool:
return return
hass_data = entry.data.copy() hass_data = entry.data.copy()
if ( if device["gwId"] in hass_data[CONF_VACS] and device.get("ip") is not None:
device["gwId"] in hass_data[CONF_VACS]
and device.get("ip") is not None
and hass_data[CONF_VACS][device["gwId"]].get("autodiscovery", True)
):
if hass_data[CONF_VACS][device["gwId"]][CONF_IP_ADDRESS] != device["ip"]: if hass_data[CONF_VACS][device["gwId"]][CONF_IP_ADDRESS] != device["ip"]:
hass_data[CONF_VACS][device["gwId"]][CONF_IP_ADDRESS] = device["ip"] hass_data[CONF_VACS][device["gwId"]][CONF_IP_ADDRESS] = device["ip"]
hass.config_entries.async_update_entry(entry, data=hass_data) hass.config_entries.async_update_entry(entry, data=hass_data)
@ -70,15 +66,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Eufy Robovac from a config entry.""" """Set up Eufy Robovac from a config entry."""
entry.async_on_unload(entry.add_update_listener(update_listener)) entry.async_on_unload(entry.add_update_listener(update_listener))
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) await hass.config_entries.async_forward_entry_setup(entry, PLATFORM)
return True return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry.""" """Unload a config entry."""
if unload_ok := await hass.config_entries.async_unload_platforms( if unload_ok := await hass.config_entries.async_forward_entry_unload(
entry, PLATFORMS entry, PLATFORM
): ):
"""Nothing""" """Nothing"""
return unload_ok return unload_ok
@ -86,7 +82,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
async def update_listener(hass, entry): async def update_listener(hass, entry):
"""Handle options update.""" """Handle options update."""
await hass.config_entries.async_reload(entry.entry_id) hass.config_entries.async_reload(entry.entry_id)
def async_get_config_entry_for_device(hass, device_id): def async_get_config_entry_for_device(hass, device_id):

View File

@ -14,7 +14,6 @@
"""Config flow for Eufy Robovac integration.""" """Config flow for Eufy Robovac integration."""
from __future__ import annotations from __future__ import annotations
import json
import logging import logging
from typing import Any, Optional from typing import Any, Optional
@ -40,20 +39,13 @@ from homeassistant.const import (
CONF_IP_ADDRESS, CONF_IP_ADDRESS,
CONF_DESCRIPTION, CONF_DESCRIPTION,
CONF_MAC, CONF_MAC,
CONF_LOCATION,
CONF_CLIENT_ID, CONF_CLIENT_ID,
CONF_REGION, CONF_REGION,
CONF_TIME_ZONE, CONF_TIME_ZONE,
CONF_COUNTRY_CODE,
) )
from .countries import ( from .const import DOMAIN, CONF_VACS
get_phone_code_by_country_code,
get_phone_code_by_region,
get_region_by_country_code,
get_region_by_phone_code,
)
from .const import CONF_AUTODISCOVERY, DOMAIN, CONF_VACS
from .tuyawebapi import TuyaAPISession from .tuyawebapi import TuyaAPISession
from .eufywebapi import EufyLogon from .eufywebapi import EufyLogon
@ -96,50 +88,16 @@ def get_eufy_vacuums(self):
settings_response = response.json() settings_response = response.json()
self[CONF_CLIENT_ID] = user_response["user_info"]["id"] self[CONF_CLIENT_ID] = user_response["user_info"]["id"]
if (
"tuya_home" in settings_response["setting"]["home_setting"]
and "tuya_region_code"
in settings_response["setting"]["home_setting"]["tuya_home"]
):
self[CONF_REGION] = settings_response["setting"]["home_setting"]["tuya_home"][ self[CONF_REGION] = settings_response["setting"]["home_setting"]["tuya_home"][
"tuya_region_code" "tuya_region_code"
] ]
if user_response["user_info"]["phone_code"]:
self[CONF_COUNTRY_CODE] = user_response["user_info"]["phone_code"]
else:
self[CONF_COUNTRY_CODE] = get_phone_code_by_region(self[CONF_REGION])
elif user_response["user_info"]["phone_code"]:
self[CONF_REGION] = get_region_by_phone_code(
user_response["user_info"]["phone_code"]
)
self[CONF_COUNTRY_CODE] = user_response["user_info"]["phone_code"]
elif user_response["user_info"]["country"]:
self[CONF_REGION] = get_region_by_country_code(
user_response["user_info"]["country"]
)
self[CONF_COUNTRY_CODE] = get_phone_code_by_country_code(
user_response["user_info"]["country"]
)
else:
self[CONF_REGION] = "EU"
self[CONF_COUNTRY_CODE] = "44"
self[CONF_TIME_ZONE] = user_response["user_info"]["timezone"] self[CONF_TIME_ZONE] = user_response["user_info"]["timezone"]
tuya_client = TuyaAPISession( # self[CONF_VACS] = {}
username="eh-" + self[CONF_CLIENT_ID],
region=self[CONF_REGION],
timezone=self[CONF_TIME_ZONE],
phone_code=self[CONF_COUNTRY_CODE],
)
items = device_response["items"] items = device_response["items"]
self[CONF_VACS] = {} allvacs = {}
for item in items: for item in items:
if item["device"]["product"]["appliance"] == "Cleaning": if item["device"]["product"]["appliance"] == "Cleaning":
try:
device = tuya_client.get_device(item["device"]["id"])
vac_details = { vac_details = {
CONF_ID: item["device"]["id"], CONF_ID: item["device"]["id"],
CONF_MODEL: item["device"]["product"]["product_code"], CONF_MODEL: item["device"]["product"]["product_code"],
@ -147,17 +105,19 @@ def get_eufy_vacuums(self):
CONF_DESCRIPTION: item["device"]["name"], CONF_DESCRIPTION: item["device"]["name"],
CONF_MAC: item["device"]["wifi"]["mac"], CONF_MAC: item["device"]["wifi"]["mac"],
CONF_IP_ADDRESS: "", CONF_IP_ADDRESS: "",
CONF_AUTODISCOVERY: True,
CONF_ACCESS_TOKEN: device["localKey"],
} }
self[CONF_VACS][item["device"]["id"]] = vac_details allvacs[item["device"]["id"]] = vac_details
except: self[CONF_VACS] = allvacs
_LOGGER.debug(
"Skipping vacuum {}: found on Eufy but not on Tuya. Eufy details:".format( tuya_client = TuyaAPISession(
item["device"]["id"] username="eh-" + self[CONF_CLIENT_ID],
region=self[CONF_REGION],
timezone=self[CONF_TIME_ZONE],
) )
) for home in tuya_client.list_homes():
_LOGGER.debug(json.dumps(item["device"], indent=2)) for device in tuya_client.list_devices(home["groupId"]):
self[CONF_VACS][device["devId"]][CONF_ACCESS_TOKEN] = device["localKey"]
self[CONF_VACS][device["devId"]][CONF_LOCATION] = home["groupId"]
return response return response
@ -187,8 +147,8 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors["base"] = "cannot_connect" errors["base"] = "cannot_connect"
except InvalidAuth: except InvalidAuth:
errors["base"] = "invalid_auth" errors["base"] = "invalid_auth"
except Exception as e: # pylint: disable=broad-except except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected exception: {}".format(e)) _LOGGER.exception("Unexpected exception")
errors["base"] = "unknown" errors["base"] = "unknown"
else: else:
await self.async_set_unique_id(unique_id) await self.async_set_unique_id(unique_id)
@ -199,12 +159,6 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=USER_SCHEMA, errors=errors step_id="user", data_schema=USER_SCHEMA, errors=errors
) )
@staticmethod
@callback
def async_get_options_flow(config_entry):
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
class CannotConnect(HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""
@ -212,71 +166,3 @@ class CannotConnect(HomeAssistantError):
class InvalidAuth(HomeAssistantError): class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth.""" """Error to indicate there is invalid auth."""
class OptionsFlowHandler(config_entries.OptionsFlow):
"""Handles options flow for the component."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
self.config_entry = config_entry
self.selected_vacuum = None
async def async_step_init(self, user_input=None):
errors = {}
if user_input is not None:
self.selected_vacuum = user_input["selected_vacuum"]
return await self.async_step_edit()
vacuums_config = self.config_entry.data[CONF_VACS]
vacuum_list = {}
for vacuum_id in vacuums_config:
vacuum_list[vacuum_id] = vacuums_config[vacuum_id]["name"]
devices_schema = vol.Schema(
{vol.Required("selected_vacuum"): vol.In(vacuum_list)}
)
return self.async_show_form(
step_id="init", data_schema=devices_schema, errors=errors
)
async def async_step_edit(self, user_input=None):
"""Manage the options for the custom component."""
errors = {}
vacuums = self.config_entry.data[CONF_VACS]
if user_input is not None:
updated_vacuums = deepcopy(vacuums)
updated_vacuums[self.selected_vacuum][CONF_AUTODISCOVERY] = user_input[
CONF_AUTODISCOVERY
]
if user_input[CONF_IP_ADDRESS]:
updated_vacuums[self.selected_vacuum][CONF_IP_ADDRESS] = user_input[
CONF_IP_ADDRESS
]
self.hass.config_entries.async_update_entry(
self.config_entry,
data={CONF_VACS: updated_vacuums},
)
return self.async_create_entry(title="", data={})
options_schema = vol.Schema(
{
vol.Required(
CONF_AUTODISCOVERY,
default=vacuums[self.selected_vacuum].get(CONF_AUTODISCOVERY, True),
): bool,
vol.Optional(
CONF_IP_ADDRESS,
default=vacuums[self.selected_vacuum].get(CONF_IP_ADDRESS),
): str,
}
)
return self.async_show_form(
step_id="edit", data_schema=options_schema, errors=errors
)

View File

@ -2,7 +2,3 @@
DOMAIN = "robovac" DOMAIN = "robovac"
CONF_VACS = "vacuums" CONF_VACS = "vacuums"
CONF_AUTODISCOVERY = "autodiscovery"
REFRESH_RATE = 60
PING_RATE = 10
TIMEOUT = 5

View File

@ -1,228 +0,0 @@
COUNTRIES = [
{"country_code": "AF", "phone_code": "93", "tuya_region": "EU"},
{"country_code": "AL", "phone_code": "355", "tuya_region": "EU"},
{"country_code": "DZ", "phone_code": "213", "tuya_region": "EU"},
{"country_code": "AO", "phone_code": "244", "tuya_region": "EU"},
{"country_code": "AR", "phone_code": "54", "tuya_region": "AZ"},
{"country_code": "AM", "phone_code": "374", "tuya_region": "EU"},
{"country_code": "AU", "phone_code": "61", "tuya_region": "AZ"},
{"country_code": "AT", "phone_code": "43", "tuya_region": "EU"},
{"country_code": "AZ", "phone_code": "994", "tuya_region": "EU"},
{"country_code": "BH", "phone_code": "973", "tuya_region": "EU"},
{"country_code": "BD", "phone_code": "880", "tuya_region": "EU"},
{"country_code": "BY", "phone_code": "375", "tuya_region": "EU"},
{"country_code": "BE", "phone_code": "32", "tuya_region": "EU"},
{"country_code": "BZ", "phone_code": "501", "tuya_region": "EU"},
{"country_code": "BJ", "phone_code": "229", "tuya_region": "EU"},
{"country_code": "BT", "phone_code": "975", "tuya_region": "EU"},
{"country_code": "BO", "phone_code": "591", "tuya_region": "AZ"},
{"country_code": "BA", "phone_code": "387", "tuya_region": "EU"},
{"country_code": "BW", "phone_code": "267", "tuya_region": "EU"},
{"country_code": "BR", "phone_code": "55", "tuya_region": "AZ"},
{"country_code": "VG", "phone_code": "1284", "tuya_region": "EU"},
{"country_code": "BN", "phone_code": "673", "tuya_region": "EU"},
{"country_code": "BG", "phone_code": "359", "tuya_region": "EU"},
{"country_code": "BF", "phone_code": "226", "tuya_region": "EU"},
{"country_code": "BI", "phone_code": "257", "tuya_region": "EU"},
{"country_code": "KH", "phone_code": "855", "tuya_region": "EU"},
{"country_code": "CM", "phone_code": "237", "tuya_region": "EU"},
{"country_code": "US", "phone_code": "1", "tuya_region": "AZ"},
{"country_code": "CA", "phone_code": "1", "tuya_region": "AZ"},
{"country_code": "CV", "phone_code": "238", "tuya_region": "EU"},
{"country_code": "KY", "phone_code": "1345", "tuya_region": "EU"},
{"country_code": "CF", "phone_code": "236", "tuya_region": "EU"},
{"country_code": "TD", "phone_code": "235", "tuya_region": "EU"},
{"country_code": "CL", "phone_code": "56", "tuya_region": "AZ"},
{"country_code": "CN", "phone_code": "86", "tuya_region": "AY"},
{"country_code": "CO", "phone_code": "57", "tuya_region": "AZ"},
{"country_code": "KM", "phone_code": "269", "tuya_region": "EU"},
{"country_code": "CG", "phone_code": "242", "tuya_region": "EU"},
{"country_code": "CD", "phone_code": "243", "tuya_region": "EU"},
{"country_code": "CR", "phone_code": "506", "tuya_region": "EU"},
{"country_code": "HR", "phone_code": "385", "tuya_region": "EU"},
{"country_code": "CY", "phone_code": "357", "tuya_region": "EU"},
{"country_code": "CZ", "phone_code": "420", "tuya_region": "EU"},
{"country_code": "DK", "phone_code": "45", "tuya_region": "EU"},
{"country_code": "DJ", "phone_code": "253", "tuya_region": "EU"},
{"country_code": "DO", "phone_code": "1809", "tuya_region": "EU"},
{"country_code": "DO", "phone_code": "1829", "tuya_region": "EU"},
{"country_code": "DO", "phone_code": "1849", "tuya_region": "EU"},
{"country_code": "EC", "phone_code": "593", "tuya_region": "AZ"},
{"country_code": "EG", "phone_code": "20", "tuya_region": "EU"},
{"country_code": "SV", "phone_code": "503", "tuya_region": "EU"},
{"country_code": "GQ", "phone_code": "240", "tuya_region": "EU"},
{"country_code": "ER", "phone_code": "291", "tuya_region": "EU"},
{"country_code": "EE", "phone_code": "372", "tuya_region": "EU"},
{"country_code": "ET", "phone_code": "251", "tuya_region": "EU"},
{"country_code": "FJ", "phone_code": "679", "tuya_region": "EU"},
{"country_code": "FI", "phone_code": "358", "tuya_region": "EU"},
{"country_code": "FR", "phone_code": "33", "tuya_region": "EU"},
{"country_code": "GA", "phone_code": "241", "tuya_region": "EU"},
{"country_code": "GM", "phone_code": "220", "tuya_region": "EU"},
{"country_code": "GE", "phone_code": "995", "tuya_region": "EU"},
{"country_code": "DE", "phone_code": "49", "tuya_region": "EU"},
{"country_code": "GH", "phone_code": "233", "tuya_region": "EU"},
{"country_code": "GR", "phone_code": "30", "tuya_region": "EU"},
{"country_code": "GL", "phone_code": "299", "tuya_region": "EU"},
{"country_code": "GT", "phone_code": "502", "tuya_region": "AZ"},
{"country_code": "GN", "phone_code": "224", "tuya_region": "EU"},
{"country_code": "GY", "phone_code": "592", "tuya_region": "EU"},
{"country_code": "HT", "phone_code": "509", "tuya_region": "EU"},
{"country_code": "HN", "phone_code": "504", "tuya_region": "EU"},
{"country_code": "HK", "phone_code": "852", "tuya_region": "AZ"},
{"country_code": "HU", "phone_code": "36", "tuya_region": "EU"},
{"country_code": "IS", "phone_code": "354", "tuya_region": "EU"},
{"country_code": "IN", "phone_code": "91", "tuya_region": "IN"},
{"country_code": "ID", "phone_code": "62", "tuya_region": "AZ"},
{"country_code": "IR", "phone_code": "98", "tuya_region": "EU"},
{"country_code": "IQ", "phone_code": "964", "tuya_region": "EU"},
{"country_code": "IE", "phone_code": "353", "tuya_region": "EU"},
{"country_code": "IM", "phone_code": "44", "tuya_region": "EU"},
{"country_code": "IL", "phone_code": "972", "tuya_region": "EU"},
{"country_code": "IT", "phone_code": "39", "tuya_region": "AZ"},
{"country_code": "CI", "phone_code": "225", "tuya_region": "EU"},
{"country_code": "JM", "phone_code": "1876", "tuya_region": "EU"},
{"country_code": "JP", "phone_code": "81", "tuya_region": "AZ"},
{"country_code": "JO", "phone_code": "962", "tuya_region": "EU"},
{"country_code": "KZ", "phone_code": "7", "tuya_region": "EU"},
{"country_code": "KE", "phone_code": "254", "tuya_region": "EU"},
{"country_code": "KR", "phone_code": "82", "tuya_region": "AZ"},
{"country_code": "KW", "phone_code": "965", "tuya_region": "EU"},
{"country_code": "KG", "phone_code": "996", "tuya_region": "EU"},
{"country_code": "LA", "phone_code": "856", "tuya_region": "EU"},
{"country_code": "LV", "phone_code": "371", "tuya_region": "EU"},
{"country_code": "LB", "phone_code": "961", "tuya_region": "EU"},
{"country_code": "LS", "phone_code": "266", "tuya_region": "EU"},
{"country_code": "LR", "phone_code": "231", "tuya_region": "EU"},
{"country_code": "LY", "phone_code": "218", "tuya_region": "EU"},
{"country_code": "LT", "phone_code": "370", "tuya_region": "EU"},
{"country_code": "LU", "phone_code": "352", "tuya_region": "EU"},
{"country_code": "MO", "phone_code": "853", "tuya_region": "AZ"},
{"country_code": "MK", "phone_code": "389", "tuya_region": "EU"},
{"country_code": "MG", "phone_code": "261", "tuya_region": "EU"},
{"country_code": "MW", "phone_code": "265", "tuya_region": "EU"},
{"country_code": "MY", "phone_code": "60", "tuya_region": "AZ"},
{"country_code": "MV", "phone_code": "960", "tuya_region": "EU"},
{"country_code": "ML", "phone_code": "223", "tuya_region": "EU"},
{"country_code": "MT", "phone_code": "356", "tuya_region": "EU"},
{"country_code": "MR", "phone_code": "222", "tuya_region": "EU"},
{"country_code": "MU", "phone_code": "230", "tuya_region": "EU"},
{"country_code": "MX", "phone_code": "52", "tuya_region": "AZ"},
{"country_code": "MD", "phone_code": "373", "tuya_region": "EU"},
{"country_code": "MC", "phone_code": "377", "tuya_region": "EU"},
{"country_code": "MN", "phone_code": "976", "tuya_region": "EU"},
{"country_code": "ME", "phone_code": "382", "tuya_region": "EU"},
{"country_code": "MA", "phone_code": "212", "tuya_region": "EU"},
{"country_code": "MZ", "phone_code": "258", "tuya_region": "EU"},
{"country_code": "MM", "phone_code": "95", "tuya_region": "AZ"},
{"country_code": "NA", "phone_code": "264", "tuya_region": "EU"},
{"country_code": "NP", "phone_code": "977", "tuya_region": "EU"},
{"country_code": "NL", "phone_code": "31", "tuya_region": "EU"},
{"country_code": "NZ", "phone_code": "64", "tuya_region": "AZ"},
{"country_code": "NI", "phone_code": "505", "tuya_region": "AZ"},
{"country_code": "NE", "phone_code": "227", "tuya_region": "EU"},
{"country_code": "NG", "phone_code": "234", "tuya_region": "EU"},
{"country_code": "KP", "phone_code": "850", "tuya_region": "EU"},
{"country_code": "NO", "phone_code": "47", "tuya_region": "EU"},
{"country_code": "OM", "phone_code": "968", "tuya_region": "EU"},
{"country_code": "PK", "phone_code": "92", "tuya_region": "EU"},
{"country_code": "PA", "phone_code": "507", "tuya_region": "EU"},
{"country_code": "PY", "phone_code": "595", "tuya_region": "AZ"},
{"country_code": "PE", "phone_code": "51", "tuya_region": "AZ"},
{"country_code": "PH", "phone_code": "63", "tuya_region": "AZ"},
{"country_code": "PL", "phone_code": "48", "tuya_region": "EU"},
{"country_code": "PF", "phone_code": "689", "tuya_region": "EU"},
{"country_code": "PT", "phone_code": "351", "tuya_region": "EU"},
{"country_code": "PR", "phone_code": "1787", "tuya_region": "AZ"},
{"country_code": "QA", "phone_code": "974", "tuya_region": "EU"},
{"country_code": "RE", "phone_code": "262", "tuya_region": "EU"},
{"country_code": "RO", "phone_code": "40", "tuya_region": "EU"},
{"country_code": "RU", "phone_code": "7", "tuya_region": "EU"},
{"country_code": "RW", "phone_code": "250", "tuya_region": "EU"},
{"country_code": "SM", "phone_code": "378", "tuya_region": "EU"},
{"country_code": "SA", "phone_code": "966", "tuya_region": "EU"},
{"country_code": "SN", "phone_code": "221", "tuya_region": "EU"},
{"country_code": "RS", "phone_code": "381", "tuya_region": "EU"},
{"country_code": "SL", "phone_code": "232", "tuya_region": "EU"},
{"country_code": "SG", "phone_code": "65", "tuya_region": "EU"},
{"country_code": "SK", "phone_code": "421", "tuya_region": "EU"},
{"country_code": "SI", "phone_code": "386", "tuya_region": "EU"},
{"country_code": "SO", "phone_code": "252", "tuya_region": "EU"},
{"country_code": "ZA", "phone_code": "27", "tuya_region": "EU"},
{"country_code": "ES", "phone_code": "34", "tuya_region": "EU"},
{"country_code": "LK", "phone_code": "94", "tuya_region": "EU"},
{"country_code": "SD", "phone_code": "249", "tuya_region": "EU"},
{"country_code": "SR", "phone_code": "597", "tuya_region": "AZ"},
{"country_code": "SZ", "phone_code": "268", "tuya_region": "EU"},
{"country_code": "SE", "phone_code": "46", "tuya_region": "EU"},
{"country_code": "CH", "phone_code": "41", "tuya_region": "EU"},
{"country_code": "SY", "phone_code": "963", "tuya_region": "EU"},
{"country_code": "TW", "phone_code": "886", "tuya_region": "AZ"},
{"country_code": "TJ", "phone_code": "992", "tuya_region": "EU"},
{"country_code": "TZ", "phone_code": "255", "tuya_region": "EU"},
{"country_code": "TH", "phone_code": "66", "tuya_region": "AZ"},
{"country_code": "TG", "phone_code": "228", "tuya_region": "EU"},
{"country_code": "TO", "phone_code": "676", "tuya_region": "EU"},
{"country_code": "TT", "phone_code": "1868", "tuya_region": "EU"},
{"country_code": "TN", "phone_code": "216", "tuya_region": "EU"},
{"country_code": "TR", "phone_code": "90", "tuya_region": "EU"},
{"country_code": "TM", "phone_code": "993", "tuya_region": "EU"},
{"country_code": "VI", "phone_code": "1340", "tuya_region": "EU"},
{"country_code": "UG", "phone_code": "256", "tuya_region": "EU"},
{"country_code": "UA", "phone_code": "380", "tuya_region": "EU"},
{"country_code": "AE", "phone_code": "971", "tuya_region": "EU"},
{"country_code": "GB", "phone_code": "44", "tuya_region": "EU"},
{"country_code": "UY", "phone_code": "598", "tuya_region": "AZ"},
{"country_code": "UZ", "phone_code": "998", "tuya_region": "EU"},
{"country_code": "VA", "phone_code": "379", "tuya_region": "EU"},
{"country_code": "VE", "phone_code": "58", "tuya_region": "AZ"},
{"country_code": "VN", "phone_code": "84", "tuya_region": "AZ"},
{"country_code": "YE", "phone_code": "967", "tuya_region": "EU"},
{"country_code": "ZR", "phone_code": "243", "tuya_region": "EU"},
{"country_code": "ZM", "phone_code": "260", "tuya_region": "EU"},
{"country_code": "ZW", "phone_code": "263", "tuya_region": "EU"},
{"country_code": "NCL", "phone_code": "687", "tuya_region": "EU"},
{"country_code": "MQ", "phone_code": "596", "tuya_region": "EU"},
]
def get_region_by_country_code(country_code):
country = next(
(item for item in COUNTRIES if item["country_code"] == country_code), None
)
if country is None:
return "EU"
return country["tuya_region"]
def get_region_by_phone_code(phone_code):
country = next(
(item for item in COUNTRIES if item["phone_code"] == phone_code), None
)
if country is None:
return "EU"
return country["tuya_region"]
def get_phone_code_by_region(region):
country = next((item for item in COUNTRIES if item["tuya_region"] == region), None)
if country is None:
return "44"
return country["phone_code"]
def get_phone_code_by_country_code(country_code):
country = next(
(item for item in COUNTRIES if item["country_code"] == country_code), None
)
if country is None:
return "44"
return country["phone_code"]

View File

@ -37,7 +37,6 @@ ROBOVAC_SERIES = {
"T2251", "T2251",
"T2252", "T2252",
"T2253", "T2253",
"T2254",
"T2150", "T2150",
"T2255", "T2255",
"T2256", "T2256",

View File

@ -1,63 +0,0 @@
import logging
from datetime import timedelta
from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import PERCENTAGE, EntityCategory, CONF_NAME, CONF_ID
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.device_registry import DeviceInfo
from .const import CONF_VACS, DOMAIN, REFRESH_RATE
_LOGGER = logging.getLogger(__name__)
BATTERY = "Battery"
SCAN_INTERVAL = timedelta(seconds=REFRESH_RATE)
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize my test integration 2 config entry."""
vacuums = config_entry.data[CONF_VACS]
for item in vacuums:
item = vacuums[item]
entity = RobovacSensorEntity(item)
async_add_entities([entity])
class RobovacSensorEntity(SensorEntity):
_attr_has_entity_name = True
_attr_device_class = SensorDeviceClass.BATTERY
_attr_entity_category = EntityCategory.DIAGNOSTIC
_attr_native_unit_of_measurement = PERCENTAGE
_attr_available = False
def __init__(self, item):
self.robovac = item
self.robovac_id = item[CONF_ID]
self._attr_unique_id = item[CONF_ID]
self._battery_level = None
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, item[CONF_ID])},
name=item[CONF_NAME]
)
def update(self):
try:
self._battery_level = self.hass.data[DOMAIN][CONF_VACS][self.robovac_id].battery_level
self._attr_available = True
except:
_LOGGER.debug("Failed to get battery level for {}".format(self.robovac_id))
self._battery_level = None
self._attr_available = False
@property
def native_value(self) -> str | None:
"""Return the state."""
if self._battery_level is not None:
return self._battery_level
return None

View File

@ -1,40 +1,21 @@
{ {
"config": { "config": {
"abort": {
"already_configured": "Device is already configured"
},
"error": {
"cannot_connect": "Failed to connect",
"invalid_auth": "Invalid authentication",
"unknown": "Unexpected error"
},
"step": { "step": {
"user": { "user": {
"data": { "data": {
"host": "Host", "username": "[%key:common::config_flow::data::username%]",
"password": "Password", "password": "[%key:common::config_flow::data::password%]"
"username": "Username"
},
"description": "Enter your Eufy account details"
} }
} }
}, },
"options": { "error": {
"step": { "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
"init": { "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
"title": "Manage vacuums", "unknown": "[%key:common::config_flow::error::unknown%]"
"data": {
"selected_vacuum": "Select the Vacuum to edit"
}
}, },
"edit": { "abort": {
"title": "Edit vacuum", "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
"data": {
"autodiscovery": "Enable autodiscovery",
"ip_address": "IP Address"
},
"description": "Autodiscovery will automatically update the IP address"
}
} }
} }
} }

View File

@ -20,20 +20,17 @@
} }
}, },
"options": { "options": {
"error": {
"invalid_path": "The path provided is not valid. Should be in the format `user/repo-name` and should be a valid github repository."
},
"step": { "step": {
"init": { "init": {
"title": "Manage vacuums", "title": "Manage IPs",
"data": { "data": {
"selected_vacuum": "Select the Vacuum to edit" "vacuum": "Select the Vacuum to edit",
} "ip_address": "IP address of vacuum"
}, },
"edit": { "description": "Add or update a vacuums IP address"
"title": "Edit vacuum",
"data": {
"autodiscovery": "Enable autodiscovery",
"ip_address": "IP Address"
},
"description": "Autodiscovery will automatically update the IP address"
} }
} }
} }

View File

@ -46,17 +46,13 @@ import socket
import struct import struct
import sys import sys
import time import time
import traceback
from typing import Callable, Coroutine
from cryptography.hazmat.backends.openssl import backend as openssl_backend from cryptography.hazmat.backends.openssl import backend as openssl_backend
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.hashes import Hash, MD5 from cryptography.hazmat.primitives.hashes import Hash, MD5
from cryptography.hazmat.primitives.padding import PKCS7 from cryptography.hazmat.primitives.padding import PKCS7
INITIAL_BACKOFF = 5
INITIAL_QUEUE_TIME = 0.1
BACKOFF_MULTIPLIER = 1.70224
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
MESSAGE_PREFIX_FORMAT = ">IIII" MESSAGE_PREFIX_FORMAT = ">IIII"
MESSAGE_SUFFIX_FORMAT = ">II" MESSAGE_SUFFIX_FORMAT = ">II"
@ -351,14 +347,6 @@ class RequestResponseCommandMismatch(TuyaException):
"""The command in the response didn't match the one from the request.""" """The command in the response didn't match the one from the request."""
class ResponseTimeoutException(TuyaException):
"""Did not recieve a response to the request within the timeout"""
class BackoffException(TuyaException):
"""Backoff time not reached"""
class TuyaCipher: class TuyaCipher:
"""Tuya cryptographic helpers.""" """Tuya cryptographic helpers."""
@ -452,34 +440,21 @@ class Message:
SET_COMMAND = 0x07 SET_COMMAND = 0x07
GRATUITOUS_UPDATE = 0x08 GRATUITOUS_UPDATE = 0x08
def __init__( def __init__(self, command, payload=None, sequence=None, encrypt_for=None):
self,
command,
payload=None,
sequence=None,
encrypt=False,
device=None,
expect_response=True,
ttl=5,
):
if payload is None: if payload is None:
payload = b"" payload = b""
self.payload = payload self.payload = payload
self.command = command self.command = command
self.original_sequence = sequence
if sequence is None: if sequence is None:
self.set_sequence() # Use millisecond process time as the sequence number. Not ideal,
else: # but good for one month's continuous connection time though.
sequence = int(time.perf_counter() * 1000) & 0xFFFFFFFF
self.sequence = sequence self.sequence = sequence
self.encrypt = encrypt self.encrypt = False
self.device = device self.device = None
self.expiry = int(time.time()) + ttl if encrypt_for is not None:
self.expect_response = expect_response self.device = encrypt_for
self.listener = None self.encrypt = True
if expect_response is True:
self.listener = asyncio.Semaphore(0)
if device is not None:
device._listeners[self.sequence] = self.listener
def __repr__(self): def __repr__(self):
return "{}({}, {!r}, {!r}, {})".format( return "{}({}, {!r}, {!r}, {})".format(
@ -490,9 +465,6 @@ class Message:
"<Device {}>".format(self.device) if self.device else None, "<Device {}>".format(self.device) if self.device else None,
) )
def set_sequence(self):
self.sequence = int(time.perf_counter() * 1000) & 0xFFFFFFFF
def hex(self): def hex(self):
return self.bytes().hex() return self.bytes().hex()
@ -524,11 +496,39 @@ class Message:
__bytes__ = bytes __bytes__ = bytes
async def async_send(self): class AsyncWrappedCallback:
await self.device._async_send(self) def __init__(self, request, callback):
self.request = request
self.callback = callback
self.devices = []
def register(self, device):
self.devices.append(device)
device._handlers.setdefault(self.request.command, [])
device._handlers[self.request.command].append(self)
def unregister(self, device):
self.devices.remove(device)
device._handlers[self.request.command].remove(self)
def unregister_all(self):
while self.devices:
device = self.devices.pop()
device._handlers[self.request.command].remove(self)
async def __call__(self, response, device):
if response.sequence == self.request.sequence:
asyncio.ensure_future(self.callback(response, device))
self.unregister(device)
async def async_send(self, device, callback=None):
if callback is not None:
wrapped = self.AsyncWrappedCallback(self, callback)
wrapped.register(device)
await device._async_send(self)
@classmethod @classmethod
def from_bytes(cls, device, data, cipher=None): def from_bytes(cls, data, cipher=None):
try: try:
prefix, sequence, command, payload_size = struct.unpack_from( prefix, sequence, command, payload_size = struct.unpack_from(
MESSAGE_PREFIX_FORMAT, data MESSAGE_PREFIX_FORMAT, data
@ -585,37 +585,53 @@ class Message:
try: try:
payload_text = payload_data.decode("utf8") payload_text = payload_data.decode("utf8")
except UnicodeDecodeError as e: except UnicodeDecodeError as e:
device._LOGGER.debug(payload_data.hex()) _LOGGER.debug(payload_data.hex())
device._LOGGER.error(e) _LOGGER.error(e)
raise MessageDecodeFailed() from e raise MessageDecodeFailed() from e
try: try:
payload = json.loads(payload_text) payload = json.loads(payload_text)
except json.decoder.JSONDecodeError as e: except json.decoder.JSONDecodeError as e:
# data may be encrypted # data may be encrypted
device._LOGGER.debug(payload_data.hex()) _LOGGER.debug(payload_data.hex())
device._LOGGER.error(e) _LOGGER.error(e)
raise MessageDecodeFailed() from e raise MessageDecodeFailed() from e
return cls(command, payload, sequence) return cls(command, payload, sequence)
def _call_async(fn, *args):
loop = None
if sys.version_info >= (3, 7):
try:
loop = asyncio.get_running_loop()
except RuntimeError:
pass
loop = asyncio.get_event_loop()
def wrapper(fn, *args):
asyncio.ensure_future(fn(*args))
loop.call_soon(wrapper, fn, *args)
class TuyaDevice: class TuyaDevice:
"""Represents a generic Tuya device.""" """Represents a generic Tuya device."""
# PING_INTERVAL = 10
def __init__( def __init__(
self, self,
device_id, device_id,
host, host,
timeout, timeout,
ping_interval, ping_interval,
update_entity_state,
local_key=None, local_key=None,
port=6668, port=6668,
gateway_id=None, gateway_id=None,
version=(3, 3), version=(3, 3),
): ):
"""Initialize the device.""" """Initialize the device."""
self._LOGGER = _LOGGER.getChild(device_id)
self.device_id = device_id self.device_id = device_id
self.host = host self.host = host
self.port = port self.port = port
@ -626,30 +642,19 @@ class TuyaDevice:
self.timeout = timeout self.timeout = timeout
self.last_pong = 0 self.last_pong = 0
self.ping_interval = ping_interval self.ping_interval = ping_interval
self.update_entity_state_cb = update_entity_state
if len(local_key) != 16: if len(local_key) != 16:
raise InvalidKey("Local key should be a 16-character string") raise InvalidKey("Local key should be a 16-character string")
self.cipher = TuyaCipher(local_key, self.version) self.cipher = TuyaCipher(local_key, self.version)
self.writer = None self.writer = None
self._response_task = None self._handlers = {
self._recieve_task = None Message.GET_COMMAND: [self.async_update_state],
self._ping_task = None Message.GRATUITOUS_UPDATE: [self.async_update_state],
self._handlers: dict[int, Callable[[Message], Coroutine]] = { Message.PING_COMMAND: [self._async_pong_received],
Message.GRATUITOUS_UPDATE: self.async_gratuitous_update_state,
Message.PING_COMMAND: self._async_pong_received,
} }
self._dps = {} self._dps = {}
self._connected = False self._connected = False
self._enabled = True
self._queue = []
self._listeners = {}
self._backoff = False
self._queue_interval = INITIAL_QUEUE_TIME
self._failures = 0
asyncio.create_task(self.process_queue())
def __repr__(self): def __repr__(self):
return "{}({!r}, {!r}, {!r}, {!r})".format( return "{}({!r}, {!r}, {!r}, {!r})".format(
@ -663,149 +668,62 @@ class TuyaDevice:
def __str__(self): def __str__(self):
return "{} ({}:{})".format(self.device_id, self.host, self.port) return "{} ({}:{})".format(self.device_id, self.host, self.port)
async def process_queue(self): async def async_connect(self, callback=None):
if self._enabled is False: if self._connected:
return return
self.clean_queue()
if len(self._queue) > 0:
self._LOGGER.debug(
"Processing queue. Current length: {}".format(len(self._queue))
)
try:
message = self._queue.pop(0)
await message.async_send()
self._failures = 0
self._queue_interval = INITIAL_QUEUE_TIME
self._backoff = False
except Exception as e:
self._failures += 1
self._LOGGER.debug(
"{} failures. Most recent: {}".format(self._failures, e)
)
if self._failures > 3:
self._backoff = True
self._queue_interval = min(
INITIAL_BACKOFF * (BACKOFF_MULTIPLIER ** (self._failures - 4)),
600,
)
self._LOGGER.warn(
"{} failures, backing off for {} seconds".format(
self._failures, self._queue_interval
)
)
await asyncio.sleep(self._queue_interval)
asyncio.create_task(self.process_queue())
def clean_queue(self):
cleaned_queue = []
now = int(time.time())
for item in self._queue:
if item.expiry > now:
cleaned_queue.append(item)
self._queue = cleaned_queue
async def async_connect(self):
if self._connected is True or self._enabled is False:
return
sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM) sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
sock.settimeout(self.timeout) sock.settimeout(self.timeout)
self._LOGGER.debug("Connecting to {}".format(self)) _LOGGER.debug("Connecting to {}".format(self))
try: try:
sock.connect((self.host, self.port)) sock.connect((self.host, self.port))
except (socket.timeout, TimeoutError) as e: except socket.timeout as e:
self._dps["106"] = "CONNECTION_FAILED" self._dps["106"] = "CONNECTION_FAILED"
raise ConnectionTimeoutException("Connection timed out") raise ConnectionTimeoutException("Connection timed out") from e
loop = asyncio.get_running_loop()
loop.create_connection
self.reader, self.writer = await asyncio.open_connection(sock=sock) self.reader, self.writer = await asyncio.open_connection(sock=sock)
self._connected = True self._connected = True
if self._ping_task is None:
self._ping_task = asyncio.create_task(self.async_ping(self.ping_interval))
asyncio.create_task(self._async_handle_message())
async def async_disable(self):
self._enabled = False
await self.async_disconnect()
async def async_disconnect(self): async def async_disconnect(self):
if self._connected is False: _LOGGER.debug("Disconnected from {}".format(self))
return
self._LOGGER.debug("Disconnected from {}".format(self))
self._connected = False self._connected = False
self.last_pong = 0 self.last_pong = 0
if self.writer is not None: if self.writer is not None:
self.writer.close() self.writer.close()
if self.reader is not None and not self.reader.at_eof(): async def async_get(self, callback=None):
self.reader.feed_eof()
async def async_get(self):
payload = {"gwId": self.gateway_id, "devId": self.device_id} payload = {"gwId": self.gateway_id, "devId": self.device_id}
encrypt = False if self.version < (3, 3) else True maybe_self = None if self.version < (3, 3) else self
message = Message(Message.GET_COMMAND, payload, encrypt=encrypt, device=self) message = Message(Message.GET_COMMAND, payload, encrypt_for=maybe_self)
self._queue.append(message) return await message.async_send(self, callback)
response = await self.async_recieve(message)
asyncio.create_task(self.async_update_state(response))
async def async_set(self, dps): async def async_set(self, dps, callback=None):
t = int(time.time()) t = int(time.time())
payload = {"devId": self.device_id, "uid": "", "t": t, "dps": dps} payload = {"devId": self.device_id, "uid": "", "t": t, "dps": dps}
message = Message( message = Message(Message.SET_COMMAND, payload, encrypt_for=self)
Message.SET_COMMAND, await message.async_send(self, callback)
payload,
encrypt=True,
device=self,
expect_response=False,
)
self._queue.append(message)
async def async_ping(self, ping_interval): def set(self, dps):
if self._enabled is False: _call_async(self.async_set, dps)
async def _async_ping(self, ping_interval):
if not self._connected:
return return
if self._backoff is True:
self._LOGGER.debug("Currently in backoff, not adding ping to queue")
else:
self.last_ping = time.time() self.last_ping = time.time()
encrypt = False if self.version < (3, 3) else True maybe_self = None if self.version < (3, 3) else self
message = Message( message = Message(Message.PING_COMMAND, sequence=0, encrypt_for=maybe_self)
Message.PING_COMMAND, await self._async_send(message)
sequence=0,
encrypt=encrypt,
device=self,
expect_response=False,
)
self._queue.append(message)
await asyncio.sleep(ping_interval) await asyncio.sleep(ping_interval)
self._ping_task = asyncio.create_task(self.async_ping(self.ping_interval))
if self.last_pong < self.last_ping: if self.last_pong < self.last_ping:
await self.async_disconnect() await self.async_disconnect()
else:
asyncio.ensure_future(self._async_ping(self.ping_interval))
async def _async_pong_received(self, message): async def _async_pong_received(self, message, device):
self.last_pong = time.time() self.last_pong = time.time()
async def async_gratuitous_update_state(self, state_message): async def async_update_state(self, state_message, _):
await self.async_update_state(state_message)
await self.update_entity_state_cb()
async def async_update_state(self, state_message, _=None):
if (
state_message is not None
and state_message.payload
and state_message.payload["dps"]
):
self._dps.update(state_message.payload["dps"]) self._dps.update(state_message.payload["dps"])
self._LOGGER.debug("Received updated state {}: {}".format(self, self._dps)) _LOGGER.info("Received updated state {}: {}".format(self, self._dps))
@property @property
def state(self): def state(self):
@ -813,113 +731,56 @@ class TuyaDevice:
@state.setter @state.setter
def state_setter(self, new_values): def state_setter(self, new_values):
asyncio.create_task(self.async_set(new_values)) asyncio.ensure_future(self.async_set(new_values))
async def _async_handle_message(self): async def _async_handle_message(self):
if self._enabled is False or self._connected is False: response_data = await self.reader.readuntil(MAGIC_SUFFIX_BYTES)
return
try: try:
self._response_task = asyncio.create_task( message = Message.from_bytes(response_data, self.cipher)
self.reader.readuntil(MAGIC_SUFFIX_BYTES) except InvalidMessage as e:
) _LOGGER.error("Invalid message from {}: {}".format(self, e))
await self._response_task except MessageDecodeFailed as e:
response_data = self._response_task.result() _LOGGER.error("Failed to decrypt message from {}".format(self))
message = Message.from_bytes(self, response_data, self.cipher)
except Exception as e:
if isinstance(e, InvalidMessage):
self._LOGGER.debug("Invalid message from {}: {}".format(self, e))
elif isinstance(e, MessageDecodeFailed):
self._LOGGER.debug("Failed to decrypt message from {}".format(self))
elif isinstance(e, asyncio.IncompleteReadError):
if self._connected:
self._LOGGER.debug("Incomplete read")
elif isinstance(e, ConnectionResetError):
self._LOGGER.debug(
"Connection reset: {}\n{}".format(e, traceback.format_exc())
)
await self.async_disconnect()
else: else:
self._LOGGER.debug("Received message from {}: {}".format(self, message)) _LOGGER.debug("Received message from {}: {}".format(self, message))
if message.sequence in self._listeners: for c in self._handlers.get(message.command, []):
sem = self._listeners[message.sequence] asyncio.ensure_future(c(message, self))
if isinstance(sem, asyncio.Semaphore):
self._listeners[message.sequence] = message
sem.release()
else:
handler = self._handlers.get(message.command, None)
if handler is not None:
asyncio.create_task(handler(message))
self._response_task = None async def _async_send(self, message, retries=4):
asyncio.create_task(self._async_handle_message())
async def _async_send(self, message, retries=2):
self._LOGGER.debug("Sending to {}: {}".format(self, message))
try: try:
await self.async_connect() await self.async_connect()
_LOGGER.debug("Sending to {}: {}".format(self, message))
self.writer.write(message.bytes()) self.writer.write(message.bytes())
await self.writer.drain() await self.writer.drain()
await self._async_handle_message()
except Exception as e: except Exception as e:
if retries == 0: if retries == 0:
if isinstance(e, socket.error): if isinstance(e, socket.error):
await self.async_disconnect() _LOGGER.error("Connection to {} failed: {}".format(self, e))
self._dps["106"] = "CONNECTION_FAILED"
raise ConnectionException( asyncio.ensure_future(self.async_disconnect())
"Connection to {} failed: {}".format(self, e)
)
elif isinstance(e, asyncio.IncompleteReadError): elif isinstance(e, asyncio.IncompleteReadError):
raise InvalidMessage( _LOGGER.error("Incomplete read from: {} : {}".format(self, e))
"Incomplete read from: {} : {}".format(self, e)
)
else: else:
raise TuyaException("Failed to send data to {}".format(self)) _LOGGER.error("Failed to send data to {}".format(self))
return
if isinstance(e, socket.error): if isinstance(e, socket.error):
self._LOGGER.debug( _LOGGER.debug(
"Retrying send due to error. Connection to {} failed: {}".format( "Retrying send due to error. Connection to {} failed: {}".format(
self, e self, e
) )
) )
elif isinstance(e, asyncio.IncompleteReadError): elif isinstance(e, asyncio.IncompleteReadError):
self._LOGGER.debug( _LOGGER.debug(
"Retrying send due to error. Incomplete read from: {} : {}. Partial data recieved: {}".format( "Retrying send due to error.Incomplete read from: {} : {}".format(
self, e, e.partial self, e
) )
) )
else: else:
self._LOGGER.debug( _LOGGER.debug(
"Retrying send due to error. Failed to send data to {}".format(self) "Retrying send due to error. Failed to send data to {}".format(self)
) )
await asyncio.sleep(0.25)
await self._async_send(message, retries=retries - 1) await self._async_send(message, retries=retries - 1)
async def async_recieve(self, message):
if self._connected is False:
return
if message.expect_response is True:
try:
self._recieve_task = asyncio.create_task(
asyncio.wait_for(message.listener.acquire(), timeout=self.timeout)
)
await self._recieve_task
response = self._listeners.pop(message.sequence)
if isinstance(response, Exception):
raise response
return response
except Exception as e:
del self._listeners[message.sequence]
await self.async_disconnect()
if isinstance(e, TimeoutError):
raise ResponseTimeoutException(
"Timed out waiting for response to sequence number {}".format(
message.sequence
)
)
raise e

View File

@ -11,10 +11,6 @@ _LOGGER = logging.getLogger(__name__)
UDP_KEY = md5(b"yGAdlopoPVldABfn").digest() UDP_KEY = md5(b"yGAdlopoPVldABfn").digest()
class DiscoveryPortsNotAvailableException(Exception):
"""This model is not supported"""
class TuyaLocalDiscovery(asyncio.DatagramProtocol): class TuyaLocalDiscovery(asyncio.DatagramProtocol):
def __init__(self, callback): def __init__(self, callback):
self.devices = {} self.devices = {}
@ -30,13 +26,8 @@ class TuyaLocalDiscovery(asyncio.DatagramProtocol):
lambda: self, local_addr=("0.0.0.0", 6667), reuse_port=True lambda: self, local_addr=("0.0.0.0", 6667), reuse_port=True
) )
try:
self._listeners = await asyncio.gather(listener, encrypted_listener) self._listeners = await asyncio.gather(listener, encrypted_listener)
_LOGGER.debug("Listening to broadcasts on UDP port 6666 and 6667") _LOGGER.debug("Listening to broadcasts on UDP port 6666 and 6667")
except Exception as e:
raise DiscoveryPortsNotAvailableException(
"Ports 6666 and 6667 are needed for autodiscovery but are unavailable. This may be due to having the localtuya integration installed and it not allowing other integrations to use the same ports. A pull request has been raised to address this: https://github.com/rospogrigio/localtuya/pull/1481"
)
def close(self, *args, **kwargs): def close(self, *args, **kwargs):
for transport, _ in self._listeners: for transport, _ in self._listeners:

View File

@ -90,20 +90,17 @@ class TuyaAPISession:
country_code = None country_code = None
session_id = None session_id = None
def __init__(self, username, region, timezone, phone_code): def __init__(self, username, region, timezone):
self.session = requests.session() self.session = requests.session()
self.session.headers = DEFAULT_TUYA_HEADERS.copy() self.session.headers = DEFAULT_TUYA_HEADERS.copy()
self.default_query_params = DEFAULT_TUYA_QUERY_PARAMS.copy() self.default_query_params = DEFAULT_TUYA_QUERY_PARAMS.copy()
self.default_query_params["deviceId"] = self.generate_new_device_id() self.default_query_params["deviceId"] = self.generate_new_device_id()
self.username = username self.username = username
self.country_code = phone_code self.country_code = self.getCountryCode(region)
self.base_url = { self.base_url = {
"AZ": "https://a1.tuyaus.com",
"AY": "https://a1.tuyacn.com",
"IN": "https://a1.tuyain.com",
"EU": "https://a1.tuyaeu.com", "EU": "https://a1.tuyaeu.com",
}.get(region, "https://a1.tuyaeu.com") "AY": "https://a1.tuyacn.com",
}.get(region, "https://a1.tuyaus.com")
DEFAULT_TUYA_QUERY_PARAMS["timeZoneId"] = timezone DEFAULT_TUYA_QUERY_PARAMS["timeZoneId"] = timezone
@staticmethod @staticmethod
@ -236,7 +233,12 @@ class TuyaAPISession:
def list_homes(self): def list_homes(self):
return self._request(action="tuya.m.location.list", version="2.1") return self._request(action="tuya.m.location.list", version="2.1")
def get_device(self, devId): def list_devices(self, home_id: str):
return self._request( return self._request(
action="tuya.m.device.get", version="1.0", data={"devId": devId} action="tuya.m.my.group.device.list",
version="1.0",
query_params={"gid": home_id},
) )
def getCountryCode(self, region_code):
return {"EU": "44", "AY": "86"}.get(region_code, "1")

View File

@ -55,8 +55,7 @@ from homeassistant.const import (
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
) )
from .tuyalocalapi import TuyaException from .const import CONF_VACS, DOMAIN
from .const import CONF_VACS, DOMAIN, REFRESH_RATE, PING_RATE, TIMEOUT
from .errors import getErrorMessage from .errors import getErrorMessage
from .robovac import ( from .robovac import (
@ -84,8 +83,8 @@ ATTR_CONSUMABLES = "consumables"
ATTR_MODE = "mode" ATTR_MODE = "mode"
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
REFRESH_RATE = 20
SCAN_INTERVAL = timedelta(seconds=REFRESH_RATE) SCAN_INTERVAL = timedelta(seconds=REFRESH_RATE)
UPDATE_RETRIES = 3
class TUYA_CODES(StrEnum): class TUYA_CODES(StrEnum):
@ -99,9 +98,8 @@ class TUYA_CODES(StrEnum):
AUTO_RETURN = "135" AUTO_RETURN = "135"
DO_NOT_DISTURB = "107" DO_NOT_DISTURB = "107"
BOOST_IQ = "118" BOOST_IQ = "118"
G_CONSUMABLES = "142"
X_CONSUMABLES = "116"
TUYA_CONSUMABLES_CODES = ["142", "116"]
async def async_setup_entry( async def async_setup_entry(
@ -114,8 +112,7 @@ async def async_setup_entry(
for item in vacuums: for item in vacuums:
item = vacuums[item] item = vacuums[item]
entity = RoboVacEntity(item) entity = RoboVacEntity(item)
hass.data[DOMAIN][CONF_VACS][item[CONF_ID]] = entity async_add_entities([entity], update_before_add=True)
async_add_entities([entity])
class RoboVacEntity(StateVacuumEntity): class RoboVacEntity(StateVacuumEntity):
@ -194,20 +191,10 @@ class RoboVacEntity(StateVacuumEntity):
def state(self) -> str | None: def state(self) -> str | None:
if self.tuya_state is None: if self.tuya_state is None:
return STATE_UNAVAILABLE return STATE_UNAVAILABLE
elif ( elif type(self.error_code) is not None and self.error_code not in [
type(self.error_code) is not None
and self.error_code
and self.error_code
not in [
0, 0,
"no_error", "no_error",
] ]:
):
_LOGGER.debug(
"State changed to error. Error message: {}".format(
getErrorMessage(self.error_code)
)
)
return STATE_ERROR return STATE_ERROR
elif self.tuya_state == "Charging" or self.tuya_state == "completed": elif self.tuya_state == "Charging" or self.tuya_state == "completed":
return STATE_DOCKED return STATE_DOCKED
@ -266,17 +253,14 @@ class RoboVacEntity(StateVacuumEntity):
self._attr_ip_address = item[CONF_IP_ADDRESS] self._attr_ip_address = item[CONF_IP_ADDRESS]
self._attr_access_token = item[CONF_ACCESS_TOKEN] self._attr_access_token = item[CONF_ACCESS_TOKEN]
self.update_failures = 0
try: try:
self.vacuum = RoboVac( self.vacuum = RoboVac(
device_id=self.unique_id, device_id=self.unique_id,
host=self.ip_address, host=self.ip_address,
local_key=self.access_token, local_key=self.access_token,
timeout=TIMEOUT, timeout=2,
ping_interval=PING_RATE, ping_interval=REFRESH_RATE,
model_code=self.model_code[0:5], model_code=self.model_code[0:5],
update_entity_state=self.pushed_update_handler,
) )
except ModelNotSupportedException: except ModelNotSupportedException:
self.error_code = "UNSUPPORTED_MODEL" self.error_code = "UNSUPPORTED_MODEL"
@ -310,25 +294,7 @@ class RoboVacEntity(StateVacuumEntity):
self.error_code = "IP_ADDRESS" self.error_code = "IP_ADDRESS"
return return
try:
await self.vacuum.async_get() await self.vacuum.async_get()
self.update_failures = 0
self.update_entity_values()
except TuyaException as e:
self.update_failures += 1
_LOGGER.warn(
"Update errored. Current update failure count: {}. Reason: {}".format(
self.update_failures, e
)
)
if self.update_failures >= UPDATE_RETRIES:
self.error_code = "CONNECTION_FAILED"
async def pushed_update_handler(self):
self.update_entity_values()
self.async_write_ha_state()
def update_entity_values(self):
self.tuyastatus = self.vacuum._dps self.tuyastatus = self.vacuum._dps
# for 15C # for 15C
@ -352,41 +318,44 @@ class RoboVacEntity(StateVacuumEntity):
# self.map_data = self.tuyastatus.get("121") # self.map_data = self.tuyastatus.get("121")
# self.erro_msg? = self.tuyastatus.get("124") # self.erro_msg? = self.tuyastatus.get("124")
if self.robovac_supported & RoboVacEntityFeature.CONSUMABLES: if self.robovac_supported & RoboVacEntityFeature.CONSUMABLES:
for CONSUMABLE_CODE in TUYA_CONSUMABLES_CODES: robovac_series = self.vacuum.getRoboVacSeries()
if ( if (
CONSUMABLE_CODE in self.tuyastatus self.tuyastatus.get(TUYA_CODES["{}_CONSUMABLES".format(robovac_series)])
and self.tuyastatus.get(CONSUMABLE_CODE) is not None is not None
): ):
consumables = ast.literal_eval( self._attr_consumables = ast.literal_eval(
base64.b64decode(self.tuyastatus.get(CONSUMABLE_CODE)).decode( base64.b64decode(
"ascii" self.tuyastatus.get(
TUYA_CODES["{}_CONSUMABLES".format(robovac_series)]
) )
) ).decode("ascii")
if ( )["consumable"]["duration"]
"consumable" in consumables
and "duration" in consumables["consumable"]
):
self._attr_consumables = consumables["consumable"]["duration"]
async def async_locate(self, **kwargs): async def async_locate(self, **kwargs):
"""Locate the vacuum cleaner.""" """Locate the vacuum cleaner."""
_LOGGER.info("Locate Pressed") _LOGGER.info("Locate Pressed")
if self.tuyastatus.get("103"): if self.tuyastatus.get("103"):
await self.vacuum.async_set({"103": False}) await self.vacuum.async_set({"103": False}, None)
else: else:
await self.vacuum.async_set({"103": True}) await self.vacuum.async_set({"103": True}, None)
async def async_return_to_base(self, **kwargs): async def async_return_to_base(self, **kwargs):
"""Set the vacuum cleaner to return to the dock.""" """Set the vacuum cleaner to return to the dock."""
_LOGGER.info("Return home Pressed") _LOGGER.info("Return home Pressed")
await self.vacuum.async_set({"101": True}) await self.vacuum.async_set({"101": True}, None)
await asyncio.sleep(1)
self.async_update
async def async_start(self, **kwargs): async def async_start(self, **kwargs):
self._attr_mode = "auto" self._attr_mode = "auto"
await self.vacuum.async_set({"5": self.mode}) await self.vacuum.async_set({"5": self.mode}, None)
await asyncio.sleep(1)
self.async_update
async def async_pause(self, **kwargs): async def async_pause(self, **kwargs):
await self.vacuum.async_set({"2": False}) await self.vacuum.async_set({"2": False}, None)
await asyncio.sleep(1)
self.async_update
async def async_stop(self, **kwargs): async def async_stop(self, **kwargs):
await self.async_return_to_base() await self.async_return_to_base()
@ -394,7 +363,9 @@ class RoboVacEntity(StateVacuumEntity):
async def async_clean_spot(self, **kwargs): async def async_clean_spot(self, **kwargs):
"""Perform a spot clean-up.""" """Perform a spot clean-up."""
_LOGGER.info("Spot Clean Pressed") _LOGGER.info("Spot Clean Pressed")
await self.vacuum.async_set({"5": "Spot"}) await self.vacuum.async_set({"5": "Spot"}, None)
await asyncio.sleep(1)
self.async_update
async def async_set_fan_speed(self, fan_speed, **kwargs): async def async_set_fan_speed(self, fan_speed, **kwargs):
"""Set fan speed.""" """Set fan speed."""
@ -405,7 +376,9 @@ class RoboVacEntity(StateVacuumEntity):
fan_speed = "Boost_IQ" fan_speed = "Boost_IQ"
elif fan_speed == "Pure": elif fan_speed == "Pure":
fan_speed = "Quiet" fan_speed = "Quiet"
await self.vacuum.async_set({"102": fan_speed}) await self.vacuum.async_set({"102": fan_speed}, None)
await asyncio.sleep(1)
self.async_update
async def async_send_command( async def async_send_command(
self, command: str, params: dict | list | None = None, **kwargs self, command: str, params: dict | list | None = None, **kwargs
@ -413,28 +386,28 @@ class RoboVacEntity(StateVacuumEntity):
"""Send a command to a vacuum cleaner.""" """Send a command to a vacuum cleaner."""
_LOGGER.info("Send Command %s Pressed", command) _LOGGER.info("Send Command %s Pressed", command)
if command == "edgeClean": if command == "edgeClean":
await self.vacuum.async_set({"5": "Edge"}) await self.vacuum.async_set({"5": "Edge"}, None)
elif command == "smallRoomClean": elif command == "smallRoomClean":
await self.vacuum.async_set({"5": "SmallRoom"}) await self.vacuum.async_set({"5": "SmallRoom"}, None)
elif command == "autoClean": elif command == "autoClean":
await self.vacuum.async_set({"5": "auto"}) await self.vacuum.async_set({"5": "auto"}, None)
elif command == "autoReturn": elif command == "autoReturn":
if self.auto_return: if self.auto_return:
await self.vacuum.async_set({"135": False}) await self.vacuum.async_set({"135": False}, None)
else: else:
await self.vacuum.async_set({"135": True}) await self.vacuum.async_set({"135": True}, None)
elif command == "doNotDisturb": elif command == "doNotDisturb":
if self.do_not_disturb: if self.do_not_disturb:
await self.vacuum.async_set({"139": "MEQ4MDAwMDAw"}) await self.vacuum.async_set({"139": "MEQ4MDAwMDAw"}, None)
await self.vacuum.async_set({"107": False}) await self.vacuum.async_set({"107": False}, None)
else: else:
await self.vacuum.async_set({"139": "MTAwMDAwMDAw"}) await self.vacuum.async_set({"139": "MTAwMDAwMDAw"}, None)
await self.vacuum.async_set({"107": True}) await self.vacuum.async_set({"107": True}, None)
elif command == "boostIQ": elif command == "boostIQ":
if self.boost_iq: if self.boost_iq:
await self.vacuum.async_set({"118": False}) await self.vacuum.async_set({"118": False}, None)
else: else:
await self.vacuum.async_set({"118": True}) await self.vacuum.async_set({"118": True}, None)
elif command == "roomClean": elif command == "roomClean":
roomIds = params.get("roomIds", [1]) roomIds = params.get("roomIds", [1])
count = params.get("count", 1) count = params.get("count", 1)
@ -447,7 +420,9 @@ class RoboVacEntity(StateVacuumEntity):
json_str = json.dumps(method_call, separators=(",", ":")) json_str = json.dumps(method_call, separators=(",", ":"))
base64_str = base64.b64encode(json_str.encode("utf8")).decode("utf8") base64_str = base64.b64encode(json_str.encode("utf8")).decode("utf8")
_LOGGER.info("roomClean call %s", json_str) _LOGGER.info("roomClean call %s", json_str)
await self.vacuum.async_set({"124": base64_str}) await self.vacuum.async_set({"124": base64_str}, None)
await asyncio.sleep(1)
self.async_update
async def async_will_remove_from_hass(self): async def async_will_remove_from_hass(self):
await self.vacuum.async_disable() await self.vacuum.async_disconnect()

6041
package-lock.json generated

File diff suppressed because it is too large Load Diff

View File

@ -1,6 +0,0 @@
{
"devDependencies": {
"conventional-changelog-conventionalcommits": "^7.0.2",
"semantic-release": "^23.0.2"
}
}

View File

@ -1,4 +1,4 @@
cryptography==41.0.4 cryptography==41.0.3
homeassistant==2023.8.4 homeassistant==2023.8.4
Requests==2.31.0 Requests==2.31.0
setuptools==68.0.0 setuptools==68.0.0

View File

@ -24,18 +24,18 @@ import warnings
dynamic_requires = [] dynamic_requires = []
setup( setup(
name="robovac", name='robovac',
version="1.0", version="1.0",
author="Luke Morrigan", author='Luke Bonaccorsi',
url="http://github.com/codefoodpixels/robovac", url='http://github.com/codefoodpixels/robovac',
packages=find_packages(), packages=find_packages(),
scripts=[], scripts=[],
description="Python API for controlling Eufy Robovac vacuum cleaners", description='Python API for controlling Eufy Robovac vacuum cleaners',
classifiers=[ classifiers=[
"Development Status :: 4 - Beta", 'Development Status :: 4 - Beta',
"Intended Audience :: Developers", 'Intended Audience :: Developers',
"License :: OSI Approved :: Apache Software License", 'License :: OSI Approved :: Apache Software License',
"Operating System :: OS Independent", 'Operating System :: OS Independent',
"Programming Language :: Python", 'Programming Language :: Python',
], ],
) )