def get_bridgeinfo(self):
if self.bridge.get('serialNumber', '') == '':
self.br = None
self.bridge_lights = {}
self.bridge_groups = {}
self.bridge_config = {}
self.bridge_scenes = {}
self.bridge_sensors = {}
return
self.logger.info("get_bridgeinfo: self.bridge = {}".format(
self.bridge))
self.br = qhue.Bridge(
self.bridge['ip'] + ':' + str(self.bridge['port']),
self.bridge['username'])
try:
self.bridge_lights = self.br.lights()
self.bridge_groups = self.br.groups()
self.bridge_config = self.br.config()
self.bridge_scenes = self.br.scenes()
self.bridge_sensors = self.br.sensors()
except Exception as e:
self.logger.error(
f"Bridge '{self.bridge.get('serialNumber','')}' returned exception {e}"
)
self.br = None
self.bridge_lights = {}
self.bridge_groups = {}
self.bridge_config = {}
self.bridge_scenes = {}
self.bridge_sensors = {}
return False
return True
def _check_bridge_model(self):
bridge = qhue.Bridge(self.bridge_ip, None, timeout=QHUE_TIMEOUT)
try:
bridge_config = bridge.config()
model = bridge_config["modelid"]
except QhueException as exc:
xbmc.log(
f"[script.service.hue] Exception: checkBridgeModel {exc.type_id}: {exc.message} {traceback.format_exc()}"
)
reporting.process_exception(exc)
return None
except requests.RequestException as exc:
xbmc.log(f"[script.service.hue] Requests exception: {exc}")
notification(header=_("Hue Service"),
message=_(f"Connection Error"),
icon=xbmcgui.NOTIFICATION_ERROR)
if model == "BSB002":
xbmc.log(f"[script.service.hue] Bridge model OK: {model}")
return True
xbmc.log(f"[script.service.hue] Unsupported bridge model: {model}")
xbmcgui.Dialog().ok(
_("Unsupported Hue Bridge"),
_("Hue Bridge V1 (Round) is unsupported. Hue Bridge V2 (Square) is required."
))
return None
def get_target(args):
if not args.hue_username and args.hue:
print("Need to create the username")
from qhue import create_new_username
username = create_new_username(args.hue)
print("Add '--hue-username %s' to the command line and restart" %
username)
sys.exit(0)
print("Will control Philips Hue @ %s" % args.hue)
b = qhue.Bridge(args.hue, args.hue_username)
lights = list(map(int, args.hue_lights.split(',')))
def set_lights(state):
if state == "blue":
hue = 46920
elif state == "green":
hue = 25500
elif state == "mix":
hue = (46920 + 25500) // 2
else:
hue = 0
for light in lights:
b.lights[light].state(bri=127, hue=hue)
for light in lights:
b.lights[light].state(bri=255, hue=hue)
return set_lights
def __init__(self, ip: str, user: str, main_light: int, lights: list, tradfri: 'Tradfri' = None):
"""
Parameters
----------
ip : str
Address of Hue Bridge. DNS will be resolved.
user : str
The secret string generated when pairing with the Bridge.
main_lights : int
The light we want to watch and copy changes from.
lights : list
A list of IDs of Hue lights, which should be controlled.
tradfri : Tradfri
The Tradfri instance we are controlling with the main light.
"""
super().__init__(ip, user, main_light, lights)
self.bridge = qhue.Bridge(ip, user)
self.hue = None
self.bri = None
self.sat = None
self.state = None
self.tradfri = tradfri
def __init__(self, lampname):
self.name = lampname
self.bridge = qhue.Bridge(ip, username)
self.lampid = get_lamp_id_by_name(self.bridge, lampname)
self.url = self.bridge.lights[self.lampid].url + '/state'
self.on = self.bridge.lights[self.lampid]()['state']['on']
self.xy = self.bridge.lights[self.lampid]()['state']['xy']
self.brightnessPercent = self.bridge.lights[self.lampid]()['state']['bri'] / 255.0
def api_create_user(self, devicetype):
import qhue
qb = qhue.Bridge(self.url.hostname, None)
try:
api_response = qb(devicetype=devicetype, http_method="post")
except qhue.QhueException:
# fake the response until we add exception handling in base
api_response = [{"error": {"type": 101}}]
return api_response
def page_light(self, turn_on):
"""Turn a light used to indicate a page either on or off."""
(bridge_ip, bridge_code) = self.get_bridge_info()
bridge = qhue.Bridge(bridge_ip, bridge_code)
for lid in PAGE_LIGHT:
if turn_on:
self.set_light_by_hsl(bridge, lid, (255, 1, 1), 10)
else:
self.turn_light_off(bridge, lid, 10)
def set_scene(scene_name):
bridge = qhue.Bridge(get_bridge_address(), settings.HUELIGHTS_USERNAME)
if scene_name not in _cached_scene_names_to_ids:
for scene_id, scene_info in bridge.scenes().items():
_cached_scene_names_to_ids[scene_info["name"]] = scene_id
if scene_name not in _cached_scene_names_to_ids:
raise RuntimeError("Invalid scene name")
bridge.groups[0].action(scene=_cached_scene_names_to_ids[scene_name])
def __init__(self, lamp_id):
# not accessible
ip = HUE_IP
username = HUE_USERNAME
# accessible
self.bridge = qhue.Bridge(ip, username)
self.getter = self.bridge.lights[lamp_id]()
self.setter = self.bridge.lights[lamp_id]
self.is_on = self.getter['state']['on']
self.colour = self.getter['state']['xy']
self.name = self.getter['name']
def get_light(profile, args):
ip, username = profile.ip, profile.username
bridge = qhue.Bridge(ip, username)
#get the light from a specified name
if args.name != "":
name = args.name
light = list(
filter(lambda l: profile.lights[l] == args.name, profile.lights))
#find a light id with that name
if light == []: #no matches
print(
f"Couldn't find a light with the name {args.name} in this profile"
)
return
else:
#once the id has been retrieved it can be extracted the same way as below
id = light[0]
light = list(
filter(lambda l: bridge.lights()[l]["uniqueid"] == id,
bridge.lights()))
if light != []:
#if a match was found with the specified id
light = bridge.lights[light[0]]
else:
#this will probably only happen if a bridge was removed from a network (was setup) and the program is still trying to access it
print(
f"Couldn't find a light with the id, {id} associated with {args.name}"
)
return
#get the light from a specified id
elif args.id != "":
id = args.id
#try and get the name of the light if it is in the bridge profile, otherwise just leave it as "N/A"
try:
name = profile.lights[id]
except:
name = "N/A"
light = list(
filter(lambda l: bridge.lights()[l]["uniqueid"] == args.id,
bridge.lights()))
#find a light with
if light != []:
light = bridge.lights[light[0]]
else:
print(f"Couldn't find a light with the id, {args.id}")
return
else:
#if the name nor id were specified, throw an error to say that one of the two are required
print(
"Either the parameter -name or -id are required for the --change command"
)
return
return light, name, id
def connect_bridge(self, silent=False):
xbmc.log(
f"[script.service.hue] in connect_bridge() with settings: bridgeIP: {self.bridge_ip}, bridgeUser: {self.bridge_user}"
)
if self.bridge_ip and self.bridge_user:
if not self._check_version():
xbmc.log(
"[script.service.hue] in connect_bridge(): Bridge not responding to connection test, attempt finding a new bridge IP."
)
if self._discover_bridge_ip():
xbmc.log(
f"[script.service.hue] in connect_bridge(): New IP found: {self.bridge_ip}. Saving"
)
ADDON.setSettingString("bridgeIP", self.bridge_ip)
else:
xbmc.log("[script.service.hue] Bridge not found")
notification(_("Hue Service"),
_("Bridge connection failed"),
icon=xbmcgui.NOTIFICATION_ERROR)
self.connected = False
return
xbmc.log("[script.service.hue] in Connect(): Checking User")
if self._check_user():
bridge = qhue.Bridge(self.bridge_ip,
self.bridge_user,
timeout=QHUE_TIMEOUT)
self.connected = True
self.bridge = bridge
xbmc.log(
f"[script.service.hue] Successfully connected to Hue Bridge: {self.bridge_ip}"
)
if not silent:
notification(_("Hue Service"),
_("Hue connected"),
sound=False)
return
else:
xbmc.log("[script.service.hue] Bridge not responding")
notification(_("Hue Service"),
_("Bridge connection failed"),
icon=xbmcgui.NOTIFICATION_ERROR)
self.connected = False
else:
xbmc.log("[script.service.hue] Bridge not configured")
notification(_("Hue Service"),
_("Bridge not configured"),
icon=xbmcgui.NOTIFICATION_ERROR)
self.connected = False
def main():
"""The main function."""
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument('--config',
default=str(Path.home() / '.philipshue.ini'),
help='the config file location')
args = ap.parse_args()
while True:
try:
cp = configparser.ConfigParser()
cp.read(args.config)
cf = cp['DEFAULT']
bridge_location = cf['bridge_location']
bridge_username = cf['bridge_username']
except KeyError:
setup(args.config)
continue
break
print(f'Connecting to {bridge_location}...')
try:
bridge = qhue.Bridge(bridge_location, bridge_username)
num_lights = len(bridge.lights())
print(f'Connected to {bridge_location}. {num_lights} lights found.')
except requests.ConnectionError as err:
print(f'{sgr(1, 31)}{err.__class__.__name__}{sgr(0)}: {err}')
sys.exit(1)
session = PromptSession(
'> ',
lexer=PygmentsLexer(Python3Lexer),
style=style_from_pygments_cls(PYGMENTS_STYLE),
auto_suggest=AutoSuggestFromHistory(),
input_processors=[HighlightMatchingBracketProcessor('()[]{}')],
history=FileHistory(Path.home() / '.philipshue.hist'))
while True:
try:
cmd = session.prompt()
start = time.perf_counter()
out = exec_cmd(cmd, bridge=bridge)
time_taken = time.perf_counter() - start
prettyprinter.cpprint(out)
print(f'Time taken: {sgr(1, 34)}{time_taken*1000:.3f} ms{sgr(0)}')
except KeyboardInterrupt:
pass
except EOFError:
break
except requests.ConnectionError as err:
print(f'{sgr(1, 31)}{err.__class__.__name__}{sgr(0)}: {err}')
sys.exit(1)
except Exception as err:
print(f'{sgr(1, 31)}{err.__class__.__name__}{sgr(0)}: {err}')
def __init__(self, host=None, user=None):
self.enabled = (not host is None)
if not (host and user):
self.hue_bridge = None
return None
self.check_import()
import qhue
try:
self.hue_bridge = qhue.Bridge(host, user)
except:
IkaUtils.dprint('%s: Exception.' % self)
IkaUtils.dprint(traceback.format_exc())
def _check_user(self):
xbmc.log(
"[script.service.hue] in user_test() Attempt initial connection")
b = qhue.Bridge(self.bridge_ip, self.bridge_user, timeout=QHUE_TIMEOUT)
try:
zigbee = b.config()['zigbeechannel']
except (requests.RequestException, qhue.QhueException, KeyError):
return False
if zigbee:
xbmc.log(
f"[script.service.hue] Hue User Authorized. Bridge Zigbee Channel: {zigbee}"
)
return True
return False
def get_bridgeinfo(self):
if self.bridge.get('serialNumber', '') == '':
self.br = None
self.bridge_lights = {}
self.bridge_groups = {}
self.bridge_config = {}
self.bridge_scenes = {}
self.bridge_sensors = {}
return
self.logger.info("get_bridgeinfo: self.bridge = {}".format(
self.bridge))
self.br = qhue.Bridge(self.bridge['ip'], self.bridge['username'])
self.bridge_lights = self.br.lights()
self.bridge_groups = self.br.groups()
self.bridge_config = self.br.config()
self.bridge_scenes = self.br.scenes()
self.bridge_sensors = self.br.sensors()
return
def quickstart():
if not os.path.exists(_uname_file_location):
username = qhue.create_new_username(_bridge_ip)
with open(_uname_file_location, 'w') as f:
f.write(username)
else:
with open(_uname_file_location, 'r') as f:
username = f.read()
b = qhue.Bridge(_bridge_ip, username)
lights = b.lights
return b, lights
def _check_version(self):
b = qhue.Bridge(self.bridge_ip, None, timeout=QHUE_TIMEOUT)
try:
api_version = b.config()['apiversion']
except QhueException as error:
xbmc.log(
f"[script.service.hue] Version check connection failed. {error.type_id}: {error.message} {traceback.format_exc()}"
)
reporting.process_exception(error)
return False
except requests.RequestException as error:
xbmc.log(
f"[script.service.hue] Version check connection failed. {error}"
)
return False
except KeyError as error:
notification(_("Hue Service"),
_("Bridge outdated. Please update your bridge."),
icon=xbmcgui.NOTIFICATION_ERROR)
xbmc.log(
f"[script.service.hue] in _version_check(): Connected! Bridge too old: {api_version}, error: {error}"
)
return False
api_split = api_version.split(".")
if api_version and int(api_split[0]) >= 1 and int(
api_split[1]) >= 38: # minimum bridge version 1.38
xbmc.log(
f"[script.service.hue] Bridge Found! Hue API version: {api_version}"
)
return True
notification(_("Hue Service"),
_("Bridge outdated. Please update your bridge."),
icon=xbmcgui.NOTIFICATION_ERROR)
xbmc.log(
f"[script.service.hue] in _connection_test(): Connected! Bridge too old: {api_version}"
)
return False
def main():
"""
main
"""
hue_bridge = qhue.Bridge(os.environ.get('HUE_BRIDGE'),
os.environ.get('HUE_USERNAME'))
if not hue_bridge:
print("Oops")
sys.exit(1)
sensors = hue_bridge.sensors
for _, sensor in sensors().items():
if sensor.get('type') == 'ZLLSwitch':
__memory__[sensor['uniqueid']] = sensor['state']['lastupdated']
print("Started")
sleep_time = os.environ.get('SLEEP_TIME', 0.3)
while True:
try:
for _, sensor in sensors().items():
if sensor.get('type') == 'ZLLSwitch':
check_change((sensor))
time.sleep(sleep_time)
except KeyboardInterrupt:
clean_exit(False, False)
break
if os.path.exists(config_path):
with open(config_path, "r") as f:
hue_username = f.read()
else:
while True:
try:
hue_username = qhue.create_new_username(HUE_BRIDGE_IP)
break
except qhue.QhueException as err:
print(
"Error occurred while creating a new username: {}".format(err))
with open(config_path, "w") as f:
f.write(hue_username)
hue = qhue.Bridge(HUE_BRIDGE_IP, hue_username)
all_light_group = hue.groups[0]
light_group = hue.groups[1]
ceiling_group = hue.groups[2]
# Open the input device
dev = evdev.InputDevice(INPUT_DEVICE)
# Grab exclusive access to all events so gnome doesn't throw a fit
with dev.grab_context():
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
key_event = KeyEvent(event)
if key_event.keystate == KeyEvent.key_up:
def reset_light_brightness(light_states, light_brightness, id):
if light_states[id] == LightStatesEnum.JUST_TURNED_ON:
previous_brightness = light_brightness[id]
lights[id].state(bri=previous_brightness)
light_states[id] = LightStatesEnum.ON
log.info("Just reset brightness of %s to: %d" % (getName(id), previous_brightness))
def reset_all_light_brightnesses(light_states, light_brightness):
for light in light_states:
reset_light_brightness(light_states, light_brightness, light)
if __name__ == "__main__":
b = qhue.Bridge(credentials.BRIDGE_IP, credentials.USERNAME)
lights = b.lights
light_states = {}
for light in lights():
light_states[light] = LightStatesEnum.UNKNOWN
light_brightness = {}
for light in lights():
light_brightness[light] = -1
while True:
try:
snapShot = lights()
update_light_states(light_states, light_brightness, snapShot)
reset_all_light_brightnesses(light_states, light_brightness)
except IOError:
logPrint("Could not find configuration file!", 40)
sys.exit("Aborting ...")
else:
with stream:
try:
config = yaml.safe_load(stream)
logPrint("Configuration file loaded successfully.", 20)
except yaml.YAMLError as yaml_error:
logPrint(
"A YAML error was raised while reading the configuration file: "
+ str(yaml_error), 40)
sys.exit("Aborting ...")
"Initialising Hue bridge object from Qhue"
hue_bridge = qhue.Bridge(config["hue"]["ip"], config["hue"]["key"])
"Load Hue groups"
try:
hue_groups = hue_bridge.groups
except qhue.QhueException as error:
logPrint("Hue related error thrown: " + str(error) + ".", 40)
sys.exit("Aborting ...")
"Get Chromecast device"
cast = get_ccast()
logPrint("Got Chromecast: " + str(cast.device), 20)
sleep(1)
while True:
if ccast_active(cast):
#!/usr/bin/env python2 # # Turn all lights off # import qhue CONFIG_FILE = "config" execfile(CONFIG_FILE) b = qhue.Bridge(HUE_BRIDGE_IP, HUE_USERNAME) b.groups['0'].action(on=False)
from __future__ import division
from flask import render_template
from flask import request
from hue import app
import json
import qhue
bridge = qhue.Bridge(app.config["bridge_ip"], app.config["bridge_user"])
@app.route("/state", methods=["POST"])
def change_light_state():
form = request.get_json()
bridge.lights[form["light"]].state(on=form["state"])
return "", 200
@app.route("/light/<light>", methods=["GET"])
def get_light_state(light):
return json.dumps(bridge.lights[light]())
@app.route("/light_test/<light>", methods=["GET"])
def get_light_state_test(light):
color_light = dict(
type="Extended color light",
name="Hue color light 1",
state={"reachable": True,
"on": True})
return json.dumps(color_light)
def main():
global currentIp
parser = argparse.ArgumentParser(
description=
"A little CLI program to control my lights more easily (v1.1)")
#Command Options
parser.add_argument("--setup",
action="store_true",
help="Automatically setup a hue bridge")
parser.add_argument(
"--change",
action="store_true",
help="Used to change the brightness/colour/state of a given light")
parser.add_argument(
"--rename",
action="store_true",
help="Rename a light to make it more easily accessible")
parser.add_argument(
"--lights",
action="store_true",
help="List all available lights connected to a hue bridge")
parser.add_argument(
"--switch",
action="store_true",
help="Switch between different profiles for different hue bridge IPs")
parser.add_argument("--ips",
action="store_true",
help="List all bridge IPs on your network")
parser.add_argument("--info",
action="store_true",
help="Get all the infomation about a light")
parser.add_argument(
"--addscene",
action="store_true",
help="Creates a scene for a given light based with its current settings"
)
parser.add_argument("--scenes",
action="store_true",
help="List all the scenes")
parser.add_argument("--delscene",
action="store_true",
help="Delete a scene")
parser.add_argument("--overide",
action="store_true",
help="Delete a scene")
#Parameters
parser.add_argument("-scene", type=str, default="")
parser.add_argument("-name", type=str, default="")
parser.add_argument("-id", type=str, default="")
parser.add_argument("-ip", type=str, default="")
parser.add_argument("-bri", type=int, default=None)
parser.add_argument("-hue", type=int, default=None)
parser.add_argument("-sat", type=int, default=None)
parser.add_argument("-on", action="store_true")
parser.add_argument("-off", action="store_true")
args = parser.parse_args()
args.name = args.name.strip()
args.id = args.id.strip()
args.ip = args.ip.strip()
try:
try:
profile = profiles[str(currentIp)]
ip, username = profile.ip, profile.username
bridge = qhue.Bridge(ip, username)
except Exception as e:
if not args.setup:
print("Please run hue --setup to get started")
#setup a bridge profile so it can be referrenced in other commands
if args.setup:
#required arguments
if args.name == "":
print("-name is a required parameter of the --setup command")
return
print("Retrieving Hue Bridge ip:\n")
#get a list of bridge ips on the users network
response = requests.get("https://discovery.meethue.com/")
response.raise_for_status()
if args.ip:
ip = args.ip
#if the user explicitly chooses a bridge ip to connect to, it must be validated to make sure it exists on the network
if not ip in [
bridge["internalipaddress"]
for bridge in ast.literal_eval(response.text)
]:
print("The provided ip could not be found on your network")
return
else:
try:
#if one wasn't explicitly specified, it should just choose to setup with the first one it finds (most people will only have one bridge anyway)
ip = ast.literal_eval(
response.text)[0]["internalipaddress"]
except:
#if no bridge ips could be found
print("Couldn't find a hue bridge on your network :(")
return
print("IP:", ip, "\n")
print(
"Press the pair button on the hue bridge to complete the connection process\n"
)
#pair the bridge with the program
try:
username = qhue.create_new_username(ip, None, 60, 120)
except qhue.QhueException:
print("2 minute time limit exceeded")
raise KeyboardInterrupt()
print("Username:"******"\n")
lights = {}
bridge = qhue.Bridge(ip, username)
#turn on all the lights so they can be dimmed one by one and the user can work out which light is which
for light in bridge.lights():
light = bridge.lights[light]
try:
light.state(on=True)
light.state(bri=255)
except:
pass
input(
"Turn on all of your lights so they can be identified and then press enter\n"
)
for light in bridge.lights():
light = bridge.lights[light]
if light()["state"]["on"]:
try:
light.state(bri=122)
except:
light.state(on=False)
#names are assaigned to each light to make it easier for the user to change them later on
name = input(
"Enter a name for the light I just turned off:\n"
).strip()
while name in lights.values() or name == "":
name = input(
"That is not a valid name for the light:\n").strip(
)
lights[str(light()["uniqueid"])] = name
else:
#tell the user that one of the lights couldn't be setup as it was turned off and can't be identified
print(
f"Light {light()['uniqueid']} was off and thus cannot be identified. You can specify a name for it manually with hue -rn -id <Light Id> -name <Light Name>"
)
#store the bridge profile
profiles[str(ip)] = Profile(args.name, lights, ip, username)
pickle.dump([ip, profiles], open(profilesFileLocation, "wb"))
print(
f"Profile sucessfully set for this IP and the current IP was switched to {ip}"
)
return
#list all lights connected to a bridge
elif args.lights:
print(f"\n{profile.name}\t-\t{profile.ip}\n")
table = []
#get the ids and names of all lights connected to the bridge
for light in bridge.lights():
light = bridge.lights[light]
id = light()["uniqueid"]
try:
name = profile.lights[id]
except KeyError:
name = "N/A" #specify this if the light hasn't been assaigned a name on this profile. this could be because it was added to the bridge after the initial setup of the profile
table.append(["\t" + name, id])
#display table function used to make the infomation more presentable and easy to read
DisplayTable(table)
#list all bridge ips the user can connect to
elif args.ips:
response = requests.get("https://discovery.meethue.com/")
response.raise_for_status()
ips = []
#get ips and names of bridges on the network
for ip in [
bridge["internalipaddress"]
for bridge in ast.literal_eval(response.text)
]:
if ip in profiles:
ips.append(
["\t" + profiles[ip].name, ip]
) #if the user has already setup this bridge, it will have a name
else:
ips.append(
["\tN/A", ip]
) #otherwise it will not and N/A will be put there instead
print("Bridge IPs:\n")
#display table function used to make the infomation more presentable and easy to read
DisplayTable(ips)
#renames a light on a bridge profile
elif args.rename:
#required parameters for this function
if args.name == "":
print("-name is a required parameter of the --rename command")
return
if args.id == "":
print("-id is a required parameter of the --rename command")
return
#make sure the specified light id is valid
if args.id in [
bridge.lights[light]()["uniqueid"]
for light in bridge.lights()
]:
profile = profiles[str(currentIp)]
try:
oldName = profile.lights[args.id]
except KeyError:
oldName = "N/A"
#make sure there won't be multiple lights with the same name on the bridge profile
if args.name not in profile.lights.values():
profile.lights[args.id] = args.name
else:
print(
f"A light with the name {args.name} already exists in this profile"
)
return
#save the changes to the profiles file
pickle.dump([ip, profiles], open(profilesFileLocation, "wb"))
print(
f"Changed light {args.id} name from {oldName} to {args.name} "
)
else:
print(
"Invalid id, use --light to get a list of lights and their ids"
)
#command used for turning lights on and off and changing brightness
elif args.change:
#get the light
result = get_light(profile, args)
if result:
light, name, id = result
else:
return
if args.on:
light.state(on=True)
print(f"Turned On {name} - {id}")
if not args.scene:
#if the brightness value was specified but it contained a number outside of the range of 0-255 an error should be thrown
if args.bri != None:
if args.bri < 0 or args.bri > 255:
print(
"-bri parameter only accepts values between 0-255")
return
if args.hue != None:
if args.hue < 0 or args.hue > 65535:
print(
"-hue parameter only accepts values between 0-65535"
)
return
if args.sat != None:
if args.sat < 0 or args.sat > 255:
print(
"-sat parameter only accepts values between 0-255")
return
if args.bri and args.bri != 0:
if not light()["state"]["on"]:
#turn the light on if it was off beforehand
light.state(on=True)
load = {}
if args.bri: load["bri"] = args.bri
if args.hue: load["hue"] = args.hue
if args.sat: load["sat"] = args.sat
else:
try:
scene = profile.scenes[args.scene]
except KeyError:
print("There isn't a scene with that name")
return
load = {"hue": scene.hue, "sat": scene.sat, "bri": scene.bri}
if load != {}:
light.state(**load)
#if the user wanted to change the brightness of their light
if args.bri != 0 and args.bri:
print(
f"Set {name} to HSB: {load['hue'],load['sat'],load['bri']}"
)
#turn the light off if the -off keyword was used or the user set -bri to 0
if args.off or args.bri == 0:
light.state(on=False)
print(f"Turned Off {name} - {id}")
#switch between different hue bridges
elif args.switch:
#if the user is switching to a specified bridge ip
if args.ip != "":
#the bridge ip must already have a profile associated with it
if args.ip in profiles:
#change the current ip and save it to the profiles file
currentIp = args.ip
pickle.dump([currentIp, profiles],
open(profilesFileLocation, "wb"))
print(
f"Switched profile to {profiles[currentIp].name} - {currentIp}"
)
else:
#if the ip hasn't got a profile for it, reccomend the user sets it up
print(
f"Couldn't find a profile/bridge with the ip, {args.ip}. Use 'hue --setup -ip {args.ip} -name <profile name>' to get started"
)
#if the user is switching to a given bridge name
elif args.name != "":
#search for a profile with the specified name
profile = list(
filter(lambda profile: profiles[profile].name == args.name,
profiles))
if profile == []:
print(
f"Couldn't find a profile with the name, {args.name}")
else:
#change the current ip and save it to the profiles file
currentIp = profiles[profile[0]].ip
pickle.dump([currentIp, profiles],
open(profilesFileLocation, "wb"))
print(f"Switched profile to {args.name} - {currentIp}")
else:
print(
"Either -name or -ip is a required parameter of the --switch command"
)
elif args.info:
result = get_light(profile, args)
if result:
light, name, id = result
else:
return
print("\n" + name + "\t" + id + "\n")
DisplayTable([["\t" + key, light()["state"][key]]
for key in light()["state"]])
elif args.addscene:
result = get_light(profile, args)
if result:
light, name, id = result
else:
return
light = light()["state"]
if not args.scene:
print("-scene is a required parameter of --addscene")
if "hue" in light:
profile.scenes[args.scene] = (Scene(light["bri"], light["hue"],
light["sat"]))
else:
profile.scenes[args.scene] = (Scene(light["bri"], 8504, 130))
pickle.dump([currentIp, profiles], open(profilesFileLocation,
"wb"))
print(f"Set a scene called {args.scene} from the light: {name}")
elif args.delscene:
if not args.scene:
print("-scene is a required parameter of --delscene")
try:
del profile.scenes[args.scene]
except KeyError:
print("There is no scene with that name")
return
print(f"Deleted a scene called {args.scene}")
pickle.dump([currentIp, profiles], open(profilesFileLocation,
"wb"))
elif args.scenes:
table = [[key, profile.scenes[key]]
for key in profile.scenes.keys()]
DisplayTable(table)
elif args.overide:
result = get_light(profile, args)
if not result: return
light, name, id = result
state = light()["state"]
scene = dict(Scene(state["bri"], state["hue"], state["sat"]))
while True:
light.state(**scene)
time.sleep(0.2)
#handle exceptions
except KeyboardInterrupt: #if the user presses ctrl+c
print("Cancelled")
except requests.exceptions.ConnectTimeout: #if the program fails to connect to the bridge
print(f"Failed to connect to {ip}")
except KeyError as e: #an error that will occur when some commands are used before the user has setup a bridge to connect to
if not str(currentIp) in profiles:
print(
"There is no Ip or profile set to retrieve from. Run 'hue --setup -name <profile name>' to get started"
)
return
else:
print(traceback.format_exc(
)) #if another key error occurs then this should show an error
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._bridge_impl: qhue.Bridge = qhue.Bridge(str(self.ip),
self.username)
def api_validate_user(self):
import qhue
qb = qhue.Bridge(self.url.hostname, self.url.username)
return qb.config()
