[components] Set optional plain values with cg.add_optional (n-z) (#21183)

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>

esphome/components/nextion/base_component.py

@@ -128,8 +128,6 @@ async def setup_component_core_(var, config, arg):
         var.set_foreground_pressed_color, config.get(CONF_FOREGROUND_PRESSED_COLOR)
     )
 
-    if CONF_FONT_ID in config:
-        cg.add(var.set_font_id(config[CONF_FONT_ID]))
+    cg.add_optional(var.set_font_id, config.get(CONF_FONT_ID))
 
-    if CONF_VISIBLE in config:
-        cg.add(var.set_visible(config[CONF_VISIBLE]))
+    cg.add_optional(var.set_visible, config.get(CONF_VISIBLE))

esphome/components/nextion/display.py

@@ -228,8 +228,7 @@ async def to_code(config):
 
     cg.add(var.set_startup_override_ms(config[CONF_STARTUP_OVERRIDE_MS]))
 
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
+    cg.add_optional(var.set_brightness, config.get(CONF_BRIGHTNESS))
 
     await display.add_writer(var, config, nextion_ref)
 
@@ -265,11 +264,9 @@ async def to_code(config):
         elif CORE.is_esp8266:
             cg.add_library("ESP8266HTTPClient", None)
 
-    if CONF_TOUCH_SLEEP_TIMEOUT in config:
-        cg.add(var.set_touch_sleep_timeout(config[CONF_TOUCH_SLEEP_TIMEOUT]))
+    cg.add_optional(var.set_touch_sleep_timeout, config.get(CONF_TOUCH_SLEEP_TIMEOUT))
 
-    if CONF_WAKE_UP_PAGE in config:
-        cg.add(var.set_wake_up_page(config[CONF_WAKE_UP_PAGE]))
+    cg.add_optional(var.set_wake_up_page, config.get(CONF_WAKE_UP_PAGE))
 
     if CONF_START_UP_PAGE in config:
         cg.add_define("USE_NEXTION_CONF_START_UP_PAGE")

esphome/components/nextion/sensor/__init__.py

@@ -74,11 +74,9 @@ async def to_code(config):
 
     await setup_component_core_(var, config, ".val")
 
-    if CONF_PRECISION in config:
-        cg.add(var.set_precision(config[CONF_PRECISION]))
+    cg.add_optional(var.set_precision, config.get(CONF_PRECISION))
 
-    if CONF_COMPONENT_ID in config:
-        cg.add(var.set_component_id(config[CONF_COMPONENT_ID]))
+    cg.add_optional(var.set_component_id, config.get(CONF_COMPONENT_ID))
 
     if CONF_WAVE_CHANNEL_ID in config:
         cg.add_define("USE_NEXTION_WAVEFORM")
@@ -87,10 +85,8 @@ async def to_code(config):
             cg.add(
                 var.set_waveform_send_last_value(config[CONF_WAVEFORM_SEND_LAST_VALUE])
             )
-        if CONF_WAVE_MAX_VALUE in config:
-            cg.add(var.set_wave_max_value(config[CONF_WAVE_MAX_VALUE]))
-        if CONF_WAVE_MAX_LENGTH in config:
-            cg.add(var.set_wave_max_length(config[CONF_WAVE_MAX_LENGTH]))
+        cg.add_optional(var.set_wave_max_value, config.get(CONF_WAVE_MAX_VALUE))
+        cg.add_optional(var.set_wave_max_length, config.get(CONF_WAVE_MAX_LENGTH))
 
 
 automation.register_apply_action(

esphome/components/nfc/binary_sensor/__init__.py

@@ -68,8 +68,7 @@ async def to_code(config: ConfigType) -> None:
     hub = await cg.get_variable(config[CONF_NFCC_ID])
     _request_listener_slot(str(hub))
     cg.add(hub.register_listener(var))
-    if CONF_NDEF_CONTAINS in config:
-        cg.add(var.set_ndef_match_string(config[CONF_NDEF_CONTAINS]))
+    cg.add_optional(var.set_ndef_match_string, config.get(CONF_NDEF_CONTAINS))
     if CONF_TAG_ID in config:
         cg.add(var.set_tag_name(config[CONF_TAG_ID]))
     elif CONF_UID in config:

esphome/components/number/__init__.py

@@ -354,10 +354,8 @@ async def number_in_range_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(condition_id, template_arg, paren)
 
-    if (above := config.get(CONF_ABOVE)) is not None:
-        cg.add(var.set_min(above))
-    if (below := config.get(CONF_BELOW)) is not None:
-        cg.add(var.set_max(below))
+    cg.add_optional(var.set_min, config.get(CONF_ABOVE))
+    cg.add_optional(var.set_max, config.get(CONF_BELOW))
 
     return var
 

esphome/components/one_wire/__init__.py

@@ -38,7 +38,5 @@ async def register_one_wire_device(var: MockObj, config: ConfigType) -> None:
     This is a coroutine, you need to await it with an 'await' expression!
     """
     await cg.add_variable(var.set_one_wire_bus, config[CONF_ONE_WIRE_ID])
-    if (address := config.get(CONF_ADDRESS)) is not None:
-        cg.add(var.set_address(address))
-    if (index := config.get(CONF_INDEX)) is not None:
-        cg.add(var.set_index(index))
+    cg.add_optional(var.set_address, config.get(CONF_ADDRESS))
+    cg.add_optional(var.set_index, config.get(CONF_INDEX))

esphome/components/opentherm/number/__init__.py

@@ -31,10 +31,8 @@ async def new_openthermnumber(config: dict[str, Any]) -> cg.Pvariable:
     await cg.register_component(var, config)
     input.generate_setters(var, config)
 
-    if (initial_value := config.get(CONF_INITIAL_VALUE)) is not None:
-        cg.add(var.set_initial_value(initial_value))
-    if (restore_value := config.get(CONF_RESTORE_VALUE)) is not None:
-        cg.add(var.set_restore_value(restore_value))
+    cg.add_optional(var.set_initial_value, config.get(CONF_INITIAL_VALUE))
+    cg.add_optional(var.set_restore_value, config.get(CONF_RESTORE_VALUE))
 
     return var
 

esphome/components/openthread/__init__.py

@@ -566,8 +566,7 @@ async def to_code(config: ConfigType) -> None:
         )
     add_use_address(ot, config[CONF_USE_ADDRESS])
     await cg.register_component(ot, config)
-    if (poll_period := config.get(CONF_POLL_PERIOD)) is not None:
-        cg.add(ot.set_poll_period(poll_period))
+    cg.add_optional(ot.set_poll_period, config.get(CONF_POLL_PERIOD))
 
     if not border_router:
         mdns_component = await cg.get_variable(config[CONF_MDNS_ID])
@@ -575,8 +574,7 @@ async def to_code(config: ConfigType) -> None:
         cg.add(srp.set_mdns(mdns_component))
         await cg.register_component(srp, config)
 
-    if (output_power := config.get(CONF_OUTPUT_POWER)) is not None:
-        cg.add(ot.set_output_power(output_power))
+    cg.add_optional(ot.set_output_power, config.get(CONF_OUTPUT_POWER))
 
     if CORE.is_esp32:
         set_sdkconfig_options(config)

esphome/components/output/__init__.py

@@ -57,8 +57,7 @@ FloatOutputPtr = FloatOutput.operator("ptr")
 
 
 async def setup_output_platform_(obj, config):
-    if CONF_INVERTED in config:
-        cg.add(obj.set_inverted(config[CONF_INVERTED]))
+    cg.add_optional(obj.set_inverted, config.get(CONF_INVERTED))
     await cg.add_variable(obj.set_power_supply, config.get(CONF_POWER_SUPPLY))
     # The C++ initializers are max_power 1.0 and min_power 0.0; skip the setter when
     # the config matches them. The define stays whenever the key is present because

esphome/components/pca9685/__init__.py

@@ -53,8 +53,7 @@ CONFIG_SCHEMA = cv.All(
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
-    if CONF_FREQUENCY in config:
-        cg.add(var.set_frequency(config[CONF_FREQUENCY]))
+    cg.add_optional(var.set_frequency, config.get(CONF_FREQUENCY))
     cg.add(var.set_extclk(config[CONF_EXTERNAL_CLOCK_INPUT]))
     cg.add(var.set_phase_balancer(config[CONF_PHASE_BALANCER]))
     await cg.register_component(var, config)

esphome/components/pn71xx/__init__.py

@@ -134,8 +134,7 @@ async def setup_pn71xx(var: MockObj, config: ConfigType) -> None:
         cg.add(var.set_tag_emulation_message(emulation_message_config))
         cg.add(var.set_tag_emulation_on())
 
-    if (tag_ttl := config.get(CONF_TAG_TTL)) is not None:
-        cg.add(var.set_tag_ttl(tag_ttl))
+    cg.add_optional(var.set_tag_ttl, config.get(CONF_TAG_TTL))
 
     for conf in config.get(CONF_ON_TAG, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])

esphome/components/rd03d/__init__.py

@@ -43,8 +43,6 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 async def to_code(config: ConfigType) -> None:
     var = await uart.new_uart_component(config)
 
-    if CONF_TRACKING_MODE in config:
-        cg.add(var.set_tracking_mode(config[CONF_TRACKING_MODE]))
+    cg.add_optional(var.set_tracking_mode, config.get(CONF_TRACKING_MODE))
 
-    if CONF_THROTTLE in config:
-        cg.add(var.set_throttle(config[CONF_THROTTLE]))
+    cg.add_optional(var.set_throttle, config.get(CONF_THROTTLE))

esphome/components/remote_base/__init__.py

@@ -2709,10 +2709,8 @@ def abbwelcome_binary_sensor(var, config):
     cg.add(var.set_retransmission(config[CONF_RETRANSMISSION]))
     cg.add(var.set_message_type(config[CONF_MESSAGE_TYPE]))
     cg.add(var.set_auto_message_id(CONF_MESSAGE_ID not in config))
-    if CONF_MESSAGE_ID in config:
-        cg.add(var.set_message_id(config[CONF_MESSAGE_ID]))
-    if CONF_DATA in config:
-        cg.add(var.set_data(config[CONF_DATA]))
+    cg.add_optional(var.set_message_id, config.get(CONF_MESSAGE_ID))
+    cg.add_optional(var.set_data, config.get(CONF_DATA))
     cg.add(var.finalize())
 
 

esphome/components/remote_receiver/__init__.py

@@ -213,12 +213,9 @@ async def to_code(config: ConfigType) -> None:
         var = cg.new_Pvariable(config[CONF_ID], pin)
         cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
         cg.add(var.set_receive_symbols(config[CONF_RECEIVE_SYMBOLS]))
-        if CONF_USE_DMA in config:
-            cg.add(var.set_with_dma(config[CONF_USE_DMA]))
-        if CONF_CLOCK_RESOLUTION in config:
-            cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
-        if CONF_FILTER_SYMBOLS in config:
-            cg.add(var.set_filter_symbols(config[CONF_FILTER_SYMBOLS]))
+        cg.add_optional(var.set_with_dma, config.get(CONF_USE_DMA))
+        cg.add_optional(var.set_clock_resolution, config.get(CONF_CLOCK_RESOLUTION))
+        cg.add_optional(var.set_filter_symbols, config.get(CONF_FILTER_SYMBOLS))
         cg.add(var.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))
         cg.add(var.set_carrier_frequency(config[CONF_CARRIER_FREQUENCY]))
     else:
@@ -238,8 +235,7 @@ async def to_code(config: ConfigType) -> None:
             config[CONF_TOLERANCE][CONF_VALUE], config[CONF_TOLERANCE][CONF_TYPE]
         )
     )
-    if CONF_BUFFER_SIZE in config:
-        cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
+    cg.add_optional(var.set_buffer_size, config.get(CONF_BUFFER_SIZE))
     cg.add(var.set_filter_us(config[CONF_FILTER]))
     cg.add(var.set_idle_us(config[CONF_IDLE]))
 

esphome/components/remote_transmitter/__init__.py

@@ -150,10 +150,8 @@ async def to_code(config: ConfigType) -> None:
         var = cg.new_Pvariable(config[CONF_ID], pin)
         cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
         cg.add(var.set_non_blocking(config[CONF_NON_BLOCKING]))
-        if CONF_CLOCK_RESOLUTION in config:
-            cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
-        if CONF_USE_DMA in config:
-            cg.add(var.set_with_dma(config[CONF_USE_DMA]))
+        cg.add_optional(var.set_clock_resolution, config.get(CONF_CLOCK_RESOLUTION))
+        cg.add_optional(var.set_with_dma, config.get(CONF_USE_DMA))
         if CONF_EOT_LEVEL in config:
             cg.add(var.set_eot_level(config[CONF_EOT_LEVEL]))
         else:
@@ -165,8 +163,7 @@ async def to_code(config: ConfigType) -> None:
             )
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
-        if (non_blocking := config.get(CONF_NON_BLOCKING)) is not None:
-            cg.add(var.set_non_blocking(non_blocking))
+        cg.add_optional(var.set_non_blocking, config.get(CONF_NON_BLOCKING))
     await cg.register_component(var, config)
 
     cg.add(var.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))

esphome/components/rotary_encoder/sensor.py

@@ -100,10 +100,8 @@ async def to_code(config: ConfigType) -> None:
 
     await cg.add_pin(var.set_reset_pin, config.get(CONF_PIN_RESET))
     cg.add(var.set_resolution(config[CONF_RESOLUTION]))
-    if CONF_MIN_VALUE in config:
-        cg.add(var.set_min_value(config[CONF_MIN_VALUE]))
-    if CONF_MAX_VALUE in config:
-        cg.add(var.set_max_value(config[CONF_MAX_VALUE]))
+    cg.add_optional(var.set_min_value, config.get(CONF_MIN_VALUE))
+    cg.add_optional(var.set_max_value, config.get(CONF_MAX_VALUE))
 
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 

esphome/components/scd30/sensor.py

@@ -91,8 +91,7 @@ async def to_code(config: ConfigType) -> None:
             )
         )
 
-    if CONF_TEMPERATURE_OFFSET in config:
-        cg.add(var.set_temperature_offset(config[CONF_TEMPERATURE_OFFSET]))
+    cg.add_optional(var.set_temperature_offset, config.get(CONF_TEMPERATURE_OFFSET))
 
     cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
 

esphome/components/sdl/display.py

@@ -157,8 +157,7 @@ async def to_code(config: ConfigType) -> None:
     await display.register_display(var, config)
     await register_snapshot(var, config)
     cg.add(var.set_headless(config[CONF_HEADLESS]))
-    if (key := config.get(CONF_SNAPSHOT_KEY)) is not None:
-        cg.add(var.set_snapshot_key(key))
+    cg.add_optional(var.set_snapshot_key, config.get(CONF_SNAPSHOT_KEY))
 
     dimensions = config[CONF_DIMENSIONS]
     if isinstance(dimensions, dict):

esphome/components/sen5x/sensor.py

@@ -225,8 +225,7 @@ async def to_code(config: ConfigType) -> None:
         if cfg := config.get(key):
             cg.add(getattr(var, funcName)(cfg))
 
-    if (model := config.get(CONF_MODEL)) is not None:
-        cg.add(var.set_model(model))
+    cg.add_optional(var.set_model, config.get(CONF_MODEL))
 
     for key, funcName in SENSOR_MAP.items():
         if cfg := config.get(key):

esphome/components/sen6x/sensor.py

@@ -272,8 +272,7 @@ SENSOR_MAP = {
 async def to_code(config: ConfigType) -> None:
     var = await i2c.new_i2c_component(config)
 
-    if CONF_TYPE in config:
-        cg.add(var.set_type(config[CONF_TYPE]))
+    cg.add_optional(var.set_type, config.get(CONF_TYPE))
     # The number concentration read and its sensors compile in only when one is configured
     if any(key in config for key in _PMC_KEYS):
         cg.add_define("USE_SEN6X_NUMBER_CONCENTRATION")

esphome/components/sensor/__init__.py

@@ -1046,10 +1046,8 @@ async def _build_sensor_automations(var, config):
 async def setup_sensor_core_(var, config):
     setup_device_class(config)
     setup_unit_of_measurement(config)
-    if (state_class := config.get(CONF_STATE_CLASS)) is not None:
-        cg.add(var.set_state_class(state_class))
-    if (accuracy_decimals := config.get(CONF_ACCURACY_DECIMALS)) is not None:
-        cg.add(var.set_accuracy_decimals(accuracy_decimals))
+    cg.add_optional(var.set_state_class, config.get(CONF_STATE_CLASS))
+    cg.add_optional(var.set_accuracy_decimals, config.get(CONF_ACCURACY_DECIMALS))
     # Only set force_update if True (default is False)
     if config[CONF_FORCE_UPDATE]:
         cg.add(var.set_force_update(True))
@@ -1117,10 +1115,8 @@ async def sensor_in_range_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(condition_id, template_arg, paren)
 
-    if (above := config.get(CONF_ABOVE)) is not None:
-        cg.add(var.set_min(above))
-    if (below := config.get(CONF_BELOW)) is not None:
-        cg.add(var.set_max(below))
+    cg.add_optional(var.set_min, config.get(CONF_ABOVE))
+    cg.add_optional(var.set_max, config.get(CONF_BELOW))
 
     return var
 

esphome/components/sgp30/sensor.py

@@ -90,8 +90,7 @@ async def to_code(config: ConfigType) -> None:
     await sensors(CONF_ECO2_BASELINE, var.set_eco2_baseline_sensor)
     await sensors(CONF_TVOC_BASELINE, var.set_tvoc_baseline_sensor)
 
-    if (store_baseline := config.get(CONF_STORE_BASELINE)) is not None:
-        cg.add(var.set_store_baseline(store_baseline))
+    cg.add_optional(var.set_store_baseline, config.get(CONF_STORE_BASELINE))
 
     if baseline_config := config.get(CONF_BASELINE):
         cg.add(var.set_eco2_baseline(baseline_config[CONF_ECO2_BASELINE]))

esphome/components/speed/fan/__init__.py

@@ -42,5 +42,4 @@ async def to_code(config: ConfigType) -> None:
     await cg.add_variable(var.set_oscillating, config.get(CONF_OSCILLATION_OUTPUT))
     await cg.add_variable(var.set_direction, config.get(CONF_DIRECTION_OUTPUT))
 
-    if CONF_PRESET_MODES in config:
-        cg.add(var.set_preset_modes(config[CONF_PRESET_MODES]))
+    cg.add_optional(var.set_preset_modes, config.get(CONF_PRESET_MODES))

esphome/components/sps30/sensor.py

@@ -134,8 +134,7 @@ async def to_code(config: ConfigType) -> None:
     if CONF_AUTO_CLEANING_INTERVAL in config:
         cg.add(var.set_auto_cleaning_interval(config[CONF_AUTO_CLEANING_INTERVAL]))
 
-    if CONF_IDLE_INTERVAL in config:
-        cg.add(var.set_idle_interval(config[CONF_IDLE_INTERVAL]))
+    cg.add_optional(var.set_idle_interval, config.get(CONF_IDLE_INTERVAL))
 
 
 SPS30_ACTION_SCHEMA = maybe_simple_id(

esphome/components/ssd1306_base/__init__.py

@@ -81,20 +81,12 @@ async def setup_ssd1306(var: MockObj, config: ConfigType) -> None:
 
     cg.add(var.set_model(config[CONF_MODEL]))
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
-    if CONF_CONTRAST in config:
-        cg.add(var.init_contrast(config[CONF_CONTRAST]))
-    if CONF_EXTERNAL_VCC in config:
-        cg.add(var.set_external_vcc(config[CONF_EXTERNAL_VCC]))
-    if CONF_FLIP_X in config:
-        cg.add(var.init_flip_x(config[CONF_FLIP_X]))
-    if CONF_FLIP_Y in config:
-        cg.add(var.init_flip_y(config[CONF_FLIP_Y]))
-    if CONF_OFFSET_X in config:
-        cg.add(var.init_offset_x(config[CONF_OFFSET_X]))
-    if CONF_OFFSET_Y in config:
-        cg.add(var.init_offset_y(config[CONF_OFFSET_Y]))
-    if CONF_INVERT in config:
-        cg.add(var.init_invert(config[CONF_INVERT]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
+    cg.add_optional(var.init_contrast, config.get(CONF_CONTRAST))
+    cg.add_optional(var.set_external_vcc, config.get(CONF_EXTERNAL_VCC))
+    cg.add_optional(var.init_flip_x, config.get(CONF_FLIP_X))
+    cg.add_optional(var.init_flip_y, config.get(CONF_FLIP_Y))
+    cg.add_optional(var.init_offset_x, config.get(CONF_OFFSET_X))
+    cg.add_optional(var.init_offset_y, config.get(CONF_OFFSET_Y))
+    cg.add_optional(var.init_invert, config.get(CONF_INVERT))
     await display.add_writer(var, config)

esphome/components/ssd1322_base/__init__.py

@@ -34,8 +34,6 @@ async def setup_ssd1322(var: MockObj, config: ConfigType) -> None:
 
     cg.add(var.set_model(config[CONF_MODEL]))
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
-    if CONF_EXTERNAL_VCC in config:
-        cg.add(var.set_external_vcc(config[CONF_EXTERNAL_VCC]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
+    cg.add_optional(var.set_external_vcc, config.get(CONF_EXTERNAL_VCC))
     await display.add_writer(var, config)

esphome/components/ssd1325_base/__init__.py

@@ -38,8 +38,6 @@ async def setup_ssd1325(var: MockObj, config: ConfigType) -> None:
 
     cg.add(var.set_model(config[CONF_MODEL]))
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
-    if CONF_EXTERNAL_VCC in config:
-        cg.add(var.set_external_vcc(config[CONF_EXTERNAL_VCC]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
+    cg.add_optional(var.set_external_vcc, config.get(CONF_EXTERNAL_VCC))
     await display.add_writer(var, config)

esphome/components/ssd1327_base/__init__.py

@@ -33,6 +33,5 @@ async def setup_ssd1327(var: MockObj, config: ConfigType) -> None:
 
     cg.add(var.set_model(config[CONF_MODEL]))
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
     await display.add_writer(var, config)

esphome/components/ssd1331_base/__init__.py

@@ -24,6 +24,5 @@ async def setup_ssd1331(var: MockObj, config: ConfigType) -> None:
     await display.register_display(var, config)
 
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
     await display.add_writer(var, config)

esphome/components/ssd1351_base/__init__.py

@@ -34,6 +34,5 @@ async def setup_ssd1351(var: MockObj, config: ConfigType) -> None:
 
     cg.add(var.set_model(config[CONF_MODEL]))
     await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
-    if CONF_BRIGHTNESS in config:
-        cg.add(var.init_brightness(config[CONF_BRIGHTNESS]))
+    cg.add_optional(var.init_brightness, config.get(CONF_BRIGHTNESS))
     await display.add_writer(var, config)

esphome/components/stepper/__init__.py

@@ -75,12 +75,9 @@ STEPPER_SCHEMA = cv.Schema(
 
 
 async def setup_stepper_core_(stepper_var, config):
-    if CONF_ACCELERATION in config:
-        cg.add(stepper_var.set_acceleration(config[CONF_ACCELERATION]))
-    if CONF_DECELERATION in config:
-        cg.add(stepper_var.set_deceleration(config[CONF_DECELERATION]))
-    if CONF_MAX_SPEED in config:
-        cg.add(stepper_var.set_max_speed(config[CONF_MAX_SPEED]))
+    cg.add_optional(stepper_var.set_acceleration, config.get(CONF_ACCELERATION))
+    cg.add_optional(stepper_var.set_deceleration, config.get(CONF_DECELERATION))
+    cg.add_optional(stepper_var.set_max_speed, config.get(CONF_MAX_SPEED))
 
 
 async def register_stepper(var, config):

esphome/components/switch/__init__.py

@@ -146,8 +146,7 @@ async def _build_switch_automations(var, config):
 
 @setup_entity("switch")
 async def setup_switch_core_(var, config):
-    if (inverted := config.get(CONF_INVERTED)) is not None:
-        cg.add(var.set_inverted(inverted))
+    cg.add_optional(var.set_inverted, config.get(CONF_INVERTED))
 
     CORE.add_job(_build_switch_automations, var, config)
 

esphome/components/tcp_uart/__init__.py

@@ -81,5 +81,4 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_data_bits(config[CONF_DATA_BITS]))
     cg.add(var.set_stop_bits(config[CONF_STOP_BITS]))
     cg.add(var.set_parity(config[CONF_PARITY]))
-    if (host := config.get(CONF_HOST)) is not None:
-        cg.add(var.set_host(host))
+    cg.add_optional(var.set_host, config.get(CONF_HOST))

esphome/components/template/fan/__init__.py

@@ -34,8 +34,6 @@ async def to_code(config):
     cg.add(var.set_has_direction(config[CONF_HAS_DIRECTION]))
     cg.add(var.set_has_oscillating(config[CONF_HAS_OSCILLATING]))
 
-    if CONF_SPEED_COUNT in config:
-        cg.add(var.set_speed_count(config[CONF_SPEED_COUNT]))
+    cg.add_optional(var.set_speed_count, config.get(CONF_SPEED_COUNT))
 
-    if CONF_PRESET_MODES in config:
-        cg.add(var.set_preset_modes(config[CONF_PRESET_MODES]))
+    cg.add_optional(var.set_preset_modes, config.get(CONF_PRESET_MODES))

esphome/components/template/number/__init__.py

@@ -92,8 +92,7 @@ async def to_code(config):
     else:
         cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
         cg.add(var.set_initial_value(config[CONF_INITIAL_VALUE]))
-        if CONF_RESTORE_VALUE in config:
-            cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
+        cg.add_optional(var.set_restore_value, config.get(CONF_RESTORE_VALUE))
 
     if CONF_SET_ACTION in config:
         await automation.build_automation(

esphome/components/template/water_heater/__init__.py

@@ -97,8 +97,7 @@ async def to_code(config: ConfigType) -> None:
         )
         cg.add(var.set_mode_lambda(template_))
 
-    if CONF_SUPPORTED_MODES in config:
-        cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
+    cg.add_optional(var.set_supported_modes, config.get(CONF_SUPPORTED_MODES))
 
     if CONF_AWAY in config:
         template_ = await cg.process_lambda(

esphome/components/thermostat/climate.py

@@ -1026,8 +1026,7 @@ async def to_code(config: ConfigType) -> None:
         else:
             cg.add(var.set_default_preset(default_preset_name))
 
-    if CONF_ON_BOOT_RESTORE_FROM in config:
-        cg.add(var.set_on_boot_restore_from(config[CONF_ON_BOOT_RESTORE_FROM]))
+    cg.add_optional(var.set_on_boot_restore_from, config.get(CONF_ON_BOOT_RESTORE_FROM))
 
     if CONF_PRESET_CHANGE in config:
         await automation.build_automation(

esphome/components/tinyusb/__init__.py

@@ -123,8 +123,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_usb_desc_product(config[CONF_USB_PRODUCT_STR]))
     if config[CONF_USB_SERIAL_STR]:
         cg.add(var.set_usb_desc_serial(config[CONF_USB_SERIAL_STR]))
-    if (vbus_pin := config.get(CONF_VBUS_MONITOR_PIN)) is not None:
-        cg.add(var.set_vbus_monitor_pin(vbus_pin))
+    cg.add_optional(var.set_vbus_monitor_pin, config.get(CONF_VBUS_MONITOR_PIN))
 
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 

esphome/components/tmp1075/sensor.py

@@ -74,8 +74,7 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
 
-    if CONF_CONVERSION_RATE in config:
-        cg.add(var.set_conversion_rate(config[CONF_CONVERSION_RATE]))
+    cg.add_optional(var.set_conversion_rate, config.get(CONF_CONVERSION_RATE))
 
     alert = config[CONF_ALERT]
     if CONF_LIMIT_LOW in alert:

esphome/components/touchscreen/__init__.py

@@ -157,8 +157,7 @@ async def register_touchscreen(var: MockObj, config: ConfigType) -> None:
 
     await cg.add_variable(var.set_display, config[CONF_DISPLAY])
 
-    if CONF_TOUCH_TIMEOUT in config:
-        cg.add(var.set_touch_timeout(config[CONF_TOUCH_TIMEOUT]))
+    cg.add_optional(var.set_touch_timeout, config.get(CONF_TOUCH_TIMEOUT))
 
     if CONF_TRANSFORM in config:
         transform = config[CONF_TRANSFORM]

esphome/components/tuya/cover/__init__.py

@@ -57,10 +57,8 @@ async def to_code(config):
     var = await cover.new_cover(config)
     await cg.register_component(var, config)
 
-    if CONF_CONTROL_DATAPOINT in config:
-        cg.add(var.set_control_id(config[CONF_CONTROL_DATAPOINT]))
-    if CONF_DIRECTION_DATAPOINT in config:
-        cg.add(var.set_direction_id(config[CONF_DIRECTION_DATAPOINT]))
+    cg.add_optional(var.set_control_id, config.get(CONF_CONTROL_DATAPOINT))
+    cg.add_optional(var.set_direction_id, config.get(CONF_DIRECTION_DATAPOINT))
     cg.add(var.set_position_id(config[CONF_POSITION_DATAPOINT]))
     if CONF_POSITION_REPORT_DATAPOINT in config:
         cg.add(var.set_position_report_id(config[CONF_POSITION_REPORT_DATAPOINT]))

esphome/components/tuya/fan/__init__.py

@@ -37,11 +37,7 @@ async def to_code(config):
     await cg.register_component(var, config)
     await fan.register_fan(var, config)
 
-    if CONF_SPEED_DATAPOINT in config:
-        cg.add(var.set_speed_id(config[CONF_SPEED_DATAPOINT]))
-    if CONF_SWITCH_DATAPOINT in config:
-        cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT]))
-    if CONF_OSCILLATION_DATAPOINT in config:
-        cg.add(var.set_oscillation_id(config[CONF_OSCILLATION_DATAPOINT]))
-    if CONF_DIRECTION_DATAPOINT in config:
-        cg.add(var.set_direction_id(config[CONF_DIRECTION_DATAPOINT]))
+    cg.add_optional(var.set_speed_id, config.get(CONF_SPEED_DATAPOINT))
+    cg.add_optional(var.set_switch_id, config.get(CONF_SWITCH_DATAPOINT))
+    cg.add_optional(var.set_oscillation_id, config.get(CONF_OSCILLATION_DATAPOINT))
+    cg.add_optional(var.set_direction_id, config.get(CONF_DIRECTION_DATAPOINT))

esphome/components/tuya/light/__init__.py

@@ -80,12 +80,10 @@ async def to_code(config):
     await cg.register_component(var, config)
     await light.register_light(var, config)
 
-    if CONF_DIMMER_DATAPOINT in config:
-        cg.add(var.set_dimmer_id(config[CONF_DIMMER_DATAPOINT]))
+    cg.add_optional(var.set_dimmer_id, config.get(CONF_DIMMER_DATAPOINT))
     if CONF_MIN_VALUE_DATAPOINT in config:
         cg.add(var.set_min_value_datapoint_id(config[CONF_MIN_VALUE_DATAPOINT]))
-    if CONF_SWITCH_DATAPOINT in config:
-        cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT]))
+    cg.add_optional(var.set_switch_id, config.get(CONF_SWITCH_DATAPOINT))
     if CONF_COLOR_DATAPOINT in config:
         cg.add(var.set_color_id(config[CONF_COLOR_DATAPOINT]))
         cg.add(var.set_color_type(config[CONF_COLOR_TYPE]))
@@ -100,10 +98,8 @@ async def to_code(config):
         cg.add(
             var.set_warm_white_temperature(config[CONF_WARM_WHITE_COLOR_TEMPERATURE])
         )
-    if CONF_MIN_VALUE in config:
-        cg.add(var.set_min_value(config[CONF_MIN_VALUE]))
-    if CONF_MAX_VALUE in config:
-        cg.add(var.set_max_value(config[CONF_MAX_VALUE]))
+    cg.add_optional(var.set_min_value, config.get(CONF_MIN_VALUE))
+    cg.add_optional(var.set_max_value, config.get(CONF_MAX_VALUE))
     if CONF_COLOR_TEMPERATURE_MAX_VALUE in config:
         cg.add(
             var.set_color_temperature_max_value(

esphome/components/tuya/water_heater/__init__.py

@@ -115,5 +115,4 @@ async def to_code(config: ConfigType) -> None:
             if (value := config.get(key)) is not None:
                 cg.add(getattr(var, setter)(value))
 
-    if (supported_modes := config.get(CONF_SUPPORTED_MODES)) is not None:
-        cg.add(var.set_supported_modes(supported_modes))
+    cg.add_optional(var.set_supported_modes, config.get(CONF_SUPPORTED_MODES))

esphome/components/uart/__init__.py

@@ -373,8 +373,7 @@ async def to_code(config):
     await cg.add_pin(var.set_tx_pin, config.get(CONF_TX_PIN))
     await cg.add_pin(var.set_rx_pin, config.get(CONF_RX_PIN))
     await cg.add_pin(var.set_flow_control_pin, config.get(CONF_FLOW_CONTROL_PIN))
-    if CONF_PORT in config:
-        cg.add(var.set_name(config[CONF_PORT]))
+    cg.add_optional(var.set_name, config.get(CONF_PORT))
     cg.add(var.set_rx_buffer_size(config[CONF_RX_BUFFER_SIZE]))
     if CORE.is_esp32:
         if CONF_RX_FULL_THRESHOLD not in config:
@@ -391,10 +390,8 @@ async def to_code(config):
             )
         cg.add(var.set_rx_full_threshold(config[CONF_RX_FULL_THRESHOLD]))
         cg.add(var.set_rx_timeout(config[CONF_RX_TIMEOUT]))
-        if CONF_FLUSH_TIMEOUT in config:
-            cg.add(var.set_flush_timeout(config[CONF_FLUSH_TIMEOUT]))
-        if (tx_buffer_size := config.get(CONF_TX_BUFFER_SIZE)) is not None:
-            cg.add(var.set_tx_buffer_size(tx_buffer_size))
+        cg.add_optional(var.set_flush_timeout, config.get(CONF_FLUSH_TIMEOUT))
+        cg.add_optional(var.set_tx_buffer_size, config.get(CONF_TX_BUFFER_SIZE))
         # The member already defaults to UART_SCLK_DEFAULT, so only emit a real choice
         if (clock_source := config.get(CONF_CLOCK_SOURCE, "DEFAULT")) != "DEFAULT":
             cg.add(var.set_clock_source(UART_CLOCK_SOURCES[clock_source]))

esphome/components/uart/switch/__init__.py

@@ -51,5 +51,4 @@ async def to_code(config):
             cg.add(setter(automation.progmem_bytes("uart_data", payload), len(payload)))
     if single_state:
         cg.add(var.set_single_state(True))
-    if CONF_SEND_EVERY in config:
-        cg.add(var.set_send_every(config[CONF_SEND_EVERY]))
+    cg.add_optional(var.set_send_every, config.get(CONF_SEND_EVERY))

esphome/components/uart_tcp/__init__.py

@@ -127,5 +127,4 @@ async def to_code(config: ConfigType) -> None:
         socket.require_tcp_client_link()
     cg.add(var.set_port(config[CONF_PORT]))
     cg.add(var.set_reconnect_interval(config[CONF_RECONNECT_INTERVAL]))
-    if (host := config.get(CONF_HOST)) is not None:
-        cg.add(var.set_host(host))
+    cg.add_optional(var.set_host, config.get(CONF_HOST))

esphome/components/vbus/binary_sensor/__init__.py

@@ -337,12 +337,9 @@ async def to_code(config: ConfigType) -> None:
         await binary_sensors(CONF_SENSOR4_ERROR, var.set_s4_error_bsensor)
 
     elif config[CONF_MODEL] == CONF_CUSTOM:
-        if CONF_COMMAND in config:
-            cg.add(var.set_command(config[CONF_COMMAND]))
-        if CONF_SOURCE in config:
-            cg.add(var.set_source(config[CONF_SOURCE]))
-        if CONF_DEST in config:
-            cg.add(var.set_dest(config[CONF_DEST]))
+        cg.add_optional(var.set_command, config.get(CONF_COMMAND))
+        cg.add_optional(var.set_source, config.get(CONF_SOURCE))
+        cg.add_optional(var.set_dest, config.get(CONF_DEST))
         bsensors = []
         for conf in config[CONF_BINARY_SENSORS]:
             bsens = await binary_sensor.new_binary_sensor(conf)

esphome/components/vbus/sensor/__init__.py

@@ -768,12 +768,9 @@ async def to_code(config: ConfigType) -> None:
         await sensors(CONF_FLOW_RATE, var.set_flow_rate_sensor)
 
     elif config[CONF_MODEL] == CONF_CUSTOM:
-        if CONF_COMMAND in config:
-            cg.add(var.set_command(config[CONF_COMMAND]))
-        if CONF_SOURCE in config:
-            cg.add(var.set_source(config[CONF_SOURCE]))
-        if CONF_DEST in config:
-            cg.add(var.set_dest(config[CONF_DEST]))
+        cg.add_optional(var.set_command, config.get(CONF_COMMAND))
+        cg.add_optional(var.set_source, config.get(CONF_SOURCE))
+        cg.add_optional(var.set_dest, config.get(CONF_DEST))
         custom_sensors = []
         for conf in config[CONF_SENSORS]:
             sens = await sensor.new_sensor(conf)

esphome/components/vevor_dtx/__init__.py

@@ -44,5 +44,4 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     await remote_base.register_listener(var, config)
     cg.add(var.set_bit_time_us(config[CONF_BIT_TIME]))
-    if (station_id := config.get(CONF_STATION_ID)) is not None:
-        cg.add(var.set_station_id(station_id))
+    cg.add_optional(var.set_station_id, config.get(CONF_STATION_ID))

esphome/components/voice_assistant/__init__.py

@@ -213,8 +213,7 @@ async def to_code(config: ConfigType) -> None:
 
     cg.add(var.set_use_wake_word(config[CONF_USE_WAKE_WORD]))
 
-    if (vad_threshold := config.get(CONF_VAD_THRESHOLD)) is not None:
-        cg.add(var.set_vad_threshold(vad_threshold))
+    cg.add_optional(var.set_vad_threshold, config.get(CONF_VAD_THRESHOLD))
 
     cg.add(var.set_noise_suppression_level(config[CONF_NOISE_SUPPRESSION_LEVEL]))
     cg.add(var.set_auto_gain(config[CONF_AUTO_GAIN]))

esphome/components/wifi/__init__.py

@@ -751,19 +751,15 @@ def manual_ip(config):
 
 
 def wifi_network(config, ap, static_ip):
-    if CONF_SSID in config:
-        cg.add(ap.set_ssid(config[CONF_SSID]))
-    if CONF_PASSWORD in config:
-        cg.add(ap.set_password(config[CONF_PASSWORD]))
+    cg.add_optional(ap.set_ssid, config.get(CONF_SSID))
+    cg.add_optional(ap.set_password, config.get(CONF_PASSWORD))
     if CONF_EAP in config:
         cg.add(ap.set_eap(eap_auth(config[CONF_EAP])))
         cg.add_define("USE_WIFI_WPA2_EAP")
     if CONF_BSSID in config:
         cg.add(ap.set_bssid([HexInt(i) for i in config[CONF_BSSID].parts]))
-    if CONF_HIDDEN in config:
-        cg.add(ap.set_hidden(config[CONF_HIDDEN]))
-    if CONF_CHANNEL in config:
-        cg.add(ap.set_channel(config[CONF_CHANNEL]))
+    cg.add_optional(ap.set_hidden, config.get(CONF_HIDDEN))
+    cg.add_optional(ap.set_channel, config.get(CONF_CHANNEL))
     if static_ip is not None:
         cg.add(ap.set_manual_ip(manual_ip(static_ip)))
     # priority_ is 0 in C++; skip the setter when the config matches it.
@@ -952,8 +948,7 @@ async def to_code(config):
             cg.add(var.set_btm(config[CONF_ENABLE_BTM]))
         if config[CONF_ENABLE_RRM]:
             cg.add(var.set_rrm(config[CONF_ENABLE_RRM]))
-        if CONF_BAND_MODE in config:
-            cg.add(var.set_band_mode(config[CONF_BAND_MODE]))
+        cg.add_optional(var.set_band_mode, config.get(CONF_BAND_MODE))
 
     if config.get(CONF_USE_PSRAM):
         add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)

esphome/components/wireguard/__init__.py

@@ -109,8 +109,7 @@ async def to_code(config):
     cg.add(var.set_keepalive(config[CONF_PEER_PERSISTENT_KEEPALIVE]))
     cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
 
-    if CONF_PEER_PRESHARED_KEY in config:
-        cg.add(var.set_preshared_key(config[CONF_PEER_PRESHARED_KEY]))
+    cg.add_optional(var.set_preshared_key, config.get(CONF_PEER_PRESHARED_KEY))
 
     allowed_ips = list(
         ipaddress.collapse_addresses(

esphome/components/xiaomi_cgg1/sensor.py

@@ -61,8 +61,7 @@ async def to_code(config: ConfigType) -> None:
     var = await ble_device_base.new_ble_device_component(config)
 
     cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
-    if CONF_BINDKEY in config:
-        cg.add(var.set_bindkey(config[CONF_BINDKEY]))
+    cg.add_optional(var.set_bindkey, config.get(CONF_BINDKEY))
 
     sensors = sensor.sub_sensors(config)
     await sensors(CONF_TEMPERATURE, var.set_temperature)