def handle_homekit(hass: HomeAssistant, homekit_models: dict[str, str],
info: HaServiceInfo) -> bool:
"""Handle a HomeKit discovery.
Return if discovery was forwarded.
"""
model = None
props = info["properties"]
for key in props:
if key.lower() == HOMEKIT_MODEL:
model = props[key]
break
if model is None:
return False
for test_model in homekit_models:
if (model != test_model and not model.startswith(f"{test_model} ")
and not model.startswith(f"{test_model}-")):
continue
hass.add_job(
hass.config_entries.flow.async_init(
homekit_models[test_model],
context={"source": config_entries.SOURCE_HOMEKIT},
data=info,
) # type: ignore
)
return True
return False
def publish(hass: HomeAssistant,
topic,
payload,
qos=None,
retain=None) -> None:
"""Publish message to an MQTT topic."""
hass.add_job(async_publish, hass, topic, payload, qos, retain)
async def async_setup(hass: HomeAssistant, config: dict):
"""Set up the component. config contains data from configuration.yaml."""
# create empty api object as singleton
api = WasteCollectionApi(
hass,
separator=config[DOMAIN][CONF_SEPARATOR],
fetch_time=config[DOMAIN][CONF_FETCH_TIME],
random_fetch_time_offset=config[DOMAIN][CONF_RANDOM_FETCH_TIME_OFFSET],
day_switch_time=config[DOMAIN][CONF_DAY_SWITCH_TIME],
)
# create scraper(s)
for source in config[DOMAIN][CONF_SOURCES]:
# create customize object
customize = {}
for c in source.get(CONF_CUSTOMIZE, {}):
customize[c[CONF_TYPE]] = Customize(
name=c[CONF_TYPE],
alias=c.get(CONF_ALIAS),
show=c.get(CONF_SHOW, True),
icon=c.get(CONF_ICON),
picture=c.get(CONF_PICTURE),
)
api.add_scraper(source[CONF_SOURCE_NAME], customize,
source.get(CONF_SOURCE_ARGS, {}))
# store api object
hass.data.setdefault(DOMAIN, api)
# initial fetch of all data
hass.add_job(api._fetch)
return True
def create(
hass: HomeAssistant,
message: str,
title: str | None = None,
notification_id: str | None = None,
) -> None:
"""Generate a notification."""
hass.add_job(async_create, hass, message, title, notification_id)
def discover(
hass: core.HomeAssistant,
service: str,
discovered: DiscoveryInfoType,
component: str,
hass_config: ConfigType,
) -> None:
"""Fire discovery event. Can ensure a component is loaded."""
hass.add_job(async_discover(hass, service, discovered, component, hass_config))
def publish(
hass: HomeAssistant,
topic: str,
payload: PublishPayloadType,
qos: int | None = 0,
retain: bool | None = False,
encoding: str | None = DEFAULT_ENCODING,
) -> None:
"""Publish message to a MQTT topic."""
hass.add_job(async_publish, hass, topic, payload, qos, retain, encoding)
def load_platform(
hass: core.HomeAssistant,
component: Platform | str,
platform: str,
discovered: DiscoveryInfoType | None,
hass_config: ConfigType,
) -> None:
"""Load a component and platform dynamically."""
hass.add_job(
async_load_platform( # type: ignore
hass, component, platform, discovered, hass_config))
def log_entry(
hass: HomeAssistant,
name: str,
message: str,
domain: str | None = None,
entity_id: str | None = None,
context: Context | None = None,
) -> None:
"""Add an entry to the logbook."""
hass.add_job(async_log_entry, hass, name, message, domain, entity_id,
context)
async def async_setup(hass: HomeAssistant, config: dict):
"""Set up the component. config contains data from configuration.yaml."""
# create empty api object as singleton
api = WasteCollectionApi(
hass,
separator=config[DOMAIN][CONF_SEPARATOR],
fetch_time=config[DOMAIN][CONF_FETCH_TIME],
random_fetch_time_offset=config[DOMAIN][CONF_RANDOM_FETCH_TIME_OFFSET],
day_switch_time=config[DOMAIN][CONF_DAY_SWITCH_TIME],
)
# create scraper(s)
for source in config[DOMAIN][CONF_SOURCES]:
# create customize object
customize = {}
for c in source.get(CONF_CUSTOMIZE, {}):
customize[c[CONF_TYPE]] = Customize(
waste_type=c[CONF_TYPE],
alias=c.get(CONF_ALIAS),
show=c.get(CONF_SHOW, True),
icon=c.get(CONF_ICON),
picture=c.get(CONF_PICTURE),
use_dedicated_calendar=c.get(CONF_USE_DEDICATED_CALENDAR,
False),
dedicated_calendar_title=c.get(CONF_DEDICATED_CALENDAR_TITLE,
False),
)
api.add_scraper(
source_name=source[CONF_SOURCE_NAME],
customize=customize,
calendar_title=source.get(CONF_SOURCE_CALENDAR_TITLE),
source_args=source.get(CONF_SOURCE_ARGS, {}),
)
# store api object
hass.data.setdefault(DOMAIN, api)
# load calendar platform
await hass.helpers.discovery.async_load_platform("calendar", DOMAIN,
{"api": api}, config)
# initial fetch of all data
hass.add_job(api._fetch)
return True
def get_amazon_image(
sdata: Any,
account: Type[imaplib.IMAP4_SSL],
image_path: str,
hass: HomeAssistant,
image_name: str,
) -> None:
""" Find Amazon delivery image """
_LOGGER.debug("Searching for Amazon image in emails...")
search = const.AMAZON_IMG_PATTERN
img_url = None
mail_list = sdata.split()
_LOGGER.debug("HTML Amazon emails found: %s", len(mail_list))
for i in mail_list:
typ, data = email_fetch(account, i, "(RFC822)")
for response_part in data:
if isinstance(response_part, tuple):
msg = email.message_from_bytes(response_part[1])
_LOGGER.debug("Email Multipart: %s", str(msg.is_multipart()))
_LOGGER.debug("Content Type: %s", str(msg.get_content_type()))
if not msg.is_multipart() and msg.get_content_type() != "text/html":
continue
for part in msg.walk():
if part.get_content_type() != "text/html":
continue
_LOGGER.debug("Processing HTML email...")
body = part.get_payload(decode=True)
body = body.decode("utf-8", "ignore")
pattern = re.compile(r"{}".format(search))
found = pattern.findall(body)
for url in found:
if url[1] != "us-prod-temp.s3.amazonaws.com":
continue
img_url = url[0] + url[1] + url[2]
_LOGGER.debug("Amazon img URL: %s", img_url)
break
if img_url is not None:
# Download the image we found
hass.add_job(download_img(img_url, image_path, image_name))
def load_platform(
hass: core.HomeAssistant,
component: str,
platform: str,
discovered: DiscoveryInfoType,
hass_config: ConfigType,
) -> None:
"""Load a component and platform dynamically.
Target components will be loaded and an EVENT_PLATFORM_DISCOVERED will be
fired to load the platform. The event will contain:
{ ATTR_SERVICE = EVENT_LOAD_PLATFORM + '.' + <<component>>
ATTR_PLATFORM = <<platform>>
ATTR_DISCOVERED = <<discovery info>> }
Use `listen_platform` to register a callback for these events.
"""
hass.add_job(
async_load_platform( # type: ignore
hass, component, platform, discovered, hass_config))
def migrate_schema(
instance: Any,
hass: HomeAssistant,
engine: Engine,
session_maker: Callable[[], Session],
current_version: int,
) -> None:
"""Check if the schema needs to be upgraded."""
_LOGGER.warning("Database is about to upgrade. Schema version: %s",
current_version)
db_ready = False
for version in range(current_version, SCHEMA_VERSION):
if live_migration(version) and not db_ready:
db_ready = True
instance.migration_is_live = True
hass.add_job(instance.async_set_db_ready)
new_version = version + 1
_LOGGER.info("Upgrading recorder db schema to version %s", new_version)
_apply_update(hass, engine, session_maker, new_version,
current_version)
with session_scope(session=session_maker()) as session:
session.add(SchemaChanges(schema_version=new_version))
_LOGGER.info("Upgrade to version %s done", new_version)
def dismiss(hass: HomeAssistant, notification_id: str) -> None:
"""Remove a notification."""
hass.add_job(async_dismiss, hass, notification_id)
