tinge/tinge/HueLight/__init__.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
from datetime import datetime

import requests

from ..HueUtils import make_request


class HueLight:
    class State:
        def __init__(self, data_slice: dict):
            keys = data_slice.keys()
            self.m_on: bool = data_slice['on']
            if 'bri' in keys:
                self.m_bri: int = data_slice['bri']
            else:
                self.m_bri: int = 0
            if 'ct' in keys:
                self.m_ct: int = data_slice['ct']
            else:
                self.m_ct: int = 0
            self.m_alert: str = data_slice['alert']
            if 'colormode' in keys:
                self.m_colormode: str = data_slice['colormode']
            else:
                self.m_colormode: str = ""
            self.m_mode: str = data_slice['mode']
            self.m_reachable: bool = data_slice['reachable']

        def is_on(self) -> bool:
            return self.m_on

        def is_reachable(self) -> bool:
            return self.m_reachable

    class SwUpdate:
        def __init__(self, data_slice: dict):
            self.m_state: str = data_slice['state']
            self.m_lastinstall: datetime = datetime.strptime(data_slice['lastinstall'], "%Y-%m-%dT%H:%M:%S")

    class Capabilites:
        class Control:
            class ColorTemp:
                def __init__(self, data_slice: dict):
                    keys = data_slice.keys()
                    if 'min' in keys:
                        self.m_min: int = data_slice['min']
                    else:
                        self.m_min: int = 0
                    if 'max' in keys:
                        self.m_max: int = data_slice['max']
                    else:
                        self.m_max: int = 0

            def __init__(self, data_slice: dict):
                keys = data_slice.keys()
                if 'mindimlevel' in keys:
                    self.m_mindimlevel: int = data_slice['mindimlevel']
                else:
                    self.m_mindimlevel: int = 0
                if 'maxlumen' in keys:
                    self.m_maxlumen: int = data_slice['maxlumen']
                else:
                    self.m_maxlumen: int = 0
                if 'ct' in data_slice.keys():
                    self.m_ct = HueLight.Capabilites.Control.ColorTemp(data_slice['ct'])
                else:
                    self.m_ct = HueLight.Capabilites.Control.ColorTemp({})

        class Streaming:
            def __init__(self, data_slice: dict):
                self.m_renderer: bool = data_slice['renderer']
                self.m_proxy: bool = data_slice['proxy']

        def __init__(self, data_slice: dict):
            self.m_certified: bool = data_slice['certified']
            self.m_control = HueLight.Capabilites.Control(data_slice['control'])
            self.m_streaming = HueLight.Capabilites.Streaming(data_slice['streaming'])

    class Config:
        class Startup:
            def __init__(self, data_slice: dict):
                self.m_mode: str = data_slice['mode']
                self.m_configured: bool = data_slice['configured']

        def __init__(self, data_slice: dict):
            self.m_archetype: str = data_slice['archetype']
            self.m_function: str = data_slice['function']
            self.m_direction: str = data_slice['direction']
            self.m_startup = HueLight.Config.Startup(data_slice['startup'])

    def __init__(self, id: int, data: dict, parent_bridge_ip: str, parent_bridge_user: str):
        self.m_id: int = id
        self.m_parent_bridge_ip = parent_bridge_ip
        self.m_parent_bridge_user = parent_bridge_user
        self.m_state = HueLight.State(data['state'])
        self.m_swupdate = HueLight.SwUpdate(data['swupdate'])
        self.m_type: str = data['type']
        self.m_name: str = data['name']
        self.m_modelid: str = data['modelid']
        self.m_manufacturername: str = data['manufacturername']
        self.m_productname: str = data['productname']
        self.m_capabilites = HueLight.Capabilites(data['capabilities'])
        self.m_config = HueLight.Config(data['config'])
        self.m_uniqueid: str = data['uniqueid']
        self.m_swconfigid: str = data['swconfigid']
        self.m_productid: str = data['productid']

    def __str__(self) -> str:
        return self.m_name

    def get_state(self):
        return self.m_state

    def get_id(self):
        return self.m_id

    def is_on(self) -> bool:
        return self.get_state().is_on()

    def is_reachable(self) -> bool:
        return self.get_state().is_reachable()

    def set_state(self, state: str) -> requests.Response:
        path: str = "{}/lights/{}/state".format(self.m_parent_bridge_user, self.m_id)
        method: str = "PUT"
        response = make_request(self.m_parent_bridge_ip, path, method, state)
        self.update_state()
        return response

    def toggle(self):
        if self.is_reachable():
            state: str = '{"on":true}'
            if self.is_on():
                state = '{"on":false}'
            self.set_state(state)

    def update_state(self):
        path: str = "{}/lights/{}".format(self.m_parent_bridge_user, self.m_id)
        response = make_request(self.m_parent_bridge_ip, path)
        self.m_state = HueLight.State(json.loads(response.text)['state'])