add-black (#1593)

* Add black

Update pre commit

Update pre commit

add empty line

* Format with black

esphome/components/light/effects.py

@@ -2,38 +2,69 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 
-from esphome.const import CONF_NAME, CONF_LAMBDA, CONF_UPDATE_INTERVAL, CONF_TRANSITION_LENGTH, \
-    CONF_COLORS, CONF_STATE, CONF_DURATION, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE, \
-    CONF_WHITE, CONF_ALPHA, CONF_INTENSITY, CONF_SPEED, CONF_WIDTH, CONF_NUM_LEDS, CONF_RANDOM, \
-    CONF_SEQUENCE
+from esphome.const import (
+    CONF_NAME,
+    CONF_LAMBDA,
+    CONF_UPDATE_INTERVAL,
+    CONF_TRANSITION_LENGTH,
+    CONF_COLORS,
+    CONF_STATE,
+    CONF_DURATION,
+    CONF_BRIGHTNESS,
+    CONF_RED,
+    CONF_GREEN,
+    CONF_BLUE,
+    CONF_WHITE,
+    CONF_ALPHA,
+    CONF_INTENSITY,
+    CONF_SPEED,
+    CONF_WIDTH,
+    CONF_NUM_LEDS,
+    CONF_RANDOM,
+    CONF_SEQUENCE,
+)
 from esphome.util import Registry
-from .types import LambdaLightEffect, RandomLightEffect, StrobeLightEffect, \
-    StrobeLightEffectColor, LightColorValues, AddressableLightRef, AddressableLambdaLightEffect, \
-    FlickerLightEffect, AddressableRainbowLightEffect, AddressableColorWipeEffect, \
-    AddressableColorWipeEffectColor, AddressableScanEffect, AddressableTwinkleEffect, \
-    AddressableRandomTwinkleEffect, AddressableFireworksEffect, AddressableFlickerEffect, \
-    AutomationLightEffect, Color
+from .types import (
+    LambdaLightEffect,
+    RandomLightEffect,
+    StrobeLightEffect,
+    StrobeLightEffectColor,
+    LightColorValues,
+    AddressableLightRef,
+    AddressableLambdaLightEffect,
+    FlickerLightEffect,
+    AddressableRainbowLightEffect,
+    AddressableColorWipeEffect,
+    AddressableColorWipeEffectColor,
+    AddressableScanEffect,
+    AddressableTwinkleEffect,
+    AddressableRandomTwinkleEffect,
+    AddressableFireworksEffect,
+    AddressableFlickerEffect,
+    AutomationLightEffect,
+    Color,
+)
 
-CONF_ADD_LED_INTERVAL = 'add_led_interval'
-CONF_REVERSE = 'reverse'
-CONF_MOVE_INTERVAL = 'move_interval'
-CONF_SCAN_WIDTH = 'scan_width'
-CONF_TWINKLE_PROBABILITY = 'twinkle_probability'
-CONF_PROGRESS_INTERVAL = 'progress_interval'
-CONF_SPARK_PROBABILITY = 'spark_probability'
-CONF_USE_RANDOM_COLOR = 'use_random_color'
-CONF_FADE_OUT_RATE = 'fade_out_rate'
-CONF_STROBE = 'strobe'
-CONF_FLICKER = 'flicker'
-CONF_ADDRESSABLE_LAMBDA = 'addressable_lambda'
-CONF_ADDRESSABLE_RAINBOW = 'addressable_rainbow'
-CONF_ADDRESSABLE_COLOR_WIPE = 'addressable_color_wipe'
-CONF_ADDRESSABLE_SCAN = 'addressable_scan'
-CONF_ADDRESSABLE_TWINKLE = 'addressable_twinkle'
-CONF_ADDRESSABLE_RANDOM_TWINKLE = 'addressable_random_twinkle'
-CONF_ADDRESSABLE_FIREWORKS = 'addressable_fireworks'
-CONF_ADDRESSABLE_FLICKER = 'addressable_flicker'
-CONF_AUTOMATION = 'automation'
+CONF_ADD_LED_INTERVAL = "add_led_interval"
+CONF_REVERSE = "reverse"
+CONF_MOVE_INTERVAL = "move_interval"
+CONF_SCAN_WIDTH = "scan_width"
+CONF_TWINKLE_PROBABILITY = "twinkle_probability"
+CONF_PROGRESS_INTERVAL = "progress_interval"
+CONF_SPARK_PROBABILITY = "spark_probability"
+CONF_USE_RANDOM_COLOR = "use_random_color"
+CONF_FADE_OUT_RATE = "fade_out_rate"
+CONF_STROBE = "strobe"
+CONF_FLICKER = "flicker"
+CONF_ADDRESSABLE_LAMBDA = "addressable_lambda"
+CONF_ADDRESSABLE_RAINBOW = "addressable_rainbow"
+CONF_ADDRESSABLE_COLOR_WIPE = "addressable_color_wipe"
+CONF_ADDRESSABLE_SCAN = "addressable_scan"
+CONF_ADDRESSABLE_TWINKLE = "addressable_twinkle"
+CONF_ADDRESSABLE_RANDOM_TWINKLE = "addressable_random_twinkle"
+CONF_ADDRESSABLE_FIREWORKS = "addressable_fireworks"
+CONF_ADDRESSABLE_FLICKER = "addressable_flicker"
+CONF_AUTOMATION = "automation"
 
 BINARY_EFFECTS = []
 MONOCHROMATIC_EFFECTS = []
@@ -44,9 +75,11 @@ EFFECTS_REGISTRY = Registry()
 
 
 def register_effect(name, effect_type, default_name, schema, *extra_validators):
-    schema = cv.Schema(schema).extend({
-        cv.Optional(CONF_NAME, default=default_name): cv.string_strict,
-    })
+    schema = cv.Schema(schema).extend(
+        {
+            cv.Optional(CONF_NAME, default=default_name): cv.string_strict,
+        }
+    )
     validator = cv.All(schema, *extra_validators)
     return EFFECTS_REGISTRY.register(name, effect_type, validator)
 
@@ -61,7 +94,9 @@ def register_binary_effect(name, effect_type, default_name, schema, *extra_valid
     return register_effect(name, effect_type, default_name, schema, *extra_validators)
 
 
-def register_monochromatic_effect(name, effect_type, default_name, schema, *extra_validators):
+def register_monochromatic_effect(
+    name, effect_type, default_name, schema, *extra_validators
+):
     # monochromatic effect can be used for all lights expect binary
     MONOCHROMATIC_EFFECTS.append(name)
     RGB_EFFECTS.append(name)
@@ -78,36 +113,58 @@ def register_rgb_effect(name, effect_type, default_name, schema, *extra_validato
     return register_effect(name, effect_type, default_name, schema, *extra_validators)
 
 
-def register_addressable_effect(name, effect_type, default_name, schema, *extra_validators):
+def register_addressable_effect(
+    name, effect_type, default_name, schema, *extra_validators
+):
     # addressable effect can be used only in addressable
     ADDRESSABLE_EFFECTS.append(name)
 
     return register_effect(name, effect_type, default_name, schema, *extra_validators)
 
 
-@register_binary_effect('lambda', LambdaLightEffect, "Lambda", {
-    cv.Required(CONF_LAMBDA): cv.lambda_,
-    cv.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.update_interval,
-})
+@register_binary_effect(
+    "lambda",
+    LambdaLightEffect,
+    "Lambda",
+    {
+        cv.Required(CONF_LAMBDA): cv.lambda_,
+        cv.Optional(CONF_UPDATE_INTERVAL, default="0ms"): cv.update_interval,
+    },
+)
 def lambda_effect_to_code(config, effect_id):
     lambda_ = yield cg.process_lambda(config[CONF_LAMBDA], [], return_type=cg.void)
-    yield cg.new_Pvariable(effect_id, config[CONF_NAME], lambda_,
-                           config[CONF_UPDATE_INTERVAL])
+    yield cg.new_Pvariable(
+        effect_id, config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL]
+    )
 
 
-@register_binary_effect('automation', AutomationLightEffect, "Automation", {
-    cv.Required(CONF_SEQUENCE): automation.validate_automation(single=True),
-})
+@register_binary_effect(
+    "automation",
+    AutomationLightEffect,
+    "Automation",
+    {
+        cv.Required(CONF_SEQUENCE): automation.validate_automation(single=True),
+    },
+)
 def automation_effect_to_code(config, effect_id):
     var = yield cg.new_Pvariable(effect_id, config[CONF_NAME])
     yield automation.build_automation(var.get_trig(), [], config[CONF_SEQUENCE])
     yield var
 
 
-@register_rgb_effect('random', RandomLightEffect, "Random", {
-    cv.Optional(CONF_TRANSITION_LENGTH, default='7.5s'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_UPDATE_INTERVAL, default='10s'): cv.positive_time_period_milliseconds,
-})
+@register_rgb_effect(
+    "random",
+    RandomLightEffect,
+    "Random",
+    {
+        cv.Optional(
+            CONF_TRANSITION_LENGTH, default="7.5s"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(
+            CONF_UPDATE_INTERVAL, default="10s"
+        ): cv.positive_time_period_milliseconds,
+    },
+)
 def random_effect_to_code(config, effect_id):
     effect = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(effect.set_transition_length(config[CONF_TRANSITION_LENGTH]))
@@ -115,40 +172,79 @@ def random_effect_to_code(config, effect_id):
     yield effect
 
 
-@register_binary_effect('strobe', StrobeLightEffect, "Strobe", {
-    cv.Optional(CONF_COLORS, default=[
-        {CONF_STATE: True, CONF_DURATION: '0.5s'},
-        {CONF_STATE: False, CONF_DURATION: '0.5s'},
-    ]): cv.All(cv.ensure_list(cv.Schema({
-        cv.Optional(CONF_STATE, default=True): cv.boolean,
-        cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
-        cv.Optional(CONF_RED, default=1.0): cv.percentage,
-        cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
-        cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
-        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
-        cv.Required(CONF_DURATION): cv.positive_time_period_milliseconds,
-    }), cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE,
-                                CONF_WHITE)), cv.Length(min=2)),
-})
+@register_binary_effect(
+    "strobe",
+    StrobeLightEffect,
+    "Strobe",
+    {
+        cv.Optional(
+            CONF_COLORS,
+            default=[
+                {CONF_STATE: True, CONF_DURATION: "0.5s"},
+                {CONF_STATE: False, CONF_DURATION: "0.5s"},
+            ],
+        ): cv.All(
+            cv.ensure_list(
+                cv.Schema(
+                    {
+                        cv.Optional(CONF_STATE, default=True): cv.boolean,
+                        cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
+                        cv.Optional(CONF_RED, default=1.0): cv.percentage,
+                        cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
+                        cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
+                        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
+                        cv.Required(
+                            CONF_DURATION
+                        ): cv.positive_time_period_milliseconds,
+                    }
+                ),
+                cv.has_at_least_one_key(
+                    CONF_STATE,
+                    CONF_BRIGHTNESS,
+                    CONF_RED,
+                    CONF_GREEN,
+                    CONF_BLUE,
+                    CONF_WHITE,
+                ),
+            ),
+            cv.Length(min=2),
+        ),
+    },
+)
 def strobe_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     colors = []
     for color in config.get(CONF_COLORS, []):
-        colors.append(cg.StructInitializer(
-            StrobeLightEffectColor,
-            ('color', LightColorValues(color[CONF_STATE], color[CONF_BRIGHTNESS],
-                                       color[CONF_RED], color[CONF_GREEN], color[CONF_BLUE],
-                                       color[CONF_WHITE])),
-            ('duration', color[CONF_DURATION]),
-        ))
+        colors.append(
+            cg.StructInitializer(
+                StrobeLightEffectColor,
+                (
+                    "color",
+                    LightColorValues(
+                        color[CONF_STATE],
+                        color[CONF_BRIGHTNESS],
+                        color[CONF_RED],
+                        color[CONF_GREEN],
+                        color[CONF_BLUE],
+                        color[CONF_WHITE],
+                    ),
+                ),
+                ("duration", color[CONF_DURATION]),
+            )
+        )
     cg.add(var.set_colors(colors))
     yield var
 
 
-@register_monochromatic_effect('flicker', FlickerLightEffect, "Flicker", {
-    cv.Optional(CONF_ALPHA, default=0.95): cv.percentage,
-    cv.Optional(CONF_INTENSITY, default=0.015): cv.percentage,
-})
+@register_monochromatic_effect(
+    "flicker",
+    FlickerLightEffect,
+    "Flicker",
+    {
+        cv.Optional(CONF_ALPHA, default=0.95): cv.percentage,
+        cv.Optional(CONF_INTENSITY, default=0.015): cv.percentage,
+    },
+)
 def flicker_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_alpha(config[CONF_ALPHA]))
@@ -157,23 +253,38 @@ def flicker_effect_to_code(config, effect_id):
 
 
 @register_addressable_effect(
-    'addressable_lambda', AddressableLambdaLightEffect, "Addressable Lambda", {
+    "addressable_lambda",
+    AddressableLambdaLightEffect,
+    "Addressable Lambda",
+    {
         cv.Required(CONF_LAMBDA): cv.lambda_,
-        cv.Optional(CONF_UPDATE_INTERVAL, default='0ms'): cv.positive_time_period_milliseconds,
-    }
+        cv.Optional(
+            CONF_UPDATE_INTERVAL, default="0ms"
+        ): cv.positive_time_period_milliseconds,
+    },
 )
 def addressable_lambda_effect_to_code(config, effect_id):
-    args = [(AddressableLightRef, 'it'), (Color, 'current_color'), (bool, 'initial_run')]
+    args = [
+        (AddressableLightRef, "it"),
+        (Color, "current_color"),
+        (bool, "initial_run"),
+    ]
     lambda_ = yield cg.process_lambda(config[CONF_LAMBDA], args, return_type=cg.void)
-    var = cg.new_Pvariable(effect_id, config[CONF_NAME], lambda_,
-                           config[CONF_UPDATE_INTERVAL])
+    var = cg.new_Pvariable(
+        effect_id, config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL]
+    )
     yield var
 
 
-@register_addressable_effect('addressable_rainbow', AddressableRainbowLightEffect, "Rainbow", {
-    cv.Optional(CONF_SPEED, default=10): cv.uint32_t,
-    cv.Optional(CONF_WIDTH, default=50): cv.uint32_t,
-})
+@register_addressable_effect(
+    "addressable_rainbow",
+    AddressableRainbowLightEffect,
+    "Rainbow",
+    {
+        cv.Optional(CONF_SPEED, default=10): cv.uint32_t,
+        cv.Optional(CONF_WIDTH, default=50): cv.uint32_t,
+    },
+)
 def addressable_rainbow_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_speed(config[CONF_SPEED]))
@@ -181,41 +292,61 @@ def addressable_rainbow_effect_to_code(config, effect_id):
     yield var
 
 
-@register_addressable_effect('addressable_color_wipe', AddressableColorWipeEffect, "Color Wipe", {
-    cv.Optional(CONF_COLORS, default=[{CONF_NUM_LEDS: 1, CONF_RANDOM: True}]): cv.ensure_list({
-        cv.Optional(CONF_RED, default=1.0): cv.percentage,
-        cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
-        cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
-        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
-        cv.Optional(CONF_RANDOM, default=False): cv.boolean,
-        cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t, cv.Range(min=1)),
-    }),
-    cv.Optional(CONF_ADD_LED_INTERVAL, default='0.1s'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_REVERSE, default=False): cv.boolean,
-})
+@register_addressable_effect(
+    "addressable_color_wipe",
+    AddressableColorWipeEffect,
+    "Color Wipe",
+    {
+        cv.Optional(
+            CONF_COLORS, default=[{CONF_NUM_LEDS: 1, CONF_RANDOM: True}]
+        ): cv.ensure_list(
+            {
+                cv.Optional(CONF_RED, default=1.0): cv.percentage,
+                cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
+                cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
+                cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
+                cv.Optional(CONF_RANDOM, default=False): cv.boolean,
+                cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t, cv.Range(min=1)),
+            }
+        ),
+        cv.Optional(
+            CONF_ADD_LED_INTERVAL, default="0.1s"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_REVERSE, default=False): cv.boolean,
+    },
+)
 def addressable_color_wipe_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
     cg.add(var.set_reverse(config[CONF_REVERSE]))
     colors = []
     for color in config.get(CONF_COLORS, []):
-        colors.append(cg.StructInitializer(
-            AddressableColorWipeEffectColor,
-            ('r', int(round(color[CONF_RED] * 255))),
-            ('g', int(round(color[CONF_GREEN] * 255))),
-            ('b', int(round(color[CONF_BLUE] * 255))),
-            ('w', int(round(color[CONF_WHITE] * 255))),
-            ('random', color[CONF_RANDOM]),
-            ('num_leds', color[CONF_NUM_LEDS]),
-        ))
+        colors.append(
+            cg.StructInitializer(
+                AddressableColorWipeEffectColor,
+                ("r", int(round(color[CONF_RED] * 255))),
+                ("g", int(round(color[CONF_GREEN] * 255))),
+                ("b", int(round(color[CONF_BLUE] * 255))),
+                ("w", int(round(color[CONF_WHITE] * 255))),
+                ("random", color[CONF_RANDOM]),
+                ("num_leds", color[CONF_NUM_LEDS]),
+            )
+        )
     cg.add(var.set_colors(colors))
     yield var
 
 
-@register_addressable_effect('addressable_scan', AddressableScanEffect, "Scan", {
-    cv.Optional(CONF_MOVE_INTERVAL, default='0.1s'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_SCAN_WIDTH, default=1): cv.int_range(min=1),
-})
+@register_addressable_effect(
+    "addressable_scan",
+    AddressableScanEffect,
+    "Scan",
+    {
+        cv.Optional(
+            CONF_MOVE_INTERVAL, default="0.1s"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_SCAN_WIDTH, default=1): cv.int_range(min=1),
+    },
+)
 def addressable_scan_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_move_interval(config[CONF_MOVE_INTERVAL]))
@@ -223,10 +354,17 @@ def addressable_scan_effect_to_code(config, effect_id):
     yield var
 
 
-@register_addressable_effect('addressable_twinkle', AddressableTwinkleEffect, "Twinkle", {
-    cv.Optional(CONF_TWINKLE_PROBABILITY, default='5%'): cv.percentage,
-    cv.Optional(CONF_PROGRESS_INTERVAL, default='4ms'): cv.positive_time_period_milliseconds,
-})
+@register_addressable_effect(
+    "addressable_twinkle",
+    AddressableTwinkleEffect,
+    "Twinkle",
+    {
+        cv.Optional(CONF_TWINKLE_PROBABILITY, default="5%"): cv.percentage,
+        cv.Optional(
+            CONF_PROGRESS_INTERVAL, default="4ms"
+        ): cv.positive_time_period_milliseconds,
+    },
+)
 def addressable_twinkle_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_twinkle_probability(config[CONF_TWINKLE_PROBABILITY]))
@@ -235,10 +373,15 @@ def addressable_twinkle_effect_to_code(config, effect_id):
 
 
 @register_addressable_effect(
-    'addressable_random_twinkle', AddressableRandomTwinkleEffect, "Random Twinkle", {
-        cv.Optional(CONF_TWINKLE_PROBABILITY, default='5%'): cv.percentage,
-        cv.Optional(CONF_PROGRESS_INTERVAL, default='32ms'): cv.positive_time_period_milliseconds,
-    }
+    "addressable_random_twinkle",
+    AddressableRandomTwinkleEffect,
+    "Random Twinkle",
+    {
+        cv.Optional(CONF_TWINKLE_PROBABILITY, default="5%"): cv.percentage,
+        cv.Optional(
+            CONF_PROGRESS_INTERVAL, default="32ms"
+        ): cv.positive_time_period_milliseconds,
+    },
 )
 def addressable_random_twinkle_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
@@ -247,12 +390,19 @@ def addressable_random_twinkle_effect_to_code(config, effect_id):
     yield var
 
 
-@register_addressable_effect('addressable_fireworks', AddressableFireworksEffect, "Fireworks", {
-    cv.Optional(CONF_UPDATE_INTERVAL, default='32ms'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_SPARK_PROBABILITY, default='10%'): cv.percentage,
-    cv.Optional(CONF_USE_RANDOM_COLOR, default=False): cv.boolean,
-    cv.Optional(CONF_FADE_OUT_RATE, default=120): cv.uint8_t,
-})
+@register_addressable_effect(
+    "addressable_fireworks",
+    AddressableFireworksEffect,
+    "Fireworks",
+    {
+        cv.Optional(
+            CONF_UPDATE_INTERVAL, default="32ms"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_SPARK_PROBABILITY, default="10%"): cv.percentage,
+        cv.Optional(CONF_USE_RANDOM_COLOR, default=False): cv.boolean,
+        cv.Optional(CONF_FADE_OUT_RATE, default=120): cv.uint8_t,
+    },
+)
 def addressable_fireworks_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
     cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
@@ -263,10 +413,15 @@ def addressable_fireworks_effect_to_code(config, effect_id):
 
 
 @register_addressable_effect(
-    'addressable_flicker', AddressableFlickerEffect, "Addressable Flicker", {
-        cv.Optional(CONF_UPDATE_INTERVAL, default='16ms'): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_INTENSITY, default='5%'): cv.percentage,
-    }
+    "addressable_flicker",
+    AddressableFlickerEffect,
+    "Addressable Flicker",
+    {
+        cv.Optional(
+            CONF_UPDATE_INTERVAL, default="16ms"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_INTENSITY, default="5%"): cv.percentage,
+    },
 )
 def addressable_flicker_effect_to_code(config, effect_id):
     var = cg.new_Pvariable(effect_id, config[CONF_NAME])
@@ -277,22 +432,28 @@ def addressable_flicker_effect_to_code(config, effect_id):
 
 def validate_effects(allowed_effects):
     def validator(value):
-        value = cv.validate_registry('effect', EFFECTS_REGISTRY)(value)
+        value = cv.validate_registry("effect", EFFECTS_REGISTRY)(value)
         errors = []
         names = set()
         for i, x in enumerate(value):
             key = next(it for it in x.keys())
             if key not in allowed_effects:
                 errors.append(
-                    cv.Invalid("The effect '{}' is not allowed for this "
-                               "light type".format(key), [i])
+                    cv.Invalid(
+                        "The effect '{}' is not allowed for this "
+                        "light type".format(key),
+                        [i],
+                    )
                 )
                 continue
             name = x[key][CONF_NAME]
             if name in names:
                 errors.append(
-                    cv.Invalid("Found the effect name '{}' twice. All effects must have "
-                               "unique names".format(name), [i])
+                    cv.Invalid(
+                        "Found the effect name '{}' twice. All effects must have "
+                        "unique names".format(name),
+                        [i],
+                    )
                 )
                 continue
             names.add(name)