pycync 0.1.0__py3-none-any.whl

pycync/__init__.py

@@ -0,0 +1,3 @@
+from pycync.auth import Auth, User
+from pycync.cync import Cync
+from pycync.devices import CyncDevice, CyncLight, CyncRoom, CyncGroup, CyncHome

pycync/auth.py

@@ -0,0 +1,166 @@
+"""
+Contains auth information about an authenticated user, and performs generic REST API calls for the user.
+"""
+import time
+from asyncio import TimeoutError
+from json import dumps
+from typing import Any
+
+from aiohttp import ClientSession, ClientResponseError
+
+from .const import GE_CORP_ID, REST_API_BASE_URL
+from .user import User
+from .exceptions import BadRequestError, TwoFactorRequiredError, AuthFailedError, CyncError
+
+
+class Auth:
+    def __init__(self, session: ClientSession, user: User = None, username: str = None, password: str = None) -> None:
+        """Initialize the auth."""
+        self._session = session
+        self._user = user
+        self._username = username
+        self._password = password
+
+    @property
+    def user(self):
+        return self._user
+
+    @property
+    def session(self):
+        return self._session
+
+    @property
+    def username(self):
+        return self._username
+
+    @property
+    def password(self):
+        return self._password
+
+    async def login(self, two_factor_code: str = None) -> User:
+        """
+        Attempts to log in with the configured user information.
+
+        If a two factor code is not provided, and the server requests a two factor code, a TwoFactorRequiredError
+        will be raised, and at the same time a two factor code will be sent to the user's email.
+        This function can then be called again with the two factor code provided to authenticate with the code.
+        """
+        if two_factor_code is None:
+            try:
+                user_info = await self._async_auth_user()
+                self._user = User(user_info["access_token"], user_info["refresh_token"], user_info["authorize"],
+                                  user_info["user_id"], expire_in=user_info["expire_in"])
+                return self._user
+            except TwoFactorRequiredError:
+                two_factor_request = {'corp_id': GE_CORP_ID, 'email': self.username, 'local_lang': "en-us"}
+
+                await self._send_user_request(url=f'{REST_API_BASE_URL}/v2/two_factor/email/verifycode', method="POST",
+                                              json=two_factor_request)
+                raise TwoFactorRequiredError('Two factor verification required. Code sent to user email.')
+        else:
+            user_info = await self._async_auth_user_two_factor(two_factor_code)
+            self._user = User(user_info["access_token"], user_info["refresh_token"], user_info["authorize"],
+                              user_info["user_id"], expire_in=user_info["expire_in"])
+            return self._user
+
+    async def _async_auth_user(self):
+        """Attempt to authenticate user without a two factor code."""
+        auth_data = {'corp_id': GE_CORP_ID, 'email': self.username, 'password': self.password}
+
+        try:
+            auth_response = await self._send_user_request(url=f'{REST_API_BASE_URL}/v2/user_auth', method="POST",
+                                                          json=auth_data)
+            return auth_response
+        except BadRequestError:
+            raise TwoFactorRequiredError("Two factor verification required.")
+
+    async def _async_auth_user_two_factor(self, two_factor_code: str):
+        """Attempt to authenticate user with a two factor code."""
+        two_factor_request = {'corp_id': GE_CORP_ID, 'email': self.username, 'password': self.password,
+                              'two_factor': two_factor_code, 'resource': 1}
+
+        try:
+            auth_response = await self._send_user_request(url=f'{REST_API_BASE_URL}/v2/user_auth/two_factor',
+                                                          method="POST", json=two_factor_request)
+            return auth_response
+        except BadRequestError as ex:
+            raise AuthFailedError("Invalid two-factor code") from ex
+
+    async def async_refresh_user_token(self):
+        """
+        Refresh the user's session token. If the token has already expired, a new login will be required.
+        (Likely also requiring a new two factor code to be provided.)
+        """
+        refresh_request = {'refresh_token': self._user.refresh_token}
+
+        try:
+            body = dumps(refresh_request)
+
+            resp = await self.session.request(method="POST", url=f'{REST_API_BASE_URL}/v2/user/token/refresh',
+                                              data=body)
+            if resp.status != 200:
+                raise AuthFailedError('Refresh token failed')
+
+            auth_response = await resp.json()
+
+            self._user.set_new_access_token(auth_response["access_token"], auth_response["refresh_token"],
+                                            auth_response["expire_in"])
+        except Exception as ex:
+            raise AuthFailedError(ex)
+
+    async def _send_user_request(
+            self,
+            url: str,
+            method: str = "GET",
+            json: dict[Any, Any] | None = None,
+            raise_for_status: bool = True,
+    ) -> dict:
+        """Send an HTTP request with the provided parameters."""
+        headers = {}
+        if self.user:
+            if self.user.expires_at - time.time() < 3600:
+                await self.async_refresh_user_token()
+            headers["Access-Token"] = self.user.access_token
+
+        try:
+            if json:
+                body = dumps(json)
+
+                resp = await self.session.request(method, url, headers=headers, data=body)
+            else:
+                resp = await self.session.request(method, url, headers=headers)
+
+        except TimeoutError as ex:
+            msg = f"Timeout error during query of url {url}: {ex}"
+            raise CyncError(msg) from ex
+        except Exception as ex:
+            msg = f"Unknown error during query of url {url}: {ex}"
+            raise CyncError(msg) from ex
+
+        async with resp:
+            if resp.status == 400:
+                raise BadRequestError("Bad Request")
+
+            if resp.status == 401 or resp.status == 403:
+                await self.async_refresh_user_token()
+
+                headers["Access-Token"] = self.user.access_token
+
+                if json:
+                    body = dumps(json)
+
+                    resp = await self.session.request(method, url, headers=headers, data=body)
+                else:
+                    resp = await self.session.request(method, url, headers=headers)
+
+            if raise_for_status:
+                try:
+                    resp.raise_for_status()
+                except ClientResponseError as ex:
+                    msg = (
+                        f"HTTP error with status code {resp.status} "
+                        f"during query of url {url}: {ex}"
+                    )
+                    raise CyncError(msg) from ex
+
+            return await resp.json()

pycync/const.py

@@ -0,0 +1,5 @@
+"""Constants for the API."""
+
+GE_CORP_ID = "1007d2ad150c4000"
+
+REST_API_BASE_URL = "https://api.gelighting.com"

pycync/cync.py

@@ -0,0 +1,117 @@
+"""
+The main API interface for the Cync library.
+Each instance of this class corresponds to one user, and all devices/homes associated with that user.
+"""
+
+import asyncio
+from typing import Callable
+
+from .auth import Auth
+from .devices import create_device, CyncDevice, device_storage
+from .exceptions import MissingAuthError
+from .const import REST_API_BASE_URL
+from pycync.devices.groups import CyncRoom, CyncGroup, CyncHome
+from pycync.tcp.command_client import CommandClient
+
+
+class Cync:
+    def __init__(self, auth: Auth):
+        """
+        Initialize a Cync object.
+        The static create function should be used to create a new Cync object.
+        """
+        if not auth.user:
+            raise MissingAuthError("No logged in user exists on auth object.")
+        self._auth = auth
+        self._command_client = CommandClient(auth.user)
+
+    @classmethod
+    async def create(cls, auth: Auth):
+        cync_api = Cync(auth)
+
+        await cync_api.refresh_home_info()
+        cync_api._command_client.start_connection()
+
+        return cync_api
+
+    def get_logged_in_user(self):
+        """Get logged in user."""
+
+        return self._auth.user
+
+    async def refresh_credentials(self):
+        """Refresh user credentials."""
+        await self._auth.async_refresh_user_token()
+        return self.get_logged_in_user()
+
+    def set_update_callback(self, update_callback: Callable):
+        """
+        Set the callback function that will be called when a device's state changes,
+        or when a poll request for device state receives a response.
+        """
+        device_storage.set_user_device_callback(self._auth.user.user_id, update_callback)
+
+    def update_device_states(self):
+        """Query the server for current device states, and update the devices."""
+        asyncio.create_task(self._command_client.update_mesh_devices())
+
+    def get_devices(self):
+        """Get a flat list of devices associated with this user."""
+        return device_storage.get_flattened_devices(self._auth.user.user_id)
+
+    def get_homes(self):
+        """Get all homes, devices, and groups for the account."""
+        return device_storage.get_user_homes(self._auth.user.user_id)
+
+    async def refresh_home_info(self):
+        """Refresh all nested home information for this account, and update the device storage.."""
+        device_info = await self._auth._send_user_request(
+            f"{REST_API_BASE_URL}/v2/user/{self._auth.user.user_id}/subscribe/devices")
+        home_entries = [device for device in device_info if device["source"] == 5]
+        homes = []
+
+        for home_json in home_entries:
+            home_devices: list[CyncDevice] = []
+            rooms: list[CyncRoom] = []
+            groups: list[CyncGroup] = []
+            home: CyncHome = CyncHome(home_json["name"], home_json["id"], [], [])
+
+            mesh_device_info = await self._auth._send_user_request(
+                f"{REST_API_BASE_URL}/v2/product/{home_json["product_id"]}/device/{home_json["id"]}/property")
+            if "bulbsArray" in mesh_device_info:
+                mesh_devices = mesh_device_info["bulbsArray"]
+                for mesh_device in mesh_devices:
+                    matching_device = next(device for device in device_info if device["id"] == mesh_device["switchID"])
+                    created_device = create_device(matching_device, mesh_device, home, self._command_client)
+
+                    home_devices.append(created_device)
+
+            room_json = []
+            group_json = []
+            if "groupsArray" in mesh_device_info:
+                room_json = [group for group in mesh_device_info["groupsArray"] if group["isSubgroup"] == False]
+                group_json = [group for group in mesh_device_info["groupsArray"] if group["isSubgroup"] == True]
+
+            for group in group_json:
+                group_devices = [device for device in home_devices if
+                                 device.isolated_mesh_id in group.get("deviceIDArray", [])]
+                groups.append(
+                    CyncGroup(group["displayName"], group["groupID"], home, group_devices, self._command_client))
+                home_devices = [device for device in home_devices if device not in group_devices]
+
+            for room in room_json:
+                room_devices = [device for device in home_devices if device.isolated_mesh_id in room["deviceIDArray"]]
+                room_groups = [group for group in groups if group.group_id in room.get("subgroupIDArray", [])]
+                rooms.append(CyncRoom(room["displayName"], room["groupID"], home, room_groups, room_devices,
+                                      self._command_client))
+                home_devices = [device for device in home_devices if device not in room_devices]
+
+            home.global_devices = home_devices
+            home.rooms = rooms
+            homes.append(home)
+
+        device_storage.set_user_homes(self._auth.user.user_id, homes)
+
+    def shut_down(self):
+        """Shut down the command client instance and close its associated connections."""
+        self._command_client.shut_down()

pycync/devices/__init__.py

@@ -0,0 +1,2 @@
+from .devices import CyncControllable, CyncDevice, CyncLight, create_device
+from .groups import CyncHome, CyncGroup, CyncRoom