How to use the esphome.config_validation.Required function in esphome

import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor, rdm6300
from esphome.const import CONF_UID, CONF_ID
from . import rdm6300_ns

DEPENDENCIES = ['rdm6300']

CONF_RDM6300_ID = 'rdm6300_id'
RDM6300BinarySensor = rdm6300_ns.class_('RDM6300BinarySensor', binary_sensor.BinarySensor)

CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
    cv.GenerateID(): cv.declare_id(RDM6300BinarySensor),
    cv.GenerateID(CONF_RDM6300_ID): cv.use_id(rdm6300.RDM6300Component),
    cv.Required(CONF_UID): cv.uint32_t,
})


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield binary_sensor.register_binary_sensor(var, config)

    hub = yield cg.get_variable(config[CONF_RDM6300_ID])
    cg.add(hub.register_card(var))
    cg.add(var.set_id(config[CONF_UID]))

import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import light, output
from esphome.const import CONF_BLUE, CONF_GREEN, CONF_RED, CONF_OUTPUT_ID, CONF_COLD_WHITE, \
    CONF_WARM_WHITE, CONF_COLD_WHITE_COLOR_TEMPERATURE, \
    CONF_WARM_WHITE_COLOR_TEMPERATURE

rgbww_ns = cg.esphome_ns.namespace('rgbww')
RGBWWLightOutput = rgbww_ns.class_('RGBWWLightOutput', light.LightOutput)

CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
    cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(RGBWWLightOutput),
    cv.Required(CONF_RED): cv.use_id(output.FloatOutput),
    cv.Required(CONF_GREEN): cv.use_id(output.FloatOutput),
    cv.Required(CONF_BLUE): cv.use_id(output.FloatOutput),
    cv.Required(CONF_COLD_WHITE): cv.use_id(output.FloatOutput),
    cv.Required(CONF_WARM_WHITE): cv.use_id(output.FloatOutput),
    cv.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
    cv.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
})


def to_code(config):
    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
    yield light.register_light(var, config)

    red = yield cg.get_variable(config[CONF_RED])
    cg.add(var.set_red(red))
    green = yield cg.get_variable(config[CONF_GREEN])
    cg.add(var.set_green(green))

def validate_wait_until(value):
    schema = cv.Schema({
        cv.Required(CONF_CONDITION): validate_potentially_and_condition,
    })
    if isinstance(value, dict) and CONF_CONDITION in value:
        return schema(value)
    return validate_wait_until({CONF_CONDITION: value})

import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
from .. import custom_ns

CustomBinarySensorConstructor = custom_ns.class_('CustomBinarySensorConstructor')

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID(): cv.declare_id(CustomBinarySensorConstructor),
    cv.Required(CONF_LAMBDA): cv.returning_lambda,
    cv.Required(CONF_BINARY_SENSORS): cv.ensure_list(binary_sensor.BINARY_SENSOR_SCHEMA),
})


def to_code(config):
    template_ = yield cg.process_lambda(
        config[CONF_LAMBDA], [], return_type=cg.std_vector.template(binary_sensor.BinarySensorPtr))

    rhs = CustomBinarySensorConstructor(template_)
    custom = cg.variable(config[CONF_ID], rhs)
    for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
        rhs = custom.Pget_binary_sensor(i)
        yield binary_sensor.register_binary_sensor(rhs, conf)

from .. import gpio_ns

GPIOSwitch = gpio_ns.class_('GPIOSwitch', switch.Switch, cg.Component)
GPIOSwitchRestoreMode = gpio_ns.enum('GPIOSwitchRestoreMode')

RESTORE_MODES = {
    'RESTORE_DEFAULT_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_OFF,
    'RESTORE_DEFAULT_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_ON,
    'ALWAYS_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_OFF,
    'ALWAYS_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_ON,
}

CONF_INTERLOCK_WAIT_TIME = 'interlock_wait_time'
CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend({
    cv.GenerateID(): cv.declare_id(GPIOSwitch),
    cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
    cv.Optional(CONF_RESTORE_MODE, default='RESTORE_DEFAULT_OFF'):
        cv.enum(RESTORE_MODES, upper=True, space='_'),
    cv.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_id(switch.Switch)),
    cv.Optional(CONF_INTERLOCK_WAIT_TIME, default='0ms'): cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA)


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield switch.register_switch(var, config)

    pin = yield cg.gpio_pin_expression(config[CONF_PIN])
    cg.add(var.set_pin(pin))

    cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))

hx711_ns = cg.esphome_ns.namespace('hx711')
HX711Sensor = hx711_ns.class_('HX711Sensor', sensor.Sensor, cg.PollingComponent)

CONF_DOUT_PIN = 'dout_pin'

HX711Gain = hx711_ns.enum('HX711Gain')
GAINS = {
    128: HX711Gain.HX711_GAIN_128,
    32: HX711Gain.HX711_GAIN_32,
    64: HX711Gain.HX711_GAIN_64,
}

CONFIG_SCHEMA = sensor.sensor_schema('', ICON_SCALE, 0).extend({
    cv.GenerateID(): cv.declare_id(HX711Sensor),
    cv.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
    cv.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
    cv.Optional(CONF_GAIN, default=128): cv.enum(GAINS, int=True),
}).extend(cv.polling_component_schema('60s'))


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield sensor.register_sensor(var, config)

    dout_pin = yield cg.gpio_pin_expression(config[CONF_DOUT_PIN])
    cg.add(var.set_dout_pin(dout_pin))
    sck_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
    cg.add(var.set_sck_pin(sck_pin))
    cg.add(var.set_gain(config[CONF_GAIN]))

camera_range_param = cv.int_range(min=-2, max=2)

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID(): cv.declare_id(ESP32Camera),
    cv.Required(CONF_NAME): cv.string,
    cv.Required(CONF_DATA_PINS): cv.All([pins.input_pin], cv.Length(min=8, max=8)),
    cv.Required(CONF_VSYNC_PIN): pins.input_pin,
    cv.Required(CONF_HREF_PIN): pins.input_pin,
    cv.Required(CONF_PIXEL_CLOCK_PIN): pins.input_pin,
    cv.Required(CONF_EXTERNAL_CLOCK): cv.Schema({
        cv.Required(CONF_PIN): pins.output_pin,
        cv.Optional(CONF_FREQUENCY, default='20MHz'): cv.All(cv.frequency, cv.one_of(20e6, 10e6)),
    }),
    cv.Required(CONF_I2C_PINS): cv.Schema({
        cv.Required(CONF_SDA): pins.output_pin,
        cv.Required(CONF_SCL): pins.output_pin,
    }),
    cv.Optional(CONF_RESET_PIN): pins.output_pin,
    cv.Optional(CONF_POWER_DOWN_PIN): pins.output_pin,

    cv.Optional(CONF_MAX_FRAMERATE, default='10 fps'): cv.All(cv.framerate,
                                                              cv.Range(min=0, min_included=False,
                                                                       max=60)),
    cv.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'): cv.All(cv.framerate,
                                                                cv.Range(min=0, max=1)),
    cv.Optional(CONF_RESOLUTION, default='640X480'): cv.enum(FRAME_SIZES, upper=True),
    cv.Optional(CONF_JPEG_QUALITY, default=10): cv.int_range(min=10, max=63),
    cv.Optional(CONF_CONTRAST, default=0): camera_range_param,
    cv.Optional(CONF_BRIGHTNESS, default=0): camera_range_param,
    cv.Optional(CONF_SATURATION, default=0): camera_range_param,
    cv.Optional(CONF_VERTICAL_FLIP, default=True): cv.boolean,

CONF_POWER_DOWN_PIN = 'power_down_pin'

CONF_MAX_FRAMERATE = 'max_framerate'
CONF_IDLE_FRAMERATE = 'idle_framerate'
CONF_JPEG_QUALITY = 'jpeg_quality'
CONF_VERTICAL_FLIP = 'vertical_flip'
CONF_HORIZONTAL_MIRROR = 'horizontal_mirror'
CONF_CONTRAST = 'contrast'
CONF_SATURATION = 'saturation'
CONF_TEST_PATTERN = 'test_pattern'

camera_range_param = cv.int_range(min=-2, max=2)

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID(): cv.declare_id(ESP32Camera),
    cv.Required(CONF_NAME): cv.string,
    cv.Required(CONF_DATA_PINS): cv.All([pins.input_pin], cv.Length(min=8, max=8)),
    cv.Required(CONF_VSYNC_PIN): pins.input_pin,
    cv.Required(CONF_HREF_PIN): pins.input_pin,
    cv.Required(CONF_PIXEL_CLOCK_PIN): pins.input_pin,
    cv.Required(CONF_EXTERNAL_CLOCK): cv.Schema({
        cv.Required(CONF_PIN): pins.output_pin,
        cv.Optional(CONF_FREQUENCY, default='20MHz'): cv.All(cv.frequency, cv.one_of(20e6, 10e6)),
    }),
    cv.Required(CONF_I2C_PINS): cv.Schema({
        cv.Required(CONF_SDA): pins.output_pin,
        cv.Required(CONF_SCL): pins.output_pin,
    }),
    cv.Optional(CONF_RESET_PIN): pins.output_pin,
    cv.Optional(CONF_POWER_DOWN_PIN): pins.output_pin,

    cv.Optional(CONF_MAX_FRAMERATE, default='10 fps'): cv.All(cv.framerate,

cv.Required(CONF_ID): cv.use_id(LightState),
    cv.Optional(CONF_STATE): cv.templatable(cv.boolean),
    cv.Exclusive(CONF_TRANSITION_LENGTH, 'transformer'):
        cv.templatable(cv.positive_time_period_milliseconds),
    cv.Exclusive(CONF_FLASH_LENGTH, 'transformer'):
        cv.templatable(cv.positive_time_period_milliseconds),
    cv.Exclusive(CONF_EFFECT, 'transformer'): cv.templatable(cv.string),
    cv.Optional(CONF_BRIGHTNESS): cv.templatable(cv.percentage),
    cv.Optional(CONF_RED): cv.templatable(cv.percentage),
    cv.Optional(CONF_GREEN): cv.templatable(cv.percentage),
    cv.Optional(CONF_BLUE): cv.templatable(cv.percentage),
    cv.Optional(CONF_WHITE): cv.templatable(cv.percentage),
    cv.Optional(CONF_COLOR_TEMPERATURE): cv.templatable(cv.color_temperature),
})
LIGHT_TURN_OFF_ACTION_SCHEMA = automation.maybe_simple_id({
    cv.Required(CONF_ID): cv.use_id(LightState),
    cv.Optional(CONF_TRANSITION_LENGTH): cv.templatable(cv.positive_time_period_milliseconds),
    cv.Optional(CONF_STATE, default=False): False,
})
LIGHT_TURN_ON_ACTION_SCHEMA = automation.maybe_simple_id(LIGHT_CONTROL_ACTION_SCHEMA.extend({
    cv.Optional(CONF_STATE, default=True): True,
}))


@automation.register_action('light.turn_off', LightControlAction, LIGHT_TURN_OFF_ACTION_SCHEMA)
@automation.register_action('light.turn_on', LightControlAction, LIGHT_TURN_ON_ACTION_SCHEMA)
@automation.register_action('light.control', LightControlAction, LIGHT_CONTROL_ACTION_SCHEMA)
def light_control_to_code(config, action_id, template_arg, args):
    paren = yield cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    if CONF_STATE in config:
        template_ = yield cg.templatable(config[CONF_STATE], args, bool)

def validate_optional_icon(config):
    if CONF_ICON not in config:
        config = config.copy()
        config[CONF_ICON] = {
            'sunset': ICON_WEATHER_SUNSET_DOWN,
            'sunrise': ICON_WEATHER_SUNSET_UP,
        }[config[CONF_TYPE]]
    return config


CONFIG_SCHEMA = cv.All(text_sensor.TEXT_SENSOR_SCHEMA.extend({
    cv.GenerateID(): cv.declare_id(SunTextSensor),
    cv.GenerateID(CONF_SUN_ID): cv.use_id(Sun),
    cv.Required(CONF_TYPE): cv.one_of(*SUN_TYPES, lower=True),
    cv.Optional(CONF_ELEVATION, default=DEFAULT_ELEVATION): elevation,
    cv.Optional(CONF_FORMAT, default='%X'): cv.string_strict,
}).extend(cv.polling_component_schema('60s')), validate_optional_icon)


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield text_sensor.register_text_sensor(var, config)

    paren = yield cg.get_variable(config[CONF_SUN_ID])
    cg.add(var.set_parent(paren))
    cg.add(var.set_sunrise(SUN_TYPES[config[CONF_TYPE]]))
    cg.add(var.set_elevation(config[CONF_ELEVATION]))
    cg.add(var.set_format(config[CONF_FORMAT]))