Beispiel #1
0
    def set_flash(self, flash) -> None:
        """Activate flash."""
        if flash:
            from yeelight import (RGBTransition, SleepTransition, Flow,
                                  BulbException)
            if self._bulb.last_properties["color_mode"] != 1:
                _LOGGER.error("Flash supported currently only in RGB mode.")
                return

            transition = int(self.config[CONF_TRANSITION])
            if flash == FLASH_LONG:
                count = 1
                duration = transition * 5
            if flash == FLASH_SHORT:
                count = 1
                duration = transition * 2

            red, green, blue = self.rgb_color

            transitions = list()
            transitions.append(
                RGBTransition(255, 0, 0, brightness=10, duration=duration))
            transitions.append(SleepTransition(duration=transition))
            transitions.append(
                RGBTransition(red,
                              green,
                              blue,
                              brightness=self.brightness,
                              duration=duration))

            flow = Flow(count=count, transitions=transitions)
            try:
                self._bulb.start_flow(flow)
            except BulbException as ex:
                _LOGGER.error("Unable to set flash: %s", ex)
Beispiel #2
0
    async def async_set_flash(self, flash) -> None:
        """Activate flash."""
        if not flash:
            return
        if int(self._bulb.last_properties["color_mode"]) != 1:
            _LOGGER.error("Flash supported currently only in RGB mode")
            return

        transition = int(self.config[CONF_TRANSITION])
        if flash == FLASH_LONG:
            count = 1
            duration = transition * 5
        if flash == FLASH_SHORT:
            count = 1
            duration = transition * 2

        red, green, blue = color_util.color_hs_to_RGB(*self.hs_color)

        transitions = []
        transitions.append(
            RGBTransition(255, 0, 0, brightness=10, duration=duration))
        transitions.append(SleepTransition(duration=transition))
        transitions.append(
            RGBTransition(red,
                          green,
                          blue,
                          brightness=self.brightness,
                          duration=duration))

        flow = Flow(count=count, transitions=transitions)
        await self._bulb.async_start_flow(flow, light_type=self.light_type)
Beispiel #3
0
def update_yeelight_beacon(beacon, temperature_color, condition_color):
    '''
    Updates a Yeelight beacon
    '''
    brightness = config['lightshow']['brightness']
    duration = config['lightshow']['transition']['duration'] * 1000
    delay = config['lightshow']['transition']['delay'] * 1000

    flow = Flow(0, Flow.actions.recover, [
        RGBTransition(*temperature_color, duration, brightness),
        SleepTransition(delay),
        RGBTransition(*condition_color, duration, brightness),
        SleepTransition(delay)
    ])

    bulb = SmartBulb(beacon['ip'])
    bulb.start_flow(flow)
Beispiel #4
0
async def test_effects(hass: HomeAssistant):
    """Test effects."""
    yaml_configuration = {
        DOMAIN: {
            CONF_DEVICES:
            YAML_CONFIGURATION[DOMAIN][CONF_DEVICES],
            CONF_CUSTOM_EFFECTS: [
                {
                    CONF_NAME: "mock_effect",
                    CONF_FLOW_PARAMS: {
                        ATTR_COUNT:
                        3,
                        ATTR_TRANSITIONS: [
                            {
                                YEELIGHT_HSV_TRANSACTION: [300, 50, 500, 50]
                            },
                            {
                                YEELIGHT_RGB_TRANSITION:
                                [100, 100, 100, 300, 30]
                            },
                            {
                                YEELIGHT_TEMPERATURE_TRANSACTION:
                                [3000, 200, 20]
                            },
                            {
                                YEELIGHT_SLEEP_TRANSACTION: [800]
                            },
                        ],
                    },
                },
            ],
        }
    }

    mocked_bulb = _mocked_bulb()
    with patch(f"{MODULE}.Bulb", return_value=mocked_bulb):
        assert await async_setup_component(hass, DOMAIN, yaml_configuration)
        await hass.async_block_till_done()

    assert hass.states.get(ENTITY_LIGHT).attributes.get(
        "effect_list") == YEELIGHT_COLOR_EFFECT_LIST + ["mock_effect"]

    async def _async_test_effect(name, target=None, called=True):
        mocked_start_flow = MagicMock()
        type(mocked_bulb).start_flow = mocked_start_flow
        await hass.services.async_call(
            "light",
            SERVICE_TURN_ON,
            {
                ATTR_ENTITY_ID: ENTITY_LIGHT,
                ATTR_EFFECT: name
            },
            blocking=True,
        )
        if not called:
            return
        mocked_start_flow.assert_called_once()
        if target is None:
            return
        args, _ = mocked_start_flow.call_args
        flow = args[0]
        assert flow.count == target.count
        assert flow.action == target.action
        assert str(flow.transitions) == str(target.transitions)

    effects = {
        "mock_effect":
        Flow(
            count=3,
            transitions=[
                HSVTransition(300, 50, 500, 50),
                RGBTransition(100, 100, 100, 300, 30),
                TemperatureTransition(3000, 200, 20),
                SleepTransition(800),
            ],
        ),
        EFFECT_DISCO:
        Flow(transitions=transitions.disco()),
        EFFECT_FAST_RANDOM_LOOP:
        None,
        EFFECT_WHATSAPP:
        Flow(count=2, transitions=transitions.pulse(37, 211, 102)),
        EFFECT_FACEBOOK:
        Flow(count=2, transitions=transitions.pulse(59, 89, 152)),
        EFFECT_TWITTER:
        Flow(count=2, transitions=transitions.pulse(0, 172, 237)),
    }

    for name, target in effects.items():
        await _async_test_effect(name, target)
    await _async_test_effect("not_existed", called=False)
Beispiel #5
0
async def test_effects(hass: HomeAssistant):
    """Test effects."""
    assert await async_setup_component(
        hass,
        DOMAIN,
        {
            DOMAIN: {
                CONF_CUSTOM_EFFECTS: [
                    {
                        CONF_NAME: "mock_effect",
                        CONF_FLOW_PARAMS: {
                            ATTR_COUNT: 3,
                            ATTR_TRANSITIONS: [
                                {YEELIGHT_HSV_TRANSACTION: [300, 50, 500, 50]},
                                {YEELIGHT_RGB_TRANSITION: [100, 100, 100, 300, 30]},
                                {YEELIGHT_TEMPERATURE_TRANSACTION: [3000, 200, 20]},
                                {YEELIGHT_SLEEP_TRANSACTION: [800]},
                            ],
                        },
                    }
                ]
            }
        },
    )

    config_entry = MockConfigEntry(domain=DOMAIN, data=CONFIG_ENTRY_DATA)
    config_entry.add_to_hass(hass)

    mocked_bulb = _mocked_bulb()
    with _patch_discovery(), _patch_discovery_interval(), patch(
        f"{MODULE}.AsyncBulb", return_value=mocked_bulb
    ):
        assert await hass.config_entries.async_setup(config_entry.entry_id)
        await hass.async_block_till_done()

    assert hass.states.get(ENTITY_LIGHT).attributes.get(
        "effect_list"
    ) == YEELIGHT_COLOR_EFFECT_LIST + ["mock_effect"]

    async def _async_test_effect(name, target=None, called=True):
        async_mocked_start_flow = AsyncMock()
        mocked_bulb.async_start_flow = async_mocked_start_flow
        await hass.services.async_call(
            "light",
            SERVICE_TURN_ON,
            {ATTR_ENTITY_ID: ENTITY_LIGHT, ATTR_EFFECT: name},
            blocking=True,
        )
        if not called:
            return
        async_mocked_start_flow.assert_called_once()
        if target is None:
            return
        args, _ = async_mocked_start_flow.call_args
        flow = args[0]
        assert flow.count == target.count
        assert flow.action == target.action
        assert str(flow.transitions) == str(target.transitions)

    effects = {
        "mock_effect": Flow(
            count=3,
            transitions=[
                HSVTransition(300, 50, 500, 50),
                RGBTransition(100, 100, 100, 300, 30),
                TemperatureTransition(3000, 200, 20),
                SleepTransition(800),
            ],
        ),
        EFFECT_DISCO: Flow(transitions=transitions.disco()),
        EFFECT_FAST_RANDOM_LOOP: None,
        EFFECT_WHATSAPP: Flow(count=2, transitions=transitions.pulse(37, 211, 102)),
        EFFECT_FACEBOOK: Flow(count=2, transitions=transitions.pulse(59, 89, 152)),
        EFFECT_TWITTER: Flow(count=2, transitions=transitions.pulse(0, 172, 237)),
        EFFECT_HOME: Flow(
            count=0,
            action=Action.recover,
            transitions=[
                TemperatureTransition(degrees=3200, duration=500, brightness=80)
            ],
        ),
        EFFECT_NIGHT_MODE: Flow(
            count=0,
            action=Action.recover,
            transitions=[RGBTransition(0xFF, 0x99, 0x00, duration=500, brightness=1)],
        ),
        EFFECT_DATE_NIGHT: Flow(
            count=0,
            action=Action.recover,
            transitions=[RGBTransition(0xFF, 0x66, 0x00, duration=500, brightness=50)],
        ),
        EFFECT_MOVIE: Flow(
            count=0,
            action=Action.recover,
            transitions=[
                RGBTransition(
                    red=0x14, green=0x14, blue=0x32, duration=500, brightness=50
                )
            ],
        ),
        EFFECT_SUNRISE: Flow(
            count=1,
            action=Action.stay,
            transitions=[
                RGBTransition(
                    red=0xFF, green=0x4D, blue=0x00, duration=50, brightness=1
                ),
                TemperatureTransition(degrees=1700, duration=360000, brightness=10),
                TemperatureTransition(degrees=2700, duration=540000, brightness=100),
            ],
        ),
        EFFECT_SUNSET: Flow(
            count=1,
            action=Action.off,
            transitions=[
                TemperatureTransition(degrees=2700, duration=50, brightness=10),
                TemperatureTransition(degrees=1700, duration=180000, brightness=5),
                RGBTransition(
                    red=0xFF, green=0x4C, blue=0x00, duration=420000, brightness=1
                ),
            ],
        ),
        EFFECT_ROMANCE: Flow(
            count=0,
            action=Action.stay,
            transitions=[
                RGBTransition(
                    red=0x59, green=0x15, blue=0x6D, duration=4000, brightness=1
                ),
                RGBTransition(
                    red=0x66, green=0x14, blue=0x2A, duration=4000, brightness=1
                ),
            ],
        ),
        EFFECT_HAPPY_BIRTHDAY: Flow(
            count=0,
            action=Action.stay,
            transitions=[
                RGBTransition(
                    red=0xDC, green=0x50, blue=0x19, duration=1996, brightness=80
                ),
                RGBTransition(
                    red=0xDC, green=0x78, blue=0x1E, duration=1996, brightness=80
                ),
                RGBTransition(
                    red=0xAA, green=0x32, blue=0x14, duration=1996, brightness=80
                ),
            ],
        ),
        EFFECT_CANDLE_FLICKER: Flow(
            count=0,
            action=Action.recover,
            transitions=[
                TemperatureTransition(degrees=2700, duration=800, brightness=50),
                TemperatureTransition(degrees=2700, duration=800, brightness=30),
                TemperatureTransition(degrees=2700, duration=1200, brightness=80),
                TemperatureTransition(degrees=2700, duration=800, brightness=60),
                TemperatureTransition(degrees=2700, duration=1200, brightness=90),
                TemperatureTransition(degrees=2700, duration=2400, brightness=50),
                TemperatureTransition(degrees=2700, duration=1200, brightness=80),
                TemperatureTransition(degrees=2700, duration=800, brightness=60),
                TemperatureTransition(degrees=2700, duration=400, brightness=70),
            ],
        ),
    }

    for name, target in effects.items():
        await _async_test_effect(name, target)
    await _async_test_effect("not_existed", called=False)
Beispiel #6
0
    def set_effect(self, effect) -> None:
        """Activate effect."""
        if effect:
            from yeelight import (RGBTransition, TemperatureTransition,
                                  SleepTransition, Flow, BulbException)
            transition = int(self.config[CONF_TRANSITION])
            if effect == EFFECT_ALARM:
                count = 0
                duration = 100

                transitions = list()
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=100,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=60, duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_DISCO:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(128,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128, 255, 0, brightness=1,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0, 255, 255, brightness=1,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(128, 0, 255, brightness=1,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_STROBE:
                count = 0
                duration = 50

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  255,
                                  brightness=1,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_COLOR_STROBE:
                count = 0
                duration = 50

                transitions = list()
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  127,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  128,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_POLICE:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_POLICE2:
                count = 0
                duration = 200

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(255, 0, 0, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0, 0, 255, brightness=1, duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_CHRISTMAS:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RGB:
                count = 0
                duration = 300

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=3000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RGB_TRANS:
                count = 0
                duration = 10000

                transitions = list()
                transitions.append(
                    RGBTransition(255,
                                  0,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  255,
                                  0,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  0,
                                  255,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_ENJOY:
                count = 0
                duration = 40000

                transitions = list()
                transitions.append(
                    TemperatureTransition(1700, duration=duration))
                transitions.append(
                    TemperatureTransition(6500, duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RANDOM_LOOP:
                count = 0
                duration = 3000

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_RANDOM_FASTLOOP:
                count = 0
                duration = 800

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_SLOWDOWN:
                count = 0

                transitions = list()
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=250))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=500))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=1000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=200))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=3000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=4000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=5000))
                transitions.append(
                    RGBTransition(random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  random.randrange(0, 255),
                                  brightness=self.brightness,
                                  duration=6000))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_WHATSAPP_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(37,
                                  211,
                                  102,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_FACEBOOK_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(59,
                                  89,
                                  152,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_TWITTER_NOTIFY:
                count = 1
                duration = 250

                transitions = list()
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=self.brightness,
                                  duration=duration))
                transitions.append(SleepTransition(duration=transition))
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=10,
                                  duration=duration))
                transitions.append(
                    RGBTransition(0,
                                  172,
                                  237,
                                  brightness=self.brightness,
                                  duration=duration))
                flow = Flow(count=count, transitions=transitions)

            if effect == EFFECT_STOP:
                self._bulb.stop_flow()
                return
            try:
                self._bulb.start_flow(flow)
            except BulbException as ex:
                _LOGGER.error("Unable to set effect: %s", ex)
Beispiel #7
0
import sys
sys.path.append('../')

from yeelight import SmartBulb, Flow, RGBTransition, SleepTransition

RED   = [255, 0, 0]
GREEN = [0, 255, 0]
BLUE  = [0, 0, 255]

flow = Flow(
    10,
    Flow.actions.recover,
    [
        RGBTransition(*RED, 1000, 100),
        SleepTransition(1000),
        RGBTransition(*GREEN, 1000, 100),
        SleepTransition(1000),
        RGBTransition(*BLUE, 1000, 100),
        SleepTransition(1000)
    ]
)

bulb = SmartBulb('192.168.1.103')
bulb.start_flow(flow)
async def test_effects(hass: HomeAssistant):
    """Test effects."""
    assert await async_setup_component(
        hass,
        DOMAIN,
        {
            DOMAIN: {
                CONF_CUSTOM_EFFECTS: [
                    {
                        CONF_NAME: "mock_effect",
                        CONF_FLOW_PARAMS: {
                            ATTR_COUNT:
                            3,
                            ATTR_TRANSITIONS: [
                                {
                                    YEELIGHT_HSV_TRANSACTION:
                                    [300, 50, 500, 50]
                                },
                                {
                                    YEELIGHT_RGB_TRANSITION:
                                    [100, 100, 100, 300, 30]
                                },
                                {
                                    YEELIGHT_TEMPERATURE_TRANSACTION:
                                    [3000, 200, 20]
                                },
                                {
                                    YEELIGHT_SLEEP_TRANSACTION: [800]
                                },
                            ],
                        },
                    },
                ],
            },
        },
    )

    config_entry = MockConfigEntry(
        domain=DOMAIN,
        data={
            CONF_ID: "",
            CONF_HOST: IP_ADDRESS,
            CONF_TRANSITION: DEFAULT_TRANSITION,
            CONF_MODE_MUSIC: DEFAULT_MODE_MUSIC,
            CONF_SAVE_ON_CHANGE: DEFAULT_SAVE_ON_CHANGE,
            CONF_NIGHTLIGHT_SWITCH: DEFAULT_NIGHTLIGHT_SWITCH,
        },
    )
    config_entry.add_to_hass(hass)

    mocked_bulb = _mocked_bulb()
    with _patch_discovery(MODULE), patch(f"{MODULE}.Bulb",
                                         return_value=mocked_bulb):
        assert await hass.config_entries.async_setup(config_entry.entry_id)
        await hass.async_block_till_done()

    assert hass.states.get(ENTITY_LIGHT).attributes.get(
        "effect_list") == YEELIGHT_COLOR_EFFECT_LIST + ["mock_effect"]

    async def _async_test_effect(name, target=None, called=True):
        mocked_start_flow = MagicMock()
        type(mocked_bulb).start_flow = mocked_start_flow
        await hass.services.async_call(
            "light",
            SERVICE_TURN_ON,
            {
                ATTR_ENTITY_ID: ENTITY_LIGHT,
                ATTR_EFFECT: name
            },
            blocking=True,
        )
        if not called:
            return
        mocked_start_flow.assert_called_once()
        if target is None:
            return
        args, _ = mocked_start_flow.call_args
        flow = args[0]
        assert flow.count == target.count
        assert flow.action == target.action
        assert str(flow.transitions) == str(target.transitions)

    effects = {
        "mock_effect":
        Flow(
            count=3,
            transitions=[
                HSVTransition(300, 50, 500, 50),
                RGBTransition(100, 100, 100, 300, 30),
                TemperatureTransition(3000, 200, 20),
                SleepTransition(800),
            ],
        ),
        EFFECT_DISCO:
        Flow(transitions=transitions.disco()),
        EFFECT_FAST_RANDOM_LOOP:
        None,
        EFFECT_WHATSAPP:
        Flow(count=2, transitions=transitions.pulse(37, 211, 102)),
        EFFECT_FACEBOOK:
        Flow(count=2, transitions=transitions.pulse(59, 89, 152)),
        EFFECT_TWITTER:
        Flow(count=2, transitions=transitions.pulse(0, 172, 237)),
    }

    for name, target in effects.items():
        await _async_test_effect(name, target)
    await _async_test_effect("not_existed", called=False)