pyvesync 3.0.0b2__tar.gz → 3.0.0b3__tar.gz

{pyvesync-3.0.0b2/src/pyvesync.egg-info → pyvesync-3.0.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.0.0b2
+Version: 3.0.0b3
 Summary: pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app.
 Author: Mark Perdue
 Author-email: Joe Trabulsy <webdjoe@gmail.com>

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyvesync"
-version = "3.0.0b2"
+version = "3.0.0b3"
 description = "pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app."
 readme = "README.md"
 requires-python = ">=3.11"

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/const.py

@@ -4,7 +4,8 @@ All device states and information are defined by Enums in this module.
 
 Attributes:
     DEFAULT_LANGUAGE (str): Default language for the VeSync app.
-    API_BASE_URL (str): Base URL for the VeSync API.
+    API_BASE_URL (str): Base URL for the VeSync API. If not specified,
+        a region-specific API URL is automatically selected.
     API_TIMEOUT (int): Timeout for API requests.
     USER_AGENT (str): User agent for API requests.
     DEFAULT_TZ (str): Default timezone for VeSync devices, updated by API after
@@ -12,6 +13,8 @@ Attributes:
     DEFAULT_REGION (str): Default region for VeSync devices,
         updated by API when retrieving devices.
     APP_VERSION (str): Version of the VeSync app.
+    APP_ID (str): ID of the app. VeSync uses a random 8-letter string, but any non-empty
+        string works.
     PHONE_BRAND (str): Brand of the phone used to login to the VeSync app.
     PHONE_OS (str): Operating system of the phone used to login to the VeSync app.
     MOBILE_ID (str): Unique identifier for the phone used to login to the VeSync app.
@@ -20,23 +23,28 @@ Attributes:
     BYPASS_HEADER_UA (str): Bypass header user agent
     TERMINAL_ID (str): Unique identifier for new API calls
 """
-from random import randint
+from random import randint, choices
 from uuid import uuid4
+import string
 from enum import StrEnum, IntEnum, Enum
 from types import MappingProxyType
 from pyvesync.utils.enum_utils import IntEnumMixin
 
 DEFAULT_LANGUAGE = "en"
-API_BASE_URL = "https://smartapi.vesync.com"
+API_BASE_URL = None  # Global URL (non-EU regions): "https://smartapi.vesync.com"
 # If device is out of reach, the cloud api sends a timeout response after 7 seconds,
 # using 8 here so there is time enough to catch that message
+API_BASE_URL_US = "https://smartapi.vesync.com"
+API_BASE_URL_EU = "https://smartapi.vesync.eu"
+NON_EU_REGIONS = ['US', 'CA', 'MX', 'JP']
 API_TIMEOUT = 8
 USER_AGENT = (
     "VeSync/3.2.39 (com.etekcity.vesyncPlatform; build:5; iOS 15.5.0) Alamofire/5.2.1"
 )
 DEFAULT_TZ = "America/New_York"
 DEFAULT_REGION = "US"
-APP_VERSION = "5.5.60"
+APP_VERSION = "5.6.60"
+APP_ID = ''.join(choices(string.ascii_lowercase + string.digits, k=8))  # noqa: S311
 PHONE_BRAND = "SM N9005"
 PHONE_OS = "Android"
 # MOBILE_ID = "1234567890123456"
@@ -45,6 +53,7 @@ USER_TYPE = "1"
 BYPASS_APP_V = f"VeSync {APP_VERSION}"
 BYPASS_HEADER_UA = "okhttp/3.12.1"
 TERMINAL_ID = '2' + str(uuid4()).replace('-', '')
+CLIENT_TYPE = "vesyncApp"
 
 
 # Generic Constants

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/models/base_models.py

@@ -27,6 +27,7 @@ from mashumaro.config import BaseConfig
 from pyvesync.const import (
     USER_TYPE,
     APP_VERSION,
+    APP_ID,
     PHONE_BRAND,
     PHONE_OS,
     MOBILE_ID,
@@ -35,6 +36,7 @@ from pyvesync.const import (
     DEFAULT_TZ,
     BYPASS_HEADER_UA,
     TERMINAL_ID,
+    CLIENT_TYPE
     )
 
 
@@ -86,6 +88,8 @@ class DefaultValues:
     _call_number: ClassVar[int] = 0
     userType: str = USER_TYPE
     appVersion: str = APP_VERSION
+    clientType: str = CLIENT_TYPE
+    appId: str = APP_ID
     phoneBrand: str = PHONE_BRAND
     phoneOS: str = PHONE_OS
     mobileId: str = MOBILE_ID

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/models/vesync_models.py

@@ -23,8 +23,8 @@ from pyvesync.models.base_models import (
 
 
 @dataclass
-class RequestLoginModel(RequestBaseModel):
-    """Request model for login."""
+class RequestAuthModel(RequestBaseModel):
+    """Request model for requesting auth token (used for login)."""
     # Arguments to set
     email: str
     method: str
@@ -32,21 +32,22 @@ class RequestLoginModel(RequestBaseModel):
     # default values
     acceptLanguage: str = DefaultValues.acceptLanguage
     accountID: str = ''
+    authProtocolType: str = "generic"
     clientInfo: str = DefaultValues.phoneBrand
-    clientType: str = "vesyncApp"
+    clientType: str = DefaultValues.clientType
     clientVersion: str = f"VeSync {DefaultValues.appVersion}"
     debugMode: bool = False
     osInfo: str = DefaultValues.phoneOS
     terminalId: str = DefaultValues.terminalId
     timeZone: str = DefaultValues.timeZone
     token: str = ''
-    userCountryCode: str = ''
-    devToken: str = ''
-    userType: str = DefaultValues.userType
+    userCountryCode: str = DefaultValues.userCountryCode
+    appID: str = DefaultValues.appId
+    sourceAppID: str = DefaultValues.appId
     traceId: str = field(default_factory=DefaultValues.newTraceId)
 
     def __post_init__(self) -> None:
-        """Set the method field."""
+        """Hash the password field."""
         self.password = self.hash_password(self.password)
 
     @staticmethod
@@ -55,6 +56,50 @@ class RequestLoginModel(RequestBaseModel):
         return hashlib.md5(string.encode('utf-8')).hexdigest()  # noqa: S324
 
 
+@dataclass
+class IntRespAuthResultModel(ResponseBaseModel):
+    """Model for the 'result' field in auth response with authorizeCode and account ID.
+
+    This class is referenced by the `ResponseAuthModel` class.
+    """
+    accountID: str
+    authorizeCode: str
+
+
+@dataclass
+class RequestLoginModel(RequestBaseModel):
+    """Request model for login."""
+    # Arguments to set
+    method: str
+    authorizeCode: str | None
+    # default values
+    acceptLanguage: str = DefaultValues.acceptLanguage
+    accountID: str = ''
+    clientInfo: str = DefaultValues.phoneBrand
+    clientType: str = DefaultValues.clientType
+    clientVersion: str = f"VeSync {DefaultValues.appVersion}"
+    debugMode: bool = False
+    emailSubscriptions: bool = False
+    osInfo: str = DefaultValues.phoneOS
+    terminalId: str = DefaultValues.terminalId
+    timeZone: str = DefaultValues.timeZone
+    token: str = ""
+    bizToken: str | None = None
+    regionChange: str | None = None
+    userCountryCode: str = DefaultValues.userCountryCode
+    traceId: str = field(default_factory=DefaultValues.newTraceId)
+
+    def __post_serialize__(self, d: dict[Any, Any]) -> dict[Any, Any]:
+        """Remove null keys."""
+        if d['regionChange'] is None:
+            d.pop('regionChange')
+        if d['authorizeCode'] is None:
+            d.pop('authorizeCode')
+        if d['bizToken'] is None:
+            d.pop('bizToken')
+        return d
+
+
 @dataclass
 class IntRespLoginResultModel(ResponseBaseModel):
     """Model for the 'result' field in login response containing token and account ID.
@@ -65,6 +110,40 @@ class IntRespLoginResultModel(ResponseBaseModel):
     acceptLanguage: str
     countryCode: str
     token: str
+    bizToken: str = ''
+    currentRegion: str = ''
+
+
+# @dataclass
+# class ResponseAuthModel(ResponseCodeModel):
+#     """Model for the auth response.
+
+#     Inherits from `BaseResultModel`. The `BaseResultModel` class provides the
+#     defaults "code" and "msg" fields for the response.
+
+#     Attributes:
+#         result: ResponseAuthResultModel
+#             The inner model for the 'result' field in the auth response.
+
+#     Examples:
+#         ```python
+#         a = {
+#             "code": 0,
+#             "msg": "success",
+#             "stacktrace": null,
+#             "module": null,
+#             "traceId": "123456",
+#             "result": {
+#                 "accountID": "123456",
+#                 "authorizeCode": "abcdef1234567890"
+#             }
+#         }
+#         b = ResponseAuthModel.from_dict(a)
+#         account_id = b.result.accountId
+#         authorizeCode = b.result.authorizeCode
+#         ```
+#     """
+#     result: IntRespAuthResultModel
 
 
 @dataclass
@@ -91,14 +170,14 @@ class ResponseLoginModel(ResponseCodeModel):
                 "acceptLanguage": "en",
                 "countryCode": "US",
                 "token": "abcdef1234567890"
-                }
+            }
         }
         b = ResponseLoginModel.from_dict(a)
         account_id = b.result.accountId
         token = b.result.token
         ```
     """
-    result: IntRespLoginResultModel
+    result: IntRespLoginResultModel | IntRespAuthResultModel
 
 
 @dataclass

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/utils/errors.py

@@ -97,6 +97,7 @@ class ErrorTypes(StrEnum):
     UNKNOWN_ERROR = "unknown_error"
     TOKEN_ERROR = "token_error"
     BAD_RESPONSE = "bad_response"
+    CROSS_REGION = "cross_region"
 
 
 class ErrorCodes:
@@ -135,6 +136,11 @@ class ErrorCodes:
 
     errors: MappingProxyType[str, ResponseInfo] = MappingProxyType(
         {
+            "-11260022": ResponseInfo(
+                "CROSS_REGION_ERROR",
+                ErrorTypes.CROSS_REGION,
+                "Cross region error",
+            ),
             "11": ResponseInfo(
                 "DEVICE_OFFLINE",
                 ErrorTypes.DEVICE_OFFLINE,

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/utils/logs.py

@@ -100,6 +100,7 @@ class LibraryLogger:
         their values with '##_REDACTED_##'. The keys that are redacted include:
 
         - token
+        - authorizeCode
         - password
         - email
         - tk
@@ -130,6 +131,7 @@ class LibraryLogger:
                     r'(?<=uuid":\s")|'
                     r'(?<=cid":\s")|'
                     r"(?<=token\s)|"
+                    r"(?<=authorizeCode\s)|"
                     r"(?<=account_id\s))"
                     r'[^"\s]+'
                 ),
@@ -182,7 +184,9 @@ class LibraryLogger:
 
     @staticmethod
     def configure_logger(
-        level: str | int = logging.INFO, file_name: str | None = None
+        level: str | int = logging.INFO,
+        file_name: str | Path | None = None,
+        std_out: bool = True,
     ) -> None:
         """Configure pyvesync library logger with a specific log level.
 
@@ -191,6 +195,7 @@ class LibraryLogger:
                 in form of enum `logging.DEBUG` or string `DEBUG`.
             file_name (str | None): The name of the file to log to. If None,
                 logs will only be printed to the console.
+            std_out (bool): If True, logs will be printed to standard output.
 
         Note:
             This method configures the pyvesync base logger and prevents
@@ -203,18 +208,22 @@ class LibraryLogger:
         if root_logger.handlers:
             for handler in root_logger.handlers:
                 root_logger.removeHandler(handler)
-        handler = logging.StreamHandler()
+
         formatter = logging.Formatter(
             fmt="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
             datefmt="%Y-%m-%d %H:%M:%S",
         )
-        handler.setFormatter(formatter)
-        root_logger.addHandler(handler)
-        if file_name:
-            if not Path(file_name).is_absolute():
-                file_name_path = Path(file_name).joinpath(Path.cwd(), file_name)
-            else:
-                file_name_path = Path(file_name)
+        if std_out is True:
+            str_handler = logging.StreamHandler()
+            str_handler.setFormatter(formatter)
+            root_logger.addHandler(str_handler)
+        if isinstance(file_name, str):
+            file_name_path = Path(file_name).resolve()
+        elif isinstance(file_name, Path):
+            file_name_path = file_name.resolve()
+        else:
+            file_name_path = None
+        if file_name_path:
             file_handler = logging.FileHandler(file_name_path)
             file_handler.setFormatter(formatter)
             root_logger.addHandler(file_handler)
@@ -274,11 +283,11 @@ class LibraryLogger:
             if dif:
                 msg += "\n\n-------------------------------------"
                 msg += "\n Expected Fields:"
-                msg += f"\n({", ".join(field_f)})"
+                msg += f"\n({', '.join(field_f)})"
                 msg += "\n Response Fields:"
-                msg += f"\n({", ".join(resp_f)})"
+                msg += f"\n({', '.join(resp_f)})"
                 msg += "\n Missing Fields:"
-                msg += f"\n({", ".join(dif)})"
+                msg += f"\n({', '.join(dif)})"
 
         msg += "\n\n Full Response:"
         msg += f"\n{orjson.dumps(resp_dict, option=orjson.OPT_INDENT_2).decode('utf-8')}"

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3}/src/pyvesync/vesync.py

@@ -3,21 +3,31 @@
 from __future__ import annotations
 import logging
 import asyncio
+from pathlib import Path
 from typing import Self
 from dataclasses import fields, MISSING
 from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientResponseError
 from mashumaro.mixins.orjson import DataClassORJSONMixin
+from mashumaro.exceptions import UnserializableDataError, MissingField
 
 from pyvesync.utils.helpers import Helpers
-from pyvesync.const import API_BASE_URL, DEFAULT_REGION
+from pyvesync.const import (
+    API_BASE_URL_US,
+    API_BASE_URL_EU,
+    DEFAULT_REGION,
+    NON_EU_REGIONS,
+)
 from pyvesync.device_container import DeviceContainer, DeviceContainerInstance
 from pyvesync.utils.logs import LibraryLogger
 from pyvesync.models.vesync_models import (
     RequestDeviceListModel,
     ResponseDeviceListModel,
+    RequestAuthModel,
+    IntRespAuthResultModel,
     RequestLoginModel,
     ResponseLoginModel,
+    IntRespLoginResultModel,
     RequestFirmwareModel,
     ResponseFirmwareModel,
     FirmwareDeviceItemModel
@@ -67,6 +77,7 @@ class VeSync:  # pylint: disable=function-redefined
     def __init__(self,
                  username: str,
                  password: str,
+                 country_code: str = DEFAULT_REGION,
                  session: ClientSession | None = None,
                  time_zone: str = DEFAULT_TZ) -> None:
         """Initialize VeSync Manager.
@@ -83,6 +94,11 @@ class VeSync:  # pylint: disable=function-redefined
         Args:
             username (str): VeSync account username (usually email address)
             password (str): VeSync account password
+            country_code (str): VeSync account country in ISO 3166 Alpha-2 format.
+                By default, the account region is detected automatically at the login step
+                If your account country is different from the default `US`,
+                a second login attempt may be necessary - in this case
+                you should specify the country directly to speed up the login process.
             session (ClientSession): aiohttp client session for
                 API calls, by default None
             time_zone (str): Time zone for device from IANA database, by default
@@ -130,7 +146,7 @@ class VeSync:  # pylint: disable=function-redefined
         self.password: str = password
         self._token: str | None = None
         self._account_id: str | None = None
-        self.country_code: str = DEFAULT_REGION
+        self.country_code: str = country_code.upper()
         self._verbose: bool = False
         self.time_zone: str = time_zone
         self.language: str = 'en'
@@ -207,10 +223,15 @@ class VeSync:  # pylint: disable=function-redefined
             LibraryLogger.shouldredact = False
         self._redact = new_flag
 
-    def log_to_file(self, filename: str) -> None:
-        """Log to file and enable debug logging."""
+    def log_to_file(self, filename: str | Path, std_out: bool = True) -> None:
+        """Log to file and enable debug logging.
+
+        Args:
+            filename (str | Path): The name of the file to log to.
+            std_out (bool): If False, logs will not print to std out.
+        """
         self.debug = True
-        LibraryLogger.configure_logger(logging.DEBUG, file_name=filename)
+        LibraryLogger.configure_logger(logging.DEBUG, file_name=filename, std_out=std_out)
         logger.debug('Logging to file: %s', filename)
 
     def process_devices(self, dev_list_resp: ResponseDeviceListModel) -> bool:
@@ -300,38 +321,112 @@ class VeSync:  # pylint: disable=function-redefined
         if not isinstance(self.username, str) or len(self.username) == 0 \
                 or not isinstance(self.password, str) or len(self.password) == 0:
             raise VesyncLoginError('Username and password must be specified')
-        request_login = RequestLoginModel(
+        request_auth = RequestAuthModel(
             email=self.username,
-            method='appLoginV3',
+            method='authByPWDOrOTM',
             password=self.password,
         )
         resp_dict, _ = await self.async_call_api(
-            '/user/api/accountManage/v3/appLoginV3', 'post',
-            json_object=request_login
+            '/globalPlatform/api/accountAuth/v1/authByPWDOrOTM', 'post',
+            json_object=request_auth
         )
         if resp_dict is None:
-            raise VeSyncAPIResponseError('Error receiving response to login request')
+            raise VeSyncAPIResponseError('Error receiving response to auth request')
         if resp_dict.get('code') == 0:
             try:
                 response_model = ResponseLoginModel.from_dict(resp_dict)
             except Exception as exc:
-                logger.debug('Error parsing login response: %s', exc)
+                logger.debug('Error parsing auth response: %s', exc)
                 raise VeSyncAPIResponseError(
-                    'Error receiving response to login request'
+                    'Error receiving response to auth request'
                     ) from exc
             result = response_model.result
-            self._token = result.token
-            self._account_id = result.accountID
-            self.country_code = result.countryCode
-            self.enabled = True
-            logger.debug('Login successful')
-            return True
+            if isinstance(result, IntRespAuthResultModel):
+                # If the result is an IntRespAuthResultModel,
+                # we need to log in with the auth code
+                return await self._login_token(auth_code=result.authorizeCode)
 
         error_info = ErrorCodes.get_error_info(resp_dict.get("code"))
         resp_message = resp_dict.get('msg')
         if resp_message is not None:
             error_info.message = f'{error_info.message} ({resp_message})'
-        raise VeSyncAPIResponseError('Error receiving response to login request')
+        raise VeSyncAPIResponseError(
+            f"Error receiving response to auth request - {error_info.message}"
+        )
+
+    async def _login_token(
+            self,
+            auth_code: str | None = None,
+            region_change_token: str | None = None,
+    ) -> bool:  # pylint: disable=W9006 # pylint mult docstring raises
+        """Exchanges the authorization code for a token.
+
+        This completes the login process. If the initial call fails with
+        `"login trigger cross region error."`, the region is adjusted and
+        another attempt is made.
+
+        Args:
+            auth_code (str): Auth code to use for logging in.
+            region_change_token (str): "bizToken" to use when calling this endpoint
+                for a second time with a different region.
+
+        Returns:
+            True if login successful, False if not.
+
+        Raises:
+            VeSyncLoginError: If login fails due to invalid username or password.
+            VeSyncAPIResponseError: If API response is invalid.
+            VeSyncServerError: If server returns an error.
+        """
+        request_login = RequestLoginModel(
+            method='loginByAuthorizeCode4Vesync',
+            authorizeCode=auth_code,
+            bizToken=region_change_token,
+            userCountryCode=self.country_code,
+            regionChange="last_region" if region_change_token else None,
+        )
+        resp_dict, _ = await self.async_call_api(
+            '/user/api/accountManage/v1/loginByAuthorizeCode4Vesync', 'post',
+            json_object=request_login
+        )
+        if resp_dict is None:
+            raise VeSyncAPIResponseError('Error receiving response to login request')
+        try:
+            response_model = ResponseLoginModel.from_dict(resp_dict)
+            if not isinstance(response_model.result, IntRespLoginResultModel):
+                raise VeSyncAPIResponseError(
+                    "Error receiving response to login request -"
+                    "result is not IntRespLoginResultModel"
+                )
+            if response_model.code == 0:
+                result = response_model.result
+                if not isinstance(result, IntRespLoginResultModel):
+                    raise VeSyncAPIResponseError(
+                        "Error receiving response to login request -"
+                        " result is not IntRespLoginResultModel"
+                    )
+                self._token = result.token
+                self._account_id = result.accountID
+                self.country_code = result.countryCode
+                self.enabled = True
+                logger.debug('Login successful')
+                return True
+            error_info = ErrorCodes.get_error_info(resp_dict.get("code"))
+            if error_info.error_type == ErrorTypes.CROSS_REGION:  # "cross region error."
+                result = response_model.result
+                self.country_code = result.countryCode
+                return await self._login_token(region_change_token=result.bizToken)
+            resp_message = resp_dict.get('msg')
+            if resp_message is not None:
+                error_info.message = f'{error_info.message} ({resp_message})'
+            raise VesyncLoginError(
+                f"Error receiving response to login request - {error_info.message}"
+            )
+        except (MissingField, UnserializableDataError) as exc:
+            logger.debug('Error parsing login response: %s', exc)
+            raise VeSyncAPIResponseError(
+                'Error receiving response to login request'
+            ) from exc
 
     async def update(self) -> None:
         """Fetch updated information about devices and new device list.
@@ -378,11 +473,11 @@ class VeSync:  # pylint: disable=function-redefined
     ) -> tuple[dict | None, int | None]:
         """Make API calls by passing endpoint, header and body.
 
-        api argument is appended to https://smartapi.vesync.com url.
+        api argument is appended to `API_BASE_URL`.
         Raises VeSyncRateLimitError if API returns a rate limit error.
 
         Args:
-            api (str): Endpoint to call with https://smartapi.vesync.com.
+            api (str): Endpoint to call with `API_BASE_URL`.
             method (str): HTTP method to use.
             json_object (dict | RequestBaseModel): JSON object to send in body.
             headers (dict): Headers to send with request.
@@ -416,7 +511,7 @@ class VeSync:  # pylint: disable=function-redefined
         try:
             async with self.session.request(
                 method,
-                url=API_BASE_URL + api,
+                url=self._api_base_url_for_current_region() + api,
                 json=req_dict,
                 headers=headers,
                 raise_for_status=False,
@@ -447,6 +542,19 @@ class VeSync:  # pylint: disable=function-redefined
             LibraryLogger.log_api_exception(logger, exception=e, request_body=req_dict)
             raise
 
+    def _api_base_url_for_current_region(self) -> str:
+        """Retrieve the API base url for the current region.
+
+        At this point, only two different URLs exist: One for `EU` region
+        (for all EU countries), and one for all others
+        (currently `US`, `CA`, `MX`, `JP` - also used as a fallback).
+
+        If `API_BASE_URL` is set, it will take precedence over the determined URL.
+        """
+        if self.country_code in NON_EU_REGIONS:
+            return API_BASE_URL_US
+        return API_BASE_URL_EU
+
     def _update_fw_version(self, info_list: list[FirmwareDeviceItemModel]) -> bool:
         """Update device firmware versions from API response."""
         if not info_list:

{pyvesync-3.0.0b2 → pyvesync-3.0.0b3/src/pyvesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvesync
-Version: 3.0.0b2
+Version: 3.0.0b3
 Summary: pyvesync is a library to manage Etekcity Devices, Cosori Air Fryers, and Levoit Air Purifiers run on the VeSync app.
 Author: Mark Perdue
 Author-email: Joe Trabulsy <webdjoe@gmail.com>