async def async_turn_on(self, **kwargs):
"""Instruct the light to turn on."""
rgb = None
if ATTR_RGB_COLOR in kwargs:
rgb = kwargs.get(ATTR_RGB_COLOR)
if ATTR_HS_COLOR in kwargs:
rgb = color_utils.color_hs_to_RGB(kwargs[ATTR_HS_COLOR][0],
kwargs[ATTR_HS_COLOR][1])
brightness = None
if ATTR_BRIGHTNESS in kwargs:
brightness = kwargs.get(ATTR_BRIGHTNESS)
colortemp = None
if ATTR_COLOR_TEMP in kwargs:
kelvin = color_utils.color_temperature_mired_to_kelvin(
kwargs[ATTR_COLOR_TEMP])
colortemp = kelvin
sceneid = None
if ATTR_EFFECT in kwargs:
sceneid = self._light.get_id_from_scene_name(kwargs[ATTR_EFFECT])
if sceneid == 1000: # rhythm
pilot = PilotBuilder()
else:
pilot = PilotBuilder(rgb=rgb,
brightness=brightness,
colortemp=colortemp,
scene=sceneid)
await self._light.turn_on(pilot)
async def run_bulb_automation():
loop = asyncio.get_event_loop()
bulb1 = wizlight('192.168.178.95')
# bulb2 = wizlight('192.168.1.7')
# await asyncio.gather(testbulb(bulb1), testbulb(bulb2), loop = loop)
state = await bulb1.updateState()
await bulb1.turn_on(PilotBuilder(scene=14))
state = await bulb1.updateState()
await asyncio.sleep(0.5)
await bulb1.turn_on(PilotBuilder()) #rhythm
state = await bulb1.updateState()
async def music():
await light.turn_on(PilotBuilder())
await light.turn_on(PilotBuilder(brightness=1))
for i in range(int(10 * 44100 / 1024)): #go for a few seconds
data = np.fromstring(stream.read(CHUNK), dtype=np.int16)
peak = np.average(np.abs(data)) * 2
bars = "#" * int(50 * peak / 2**16)
r = 0
g = 0
b = 0
if (peak <= 5000 / 6):
r = 245
g = peak / 5000 * 179 + 66
b = 66
elif (peak <= 5000 / 6 * 2):
r = peak / 5000 * 179 + 66
g = 245
b = 66
elif (peak <= 5000 / 6 * 3):
r = 66
g = 245
b = peak / 5000 * 179 + 66
elif (peak <= 5000 / 6 * 4):
r = 66
g = peak / 5000 * 179 + 66
b = 245
elif (peak <= 5000 / 6 * 5):
r = peak / 5000 * 179 + 66
g = 245
b = 66
elif (peak <= 5000 / 6 * 6):
r = 245
g = 66
b = peak / 5000 * 179 + 66
r = min(r, 255)
g = min(g, 255)
b = min(b, 255)
#r = min(127.5 + peak/7000 * 255, 254)
#g = max(127.5 - peak/5500 * 255, 0)
#b = min(peak/4000 * 255, 254)
brightlevel = min(peak / 7000 * 254, 255)
#print("%04d %05d %s"%(i,peak,bars))
#print(bars)
print(peak)
await light.turn_on(PilotBuilder(rgb=(r, g, b),
brightness=brightlevel))
print('r value', r)
print('g value', g)
print('g value', b)
print('brightness value', brightlevel)
async def test_timeout_PilotBuilder(bad_bulb: wizlight) -> None:
"""Test Timout for Result."""
# check if the bulb state it given as bool - mock ?
with pytest.raises(WizLightTimeOutError), patch(
"pywizlight.bulb.FIRST_SEND_INTERVAL", 0.01
), patch("pywizlight.bulb.TIMEOUT", 0.01):
await bad_bulb.turn_on(PilotBuilder(brightness=255))
async def test_PilotBuilder_speed(correct_bulb: wizlight) -> None:
"""Test speed."""
await correct_bulb.turn_on(PilotBuilder(scene=1, speed=50))
state = await correct_bulb.updateState()
assert state and state.get_scene() == SCENES[1]
assert state and state.get_speed() == 50
async def set_state(ip, k, brightness):
"""Turn a given bulb on."""
click.echo("Turning on %s" % ip)
bulb = wizlight(ip)
if bulb and k <= 6800 and k >= 1000 and brightness >= 0 and brightness <= 256:
await bulb.set_state(PilotBuilder(colortemp=k, brightness=brightness))
else:
click.echo("Error - values are not correct. Type --help for help.")
async def test_PilotBuilder_scene(correct_bulb: wizlight) -> None:
"""Test scene."""
await correct_bulb.turn_on(PilotBuilder(scene=1))
state = await correct_bulb.updateState()
assert state and state.get_scene() == SCENES[1]
state.pilotResult["schdPsetId"] = True
assert state.get_scene() == SCENES[1000]
async def main():
bulbs = await discovery.discover_lights(broadcast_space="10.0.0.255")
lights = []
for i in range(len(bulbs)):
light = wizlight(bulbs[i].ip)
lights.append(light)
print(lights)
while True:
rgb_vals_left, rgb_vals_right = await dual_screen_average_colors()
#bright_val = calc_brightness(rgb_vals)
await lights[0].turn_on(PilotBuilder(rgb=rgb_vals_left))
await lights[1].turn_on(PilotBuilder(rgb=rgb_vals_right))
async def set_state(ip: str, k: int, brightness: int) -> None:
"""Set the current state of a given bulb."""
click.echo(f"Turning on {ip}")
bulb = wizlight(ip)
if bulb and 1000 <= k <= 6800 and 0 <= brightness <= 255:
await bulb.set_state(PilotBuilder(colortemp=k, brightness=brightness))
else:
click.echo("Error - values are not correct. Type --help for help.")
await bulb.async_close()
async def test_setting_ratio(squire: wizlight) -> None:
"""Test setting ratio."""
await squire.set_ratio(50)
state = await squire.updateState()
assert state and state.get_ratio() == 50
await squire.turn_on(PilotBuilder(ratio=20))
state = await squire.updateState()
assert state and state.get_ratio() == 20
with pytest.raises(ValueError):
await squire.set_ratio(500)
async def async_turn_on(self, **kwargs):
"""Instruct the light to turn on."""
brightness = None
if ATTR_BRIGHTNESS in kwargs:
brightness = kwargs.get(ATTR_BRIGHTNESS)
if ATTR_RGB_COLOR in kwargs:
pilot = rgb2rgbcw(kwargs.get(ATTR_RGB_COLOR), brightness)
if ATTR_HS_COLOR in kwargs:
pilot = hs2rgbcw(kwargs.get(ATTR_HS_COLOR), brightness)
else:
colortemp = None
if ATTR_COLOR_TEMP in kwargs:
kelvin = color_utils.color_temperature_mired_to_kelvin(
kwargs[ATTR_COLOR_TEMP])
colortemp = kelvin
_LOGGER.debug(
"[wizlight %s] kelvin changed and send to bulb: %s",
self._light.ip,
colortemp,
)
sceneid = None
if ATTR_EFFECT in kwargs:
sceneid = self._light.get_id_from_scene_name(
kwargs[ATTR_EFFECT])
if sceneid == 1000: # rhythm
pilot = PilotBuilder()
else:
pilot = PilotBuilder(brightness=brightness,
colortemp=colortemp,
scene=sceneid)
_LOGGER.debug(
"[wizlight %s] Pilot will be send with brightness=%s, colortemp=%s, scene=%s",
self._light.ip,
brightness,
colortemp,
sceneid,
)
await self._light.turn_on(pilot, )
def _async_pilot_builder(**kwargs: Any) -> PilotBuilder:
"""Create the PilotBuilder for turn on."""
brightness = kwargs.get(ATTR_BRIGHTNESS)
if ATTR_RGBWW_COLOR in kwargs:
return PilotBuilder(brightness=brightness,
rgbww=kwargs[ATTR_RGBWW_COLOR])
if ATTR_RGBW_COLOR in kwargs:
return PilotBuilder(brightness=brightness,
rgbw=kwargs[ATTR_RGBW_COLOR])
if ATTR_COLOR_TEMP in kwargs:
return PilotBuilder(
brightness=brightness,
colortemp=color_temperature_mired_to_kelvin(
kwargs[ATTR_COLOR_TEMP]),
)
if ATTR_EFFECT in kwargs:
scene_id = get_id_from_scene_name(kwargs[ATTR_EFFECT])
if scene_id == 1000: # rhythm
return PilotBuilder()
return PilotBuilder(brightness=brightness, scene=scene_id)
return PilotBuilder(brightness=brightness)
async def main():
bulbs = await discovery.discover_lights(broadcast_space="10.0.0.255")
lights = []
for i in range(len(bulbs)):
light = wizlight(bulbs[i].ip)
lights.append(light)
print(len(lights), "lights found.")
while True:
rgb_vals = await screen_average_colors()
#bright_val = calc_brightness(rgb_vals)
for light in lights:
await light.turn_on(PilotBuilder(rgb=rgb_vals))
async def testbulb(bulb):
wait_secs = 10
state = await bulb.updateState()
if state.get_state(): # check if on
await asyncio.wait_for(bulb.turn_off(), wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.lightSwitch(), wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_off(), wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(brightness=255)),
wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(brightness=50)),
wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(rgb=(50, 100, 200))),
wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(colortemp=4000)),
wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(colortemp=6500)),
wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(scene=14)), wait_secs)
await asyncio.sleep(0.5)
await asyncio.wait_for(bulb.turn_on(PilotBuilder(scene=24)), wait_secs)
state = await bulb.updateState()
print(state.get_state())
print(state.get_scene())
print(state.get_scene())
print(state.get_warm_white())
print(state.get_speed())
print(state.get_cold_white())
print(state.get_rgb())
print(state.get_brightness())
print(state.get_colortemp())
async def test_PilotBuilder_brightness(correct_bulb: wizlight) -> None:
"""Test Brightness."""
await correct_bulb.turn_on(PilotBuilder(brightness=10))
state = await correct_bulb.updateState()
# 10% == 26 in Hex
assert state and state.get_brightness() == 26
async def test_error_PilotBuilder_warm_wite(self, data):
"""Error Warm White."""
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(warm_white=300))
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(warm_white=0))
async def test_error_PilotBuilder_brightness(self, data):
"""Error Brightness."""
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(brightness=500))
async def test_PilotBuilder_scene(self, data):
"""Test Screen."""
await pytest.correct_bulb.turn_on(PilotBuilder(scene=1))
state = await pytest.correct_bulb.updateState()
assert state.get_scene() == SCENES[1]
async def test_PilotBuilder_rgb(self, data):
"""Test RGB Value."""
await pytest.correct_bulb.turn_on(PilotBuilder(rgb=(0, 128, 255)))
state = await pytest.correct_bulb.updateState()
assert state.get_rgb() == (0, 128, 255)
async def test_PilotBuilder_cold_white(self, data):
"""Test Cold White."""
await pytest.correct_bulb.turn_on(PilotBuilder(cold_white=255))
state = await pytest.correct_bulb.updateState()
assert state.get_cold_white() == 255
import sys
import asyncio
from pywizlight import wizlight, PilotBuilder, discovery
addr = sys.argv[1]
# allow to pass 'red', 'blue', 'green', 'white' as color in arguments, otherwise default to white
color = sys.argv[2] if len(sys.argv) > 2 else "white"
if (color != "white" and
color != "red" and color != "r" and
color != "blue" and color != "b" and
color != "green" and color != "g"):
color = "white"
pb = PilotBuilder(warm_white = 230, brightness = 110, speed = 100)
if (color != "white"):
if color == "red" or color == "r":
pb = PilotBuilder(rgb = (255, 0, 0), brightness = 255, speed = 100)
elif color == "green" or color == "g":
pb = PilotBuilder(rgb = (0, 255, 0), brightness = 255, speed = 100)
elif color == "blue" or color == "b":
pb = PilotBuilder(rgb = (0, 0, 255), brightness = 255, speed = 100)
else:
raise ValueError("color wasn't white but couldn't parse to true color")
async def main():
light = wizlight(addr)
await light.turn_on(pb)
loop = asyncio.get_event_loop()
async def test_PilotBuilder_colortemp(self, data):
"""Test Color Temp."""
await pytest.correct_bulb.turn_on(PilotBuilder(colortemp=2800))
state = await pytest.correct_bulb.updateState()
assert state.get_colortemp() == 2800
async def test_timeout_PilotBuilder(self, data):
"""Test Timout for Result."""
# check if the bulb state it given as bool - mock ?
with pytest.raises(WizLightTimeOutError):
await pytest.bad_bulb.turn_on(PilotBuilder(brightness=255))
async def test_error_PilotBuilder_scene(self, data):
"""Error Screen."""
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(scene=532))
async def test_error_PilotBuilder_blue(self, data):
"""Error Blue Value."""
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(rgb=(0, 0, 300)))
async def test_error_PilotBuilder_cold_white_lower(self, data):
"""Error Cold White."""
with pytest.raises(ValueError):
await pytest.correct_bulb.turn_on(PilotBuilder(cold_white=0))
async def test_PilotBuilder_warm_wite(correct_bulb: wizlight) -> None:
"""Test Warm White."""
await correct_bulb.turn_on(PilotBuilder(warm_white=255))
state = await correct_bulb.updateState()
assert state and state.get_warm_white() == 255
async def test_setting_rgbww(light_strip: wizlight) -> None:
"""Test setting rgbww."""
await light_strip.turn_on(PilotBuilder(rgbww=(1, 2, 3, 4, 5)))
state = await light_strip.updateState()
assert state and state.get_rgbww() == (1, 2, 3, 4, 5)
async def async_turn_on(self, **kwargs):
"""Instruct the switch to turn on."""
await self._switch.turn_on(PilotBuilder())
self._state = True
self.schedule_update_ha_state()
async def test_PilotBuilder_brightness(self, data):
"""Test Brightness."""
await pytest.correct_bulb.turn_on(PilotBuilder(brightness=10))
state = await pytest.correct_bulb.updateState()
# 10% == 26 in Hex
assert state.get_brightness() == 26
