def async_populate_data_from_discovery(
current_data: Mapping[str, Any],
data_updates: dict[str, Any],
device: FluxLEDDiscovery,
) -> None:
"""Copy discovery data into config entry data."""
for conf_key, discovery_key in CONF_TO_DISCOVERY.items():
if (
device.get(discovery_key) is not None
and conf_key
not in data_updates # Prefer the model num from TCP instead of UDP
and current_data.get(conf_key) != device[discovery_key] # type: ignore[literal-required]
):
data_updates[conf_key] = device[discovery_key] # type: ignore[literal-required]
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
"""Handle discovery via dhcp."""
self._discovered_device = FluxLEDDiscovery(
ipaddr=discovery_info.ip,
model=None,
id=format_as_flux_mac(discovery_info.macaddress),
model_num=None,
version_num=None,
firmware_date=None,
model_info=None,
model_description=None,
remote_access_enabled=None,
remote_access_host=None,
remote_access_port=None,
)
return await self._async_handle_discovery()
def async_build_cached_discovery(entry: ConfigEntry) -> FluxLEDDiscovery:
"""When discovery is unavailable, load it from the config entry."""
data = entry.data
return FluxLEDDiscovery(
ipaddr=data[CONF_HOST],
model=data.get(CONF_MODEL),
id=format_as_flux_mac(entry.unique_id),
model_num=data.get(CONF_MODEL_NUM),
version_num=data.get(CONF_MINOR_VERSION),
firmware_date=None,
model_info=data.get(CONF_MODEL_INFO),
model_description=data.get(CONF_MODEL_DESCRIPTION),
remote_access_enabled=data.get(CONF_REMOTE_ACCESS_ENABLED),
remote_access_host=data.get(CONF_REMOTE_ACCESS_HOST),
remote_access_port=data.get(CONF_REMOTE_ACCESS_PORT),
)
# identifying the device as the chip model number
# AKA `HF-LPB100-ZJ200`
return device
bulb = async_wifi_bulb_for_host(host, discovery=device)
bulb.discovery = discovery
try:
await bulb.async_setup(lambda: None)
finally:
await bulb.async_stop()
return FluxLEDDiscovery(
ipaddr=host,
model=discovery[ATTR_MODEL] if discovery else None,
id=discovery[ATTR_ID] if discovery else None,
model_num=bulb.model_num,
version_num=discovery[ATTR_VERSION_NUM] if discovery else None,
firmware_date=None,
model_info=discovery[ATTR_MODEL_INFO] if discovery else None,
model_description=bulb.model_data.description,
remote_access_enabled=None,
remote_access_host=None,
remote_access_port=None,
)
class OptionsFlow(config_entries.OptionsFlow):
"""Handle flux_led options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
"""Initialize the flux_led options flow."""
self._config_entry = config_entry
async def async_step_init(self,
MAC_ADDRESS = "aa:bb:cc:dd:ee:ff"
FLUX_MAC_ADDRESS = "AABBCCDDEEFF"
SHORT_MAC_ADDRESS = "DDEEFF"
DEFAULT_ENTRY_TITLE = f"{MODEL_DESCRIPTION} {SHORT_MAC_ADDRESS}"
DHCP_DISCOVERY = dhcp.DhcpServiceInfo(
hostname=MODEL,
ip=IP_ADDRESS,
macaddress=MAC_ADDRESS,
)
FLUX_DISCOVERY_PARTIAL = FluxLEDDiscovery(
ipaddr=IP_ADDRESS,
model=MODEL,
id=FLUX_MAC_ADDRESS,
model_num=None,
version_num=None,
firmware_date=None,
model_info=None,
model_description=None,
)
FLUX_DISCOVERY = FluxLEDDiscovery(
ipaddr=IP_ADDRESS,
model=MODEL,
id=FLUX_MAC_ADDRESS,
model_num=MODEL_NUM,
version_num=0x04,
firmware_date=datetime.date(2021, 5, 5),
model_info=MODEL,
model_description=MODEL_DESCRIPTION,
remote_access_enabled=True,
remote_access_host="the.cloud",
MAC_ADDRESS = "aa:bb:cc:dd:ee:ff"
FLUX_MAC_ADDRESS = "aabbccddeeff"
SHORT_MAC_ADDRESS = "ddeeff"
DEFAULT_ENTRY_TITLE = f"{MODEL_DESCRIPTION} {SHORT_MAC_ADDRESS}"
DHCP_DISCOVERY = dhcp.DhcpServiceInfo(
hostname=MODEL,
ip=IP_ADDRESS,
macaddress=MAC_ADDRESS,
)
FLUX_DISCOVERY_PARTIAL = FluxLEDDiscovery(
ipaddr=IP_ADDRESS,
model=MODEL,
id=FLUX_MAC_ADDRESS,
model_num=None,
version_num=None,
firmware_date=None,
model_info=None,
model_description=None,
)
FLUX_DISCOVERY = FluxLEDDiscovery(
ipaddr=IP_ADDRESS,
model=MODEL,
id=FLUX_MAC_ADDRESS,
model_num=0x25,
version_num=0x04,
firmware_date=datetime.date(2021, 5, 5),
model_info=MODEL,
model_description=MODEL_DESCRIPTION,
)
# to fallback to making a tcp connection to avoid
# identifying the device as the chip model number
# AKA `HF-LPB100-ZJ200`
return device
bulb = async_wifi_bulb_for_host(host, discovery=device)
try:
await bulb.async_setup(lambda: None)
finally:
await bulb.async_stop()
return FluxLEDDiscovery(
ipaddr=host,
model=model,
id=mac_address,
model_num=bulb.model_num,
version_num=None, # This is the minor version number
firmware_date=None,
model_info=None,
model_description=bulb.model_data.description,
remote_access_enabled=None,
remote_access_host=None,
remote_access_port=None,
)
class OptionsFlow(config_entries.OptionsFlow):
"""Handle flux_led options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
"""Initialize the flux_led options flow."""
self._config_entry = config_entry
async def async_step_init(self,