from esphome.components import text_sensor
from esphome.const import CONF_STATUS
from . import DalyBmsComponent, CONF_BMS_DALY_ID
ICON_CAR_BATTERY = "mdi:car-battery"
TYPES = [
CONF_STATUS,
]
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID(CONF_BMS_DALY_ID):
cv.use_id(DalyBmsComponent),
cv.Optional(CONF_STATUS):
text_sensor.text_sensor_schema(icon=ICON_CAR_BATTERY),
}).extend(cv.COMPONENT_SCHEMA))
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
sens = await text_sensor.new_text_sensor(conf)
cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
async def to_code(config):
hub = await cg.get_variable(config[CONF_BMS_DALY_ID])
for key in TYPES:
await setup_conf(config, key, hub)
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import text_sensor
from . import Dsmr, CONF_DSMR_ID
AUTO_LOAD = ["dsmr"]
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(CONF_DSMR_ID): cv.use_id(Dsmr),
cv.Optional("identification"): text_sensor.text_sensor_schema(),
cv.Optional("p1_version"): text_sensor.text_sensor_schema(),
cv.Optional("p1_version_be"): text_sensor.text_sensor_schema(),
cv.Optional("timestamp"): text_sensor.text_sensor_schema(),
cv.Optional("electricity_tariff"): text_sensor.text_sensor_schema(),
cv.Optional("electricity_failure_log"): text_sensor.text_sensor_schema(),
cv.Optional("message_short"): text_sensor.text_sensor_schema(),
cv.Optional("message_long"): text_sensor.text_sensor_schema(),
cv.Optional("gas_equipment_id"): text_sensor.text_sensor_schema(),
cv.Optional("thermal_equipment_id"): text_sensor.text_sensor_schema(),
cv.Optional("water_equipment_id"): text_sensor.text_sensor_schema(),
cv.Optional("sub_equipment_id"): text_sensor.text_sensor_schema(),
cv.Optional("gas_delivered_text"): text_sensor.text_sensor_schema(),
}
).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
hub = await cg.get_variable(config[CONF_DSMR_ID])
cv.Required(CONF_ECO2): sensor.sensor_schema(
unit_of_measurement=UNIT_PARTS_PER_MILLION,
icon=ICON_MOLECULE_CO2,
accuracy_decimals=0,
device_class=DEVICE_CLASS_CARBON_DIOXIDE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Required(CONF_TVOC): sensor.sensor_schema(
unit_of_measurement=UNIT_PARTS_PER_BILLION,
icon=ICON_RADIATOR,
accuracy_decimals=0,
device_class=DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
icon=ICON_RESTART
),
cv.Optional(CONF_BASELINE): cv.hex_uint16_t,
cv.Optional(CONF_TEMPERATURE): cv.use_id(sensor.Sensor),
cv.Optional(CONF_HUMIDITY): cv.use_id(sensor.Sensor),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x5A))
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
import esphome.config_validation as cv
from esphome.components import text_sensor
from . import BME680BSECComponent, CONF_BME680_BSEC_ID
DEPENDENCIES = ["bme680_bsec"]
CONF_IAQ_ACCURACY = "iaq_accuracy"
ICON_ACCURACY = "mdi:checkbox-marked-circle-outline"
TYPES = [CONF_IAQ_ACCURACY]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_BME680_BSEC_ID):
cv.use_id(BME680BSECComponent),
cv.Optional(CONF_IAQ_ACCURACY):
text_sensor.text_sensor_schema(icon=ICON_ACCURACY),
})
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
sens = await text_sensor.new_text_sensor(conf)
cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
async def to_code(config):
hub = await cg.get_variable(config[CONF_BME680_BSEC_ID])
for key in TYPES:
await setup_conf(config, key, hub)
from esphome.components import text_sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_SENSOR_DATAPOINT
from .. import tuya_ns, CONF_TUYA_ID, Tuya
DEPENDENCIES = ["tuya"]
CODEOWNERS = ["@dentra"]
TuyaTextSensor = tuya_ns.class_("TuyaTextSensor", text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = (text_sensor.text_sensor_schema().extend({
cv.GenerateID():
cv.declare_id(TuyaTextSensor),
cv.GenerateID(CONF_TUYA_ID):
cv.use_id(Tuya),
cv.Required(CONF_SENSOR_DATAPOINT):
cv.uint8_t,
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
paren = await cg.get_variable(config[CONF_TUYA_ID])
cg.add(var.set_tuya_parent(paren))
cg.add(var.set_sensor_id(config[CONF_SENSOR_DATAPOINT]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import text_sensor
from esphome.const import CONF_ATTRIBUTE, CONF_ENTITY_ID
from .. import homeassistant_ns
DEPENDENCIES = ["api"]
HomeassistantTextSensor = homeassistant_ns.class_("HomeassistantTextSensor",
text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = text_sensor.text_sensor_schema().extend({
cv.GenerateID():
cv.declare_id(HomeassistantTextSensor),
cv.Required(CONF_ENTITY_ID):
cv.entity_id,
cv.Optional(CONF_ATTRIBUTE):
cv.string,
})
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
cg.add(var.set_entity_id(config[CONF_ENTITY_ID]))
if CONF_ATTRIBUTE in config:
cg.add(var.set_attribute(config[CONF_ATTRIBUTE]))
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,
)
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
paren = await cg.get_variable(config[CONF_SUN_ID])
cg.add(var.set_parent(paren))
from .. import nextion_ns, CONF_NEXTION_ID
from ..base_component import (
setup_component_core_,
CONFIG_TEXT_COMPONENT_SCHEMA,
)
CODEOWNERS = ["@senexcrenshaw"]
NextionTextSensor = nextion_ns.class_(
"NextionTextSensor", text_sensor.TextSensor, cg.PollingComponent
)
CONFIG_SCHEMA = (
text_sensor.text_sensor_schema(NextionTextSensor)
.extend(CONFIG_TEXT_COMPONENT_SCHEMA)
.extend(cv.polling_component_schema("never"))
)
async def to_code(config):
hub = await cg.get_variable(config[CONF_NEXTION_ID])
var = cg.new_Pvariable(config[CONF_ID], hub)
await text_sensor.register_text_sensor(var, config)
await cg.register_component(var, config)
cg.add(hub.register_textsensor_component(var))
await setup_component_core_(var, config, ".txt")
RawEncoding_ns = modbus_controller_ns.namespace("RawEncoding")
RawEncoding = RawEncoding_ns.enum("RawEncoding")
RAW_ENCODING = {
"NONE": RawEncoding.NONE,
"HEXBYTES": RawEncoding.HEXBYTES,
"COMMA": RawEncoding.COMMA,
}
CONFIG_SCHEMA = cv.All(
text_sensor.text_sensor_schema().extend(
cv.COMPONENT_SCHEMA).extend(ModbusItemBaseSchema).extend({
cv.GenerateID():
cv.declare_id(ModbusTextSensor),
cv.Optional(CONF_REGISTER_TYPE):
cv.enum(MODBUS_REGISTER_TYPE),
cv.Optional(CONF_REGISTER_COUNT, default=0):
cv.positive_int,
cv.Optional(CONF_RESPONSE_SIZE, default=2):
cv.positive_int,
cv.Optional(CONF_RAW_ENCODE, default="NONE"):
cv.enum(RAW_ENCODING),
}),
validate_modbus_register,
)
async def to_code(config):
byte_offset, reg_count = modbus_calc_properties(config)
response_size = config[CONF_RESPONSE_SIZE]
reg_count = config[CONF_REGISTER_COUNT]
if reg_count == 0:
import esphome.config_validation as cv
from esphome.components import text_sensor
from esphome.const import (
CONF_ENTITY_CATEGORY,
CONF_ICON,
CONF_SOURCE_ID,
)
from esphome.core.entity_helpers import inherit_property_from
from .. import copy_ns
CopyTextSensor = copy_ns.class_("CopyTextSensor", text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = (text_sensor.text_sensor_schema(CopyTextSensor).extend({
cv.Required(CONF_SOURCE_ID):
cv.use_id(text_sensor.TextSensor),
}).extend(cv.COMPONENT_SCHEMA))
FINAL_VALIDATE_SCHEMA = cv.All(
inherit_property_from(CONF_ICON, CONF_SOURCE_ID),
inherit_property_from(CONF_ENTITY_CATEGORY, CONF_SOURCE_ID),
)
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
source = await cg.get_variable(config[CONF_SOURCE_ID])
cg.add(var.set_source(source))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import text_sensor
from esphome.const import CONF_ID, CONF_LAMBDA, CONF_TEXT_SENSORS
from .. import custom_ns
CustomTextSensorConstructor = custom_ns.class_("CustomTextSensorConstructor")
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(CustomTextSensorConstructor),
cv.Required(CONF_LAMBDA):
cv.returning_lambda,
cv.Required(CONF_TEXT_SENSORS):
cv.ensure_list(text_sensor.text_sensor_schema()),
})
async def to_code(config):
template_ = await cg.process_lambda(
config[CONF_LAMBDA],
[],
return_type=cg.std_vector.template(text_sensor.TextSensorPtr),
)
rhs = CustomTextSensorConstructor(template_)
var = cg.variable(config[CONF_ID], rhs)
for i, conf in enumerate(config[CONF_TEXT_SENSORS]):
text = cg.Pvariable(conf[CONF_ID], var.get_text_sensor(i))
await text_sensor.register_text_sensor(text, conf)
from esphome.const import CONF_QOS, CONF_TOPIC
from .. import mqtt_subscribe_ns
DEPENDENCIES = ["mqtt"]
CONF_MQTT_PARENT_ID = "mqtt_parent_id"
MQTTSubscribeTextSensor = mqtt_subscribe_ns.class_("MQTTSubscribeTextSensor",
text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = (text_sensor.text_sensor_schema().extend({
cv.GenerateID():
cv.declare_id(MQTTSubscribeTextSensor),
cv.GenerateID(CONF_MQTT_PARENT_ID):
cv.use_id(mqtt.MQTTClientComponent),
cv.Required(CONF_TOPIC):
cv.subscribe_topic,
cv.Optional(CONF_QOS, default=0):
cv.mqtt_qos,
}).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
parent = await cg.get_variable(config[CONF_MQTT_PARENT_ID])
cg.add(var.set_parent(parent))
cg.add(var.set_topic(config[CONF_TOPIC]))
cg.add(var.set_qos(config[CONF_QOS]))
text_sensor.TextSensor,
cg.PollingComponent)
ScanResultsWiFiInfo = wifi_info_ns.class_("ScanResultsWiFiInfo",
text_sensor.TextSensor,
cg.PollingComponent)
SSIDWiFiInfo = wifi_info_ns.class_("SSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
BSSIDWiFiInfo = wifi_info_ns.class_("BSSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
MacAddressWifiInfo = wifi_info_ns.class_("MacAddressWifiInfo",
text_sensor.TextSensor, cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.Optional(CONF_IP_ADDRESS):
text_sensor.text_sensor_schema(
klass=IPAddressWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_SCAN_RESULTS):
text_sensor.text_sensor_schema(
klass=ScanResultsWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("60s")),
cv.Optional(CONF_SSID):
text_sensor.text_sensor_schema(
klass=SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_BSSID):
text_sensor.text_sensor_schema(
klass=BSSIDWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import text_sensor, esp32_ble_tracker
DEPENDENCIES = ["esp32_ble_tracker"]
ble_scanner_ns = cg.esphome_ns.namespace("ble_scanner")
BLEScanner = ble_scanner_ns.class_(
"BLEScanner",
text_sensor.TextSensor,
cg.Component,
esp32_ble_tracker.ESPBTDeviceListener,
)
CONFIG_SCHEMA = cv.All(
text_sensor.text_sensor_schema(BLEScanner)
.extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
.extend(cv.COMPONENT_SCHEMA)
)
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
await esp32_ble_tracker.register_ble_device(var, config)
CONF_LAST_QMOD = "last_qmod"
CONF_LAST_QFLAG = "last_qflag"
CONF_LAST_QPIWS = "last_qpiws"
CONF_LAST_QT = "last_qt"
CONF_LAST_QMN = "last_qmn"
TYPES = [
CONF_DEVICE_MODE,
CONF_LAST_QPIGS,
CONF_LAST_QPIRI,
CONF_LAST_QMOD,
CONF_LAST_QFLAG,
CONF_LAST_QPIWS,
CONF_LAST_QT,
CONF_LAST_QMN,
]
CONFIG_SCHEMA = PIPSOLAR_COMPONENT_SCHEMA.extend(
{cv.Optional(type): text_sensor.text_sensor_schema()
for type in TYPES})
async def to_code(config):
paren = await cg.get_variable(config[CONF_PIPSOLAR_ID])
for type in TYPES:
if type in config:
conf = config[type]
var = await text_sensor.new_text_sensor(conf)
cg.add(getattr(paren, f"set_{type}")(var))
import esphome.codegen as cg
from esphome.components import text_sensor
from .. import (
HOME_ASSISTANT_IMPORT_SCHEMA,
homeassistant_ns,
setup_home_assistant_entity,
)
DEPENDENCIES = ["api"]
HomeassistantTextSensor = homeassistant_ns.class_("HomeassistantTextSensor",
text_sensor.TextSensor,
cg.Component)
CONFIG_SCHEMA = text_sensor.text_sensor_schema(HomeassistantTextSensor).extend(
HOME_ASSISTANT_IMPORT_SCHEMA)
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
setup_home_assistant_entity(var, config)
cv.declare_id(DemoSwitch),
})
],
cv.Optional(
CONF_TEXT_SENSORS,
default=[
{
CONF_NAME: "Demo Text Sensor 1",
},
{
CONF_NAME: "Demo Text Sensor 2",
CONF_ICON: ICON_BLUR,
},
],
): [
text_sensor.text_sensor_schema(klass=DemoTextSensor).extend(
cv.polling_component_schema("60s"))
],
})
async def to_code(config):
for conf in config[CONF_BINARY_SENSORS]:
var = cg.new_Pvariable(conf[CONF_ID])
await cg.register_component(var, conf)
await binary_sensor.register_binary_sensor(var, conf)
for conf in config[CONF_CLIMATES]:
var = cg.new_Pvariable(conf[CONF_ID])
await cg.register_component(var, conf)
await climate.register_climate(var, conf)
cg.add(var.set_type(conf[CONF_TYPE]))
text_sensor.TextSensor,
cg.PollingComponent)
ScanResultsWiFiInfo = wifi_info_ns.class_("ScanResultsWiFiInfo",
text_sensor.TextSensor,
cg.PollingComponent)
SSIDWiFiInfo = wifi_info_ns.class_("SSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
BSSIDWiFiInfo = wifi_info_ns.class_("BSSIDWiFiInfo", text_sensor.TextSensor,
cg.PollingComponent)
MacAddressWifiInfo = wifi_info_ns.class_("MacAddressWifiInfo",
text_sensor.TextSensor, cg.Component)
CONFIG_SCHEMA = cv.Schema({
cv.Optional(CONF_IP_ADDRESS):
text_sensor.text_sensor_schema(
IPAddressWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_SCAN_RESULTS):
text_sensor.text_sensor_schema(
ScanResultsWiFiInfo,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend({
cv.Optional(CONF_VERBOSE, default=False):
cv.boolean
}).extend(cv.polling_component_schema("60s")),
cv.Optional(CONF_SSID):
text_sensor.text_sensor_schema(
SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
cv.polling_component_schema("1s")),
cv.Optional(CONF_BSSID):
text_sensor.text_sensor_schema(
BSSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC).extend(
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import (
CONF_DEVICE,
CONF_BLOCKING_COMPONENT,
ENTITY_CATEGORY_DIAGNOSTIC,
)
from . import CONF_DEBUG_ID, DebugComponent
DEPENDENCIES = ["debug"]
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_DEBUG_ID):
cv.use_id(DebugComponent),
cv.Optional(CONF_DEVICE):
text_sensor.text_sensor_schema(entity_category=ENTITY_CATEGORY_DIAGNOSTIC),
cv.Optional(CONF_BLOCKING_COMPONENT):
text_sensor.text_sensor_schema(entity_category=ENTITY_CATEGORY_DIAGNOSTIC),
})
async def to_code(config):
debug_component = await cg.get_variable(config[CONF_DEBUG_ID])
if CONF_DEVICE in config:
sens = await text_sensor.new_text_sensor(config[CONF_DEVICE])
cg.add(debug_component.set_device_info_sensor(sens))
if CONF_BLOCKING_COMPONENT in config:
sens = await text_sensor.new_text_sensor(
config[CONF_BLOCKING_COMPONENT])
from esphome.const import (
ENTITY_CATEGORY_DIAGNOSTIC,
ICON_NEW_BOX,
CONF_HIDE_TIMESTAMP,
)
version_ns = cg.esphome_ns.namespace("version")
VersionTextSensor = version_ns.class_(
"VersionTextSensor", text_sensor.TextSensor, cg.Component
)
CONFIG_SCHEMA = (
text_sensor.text_sensor_schema(
icon=ICON_NEW_BOX,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
)
.extend(
{
cv.GenerateID(): cv.declare_id(VersionTextSensor),
cv.Optional(CONF_HIDE_TIMESTAMP, default=False): cv.boolean,
}
)
.extend(cv.COMPONENT_SCHEMA)
)
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
cg.add(var.set_hide_timestamp(config[CONF_HIDE_TIMESTAMP]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.components import text_sensor
from esphome.components.text_sensor import TextSensorPublishAction
from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
from .. import template_ns
TemplateTextSensor = template_ns.class_("TemplateTextSensor",
text_sensor.TextSensor,
cg.PollingComponent)
CONFIG_SCHEMA = (text_sensor.text_sensor_schema().extend({
cv.GenerateID():
cv.declare_id(TemplateTextSensor),
cv.Optional(CONF_LAMBDA):
cv.returning_lambda,
}).extend(cv.polling_component_schema("60s")))
async def to_code(config):
var = await text_sensor.new_text_sensor(config)
await cg.register_component(var, config)
if CONF_LAMBDA in config:
template_ = await cg.process_lambda(config[CONF_LAMBDA], [],
return_type=cg.optional.template(
cg.std_string))
cg.add(var.set_template(template_))
import esphome.codegen as cg
from esphome.components import text_sensor
from esphome.const import CONF_ID
from .. import CONF_TAG_NAME, TELEINFO_LISTENER_SCHEMA, teleinfo_ns, CONF_TELEINFO_ID
TeleInfoTextSensor = teleinfo_ns.class_(
"TeleInfoTextSensor", text_sensor.TextSensor, cg.Component
)
CONFIG_SCHEMA = text_sensor.text_sensor_schema(klass=TeleInfoTextSensor).extend(
TELEINFO_LISTENER_SCHEMA
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_TAG_NAME])
await cg.register_component(var, config)
await text_sensor.register_text_sensor(var, config)
teleinfo = await cg.get_variable(config[CONF_TELEINFO_ID])
cg.add(teleinfo.register_teleinfo_listener(var))
"ScanResultsWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
)
SSIDWiFiInfo = wifi_info_ns.class_(
"SSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
)
BSSIDWiFiInfo = wifi_info_ns.class_(
"BSSIDWiFiInfo", text_sensor.TextSensor, cg.PollingComponent
)
MacAddressWifiInfo = wifi_info_ns.class_(
"MacAddressWifiInfo", text_sensor.TextSensor, cg.Component
)
CONFIG_SCHEMA = cv.Schema(
{
cv.Optional(CONF_IP_ADDRESS): text_sensor.text_sensor_schema(
IPAddressWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
).extend(cv.polling_component_schema("1s")),
cv.Optional(CONF_SCAN_RESULTS): text_sensor.text_sensor_schema(
ScanResultsWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
).extend(cv.polling_component_schema("60s")),
cv.Optional(CONF_SSID): text_sensor.text_sensor_schema(
SSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
).extend(cv.polling_component_schema("1s")),
cv.Optional(CONF_BSSID): text_sensor.text_sensor_schema(
BSSIDWiFiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
).extend(cv.polling_component_schema("1s")),
cv.Optional(CONF_MAC_ADDRESS): text_sensor.text_sensor_schema(
MacAddressWifiInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
),
}
)
