async def async_setup_platform(hass: HomeAssistant,
config: ConfigEntry,
async_add_entities,
discover_info=None):
"""Set up the Mopidy platform."""
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
name = config.get(CONF_NAME)
entity = MopidyMediaPlayerEntity(host, port, name)
async_add_entities([entity], True)
async def async_setup_platform(hass: HomeAssistant,
config: ConfigEntry,
async_add_entities: AddEntitiesCallback,
discovery_info=None):
name = config.get(CONF_NAME)
device_class = config.get(CONF_DEVICE_CLASS)
method = config.get(CONF_METHOD)
weather = config.get(CONF_WEATHER)
async_add_entities(
[WeatherSummary(name, device_class, method, weather)],
False,
)
async def async_setup_entry(hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities,
discovery_info=None):
prana_client: PranaRCAsyncClient = hass.data[const.DOMAIN][
config_entry.entry_id][const.DATA_API_CLIENT]
entities: List[PranaEntity] = []
if config_entry.data.get(
const.CONF_CONNECTION_TYPE
) == const.ConnectionType.REMOTE_HTTP_SERVER.value:
for device_config in config_entry.options.get(const.OPT_DEVICES,
{}).values():
device_coordinator, device_entities = await setup_prana_device(
hass, prana_client, device_config, config_entry.data)
entities += device_entities
else:
_LOGGER.warning(
"Connection type {} is not yet supported. This config entry will be ignored."
.format(config_entry.get(const.CONF_CONNECTION_TYPE)))
if len(entities) > 0:
hass.data[const.DOMAIN][config_entry.entry_id][
const.DATA_MAIN_ENTITIES] += entities
# At the moment we registered just main entities. Let's build supplementary fans
for main_entity in entities.copy():
entities.append(PranaInputFan(main_entity))
entities.append(PranaOutputFan(main_entity))
hass.data[const.DOMAIN][config_entry.entry_id][
const.DATA_ENTITIES] += entities
async_add_entities(entities)
async_dispatcher_send(hass, const.SIGNAL_PRANA_MAIN_INITIALIZED)
return True
async def async_setup_platform(hass: HomeAssistant,
config: ConfigEntry,
async_add_entities: AddEntitiesCallback,
discovery_info=None) -> None:
"""Set up the OpenWeatherMap weather platform."""
name = config.get(CONF_NAME)
phone_id = config.get(PHONE_ID)
device_ids = []
for device_id in config[CONF_DEVICE_ID]:
device_ids.append(device_id)
mad = MobileAlertsData(phone_id, device_ids)
async_add_entities(
[MobileAlertsWeather(name, mad)],
True,
)
async def async_setup_platform(hass: HomeAssistant,
config: ConfigEntry,
async_add_entities: AddEntitiesCallback,
discovery_info=None):
name = config.get(CONF_NAME)
device_class = config.get(CONF_DEVICE_CLASS)
device_id = config.get(CONF_DEVICE_ID)
if device_id != "": # historic
method = config.get(CONF_METHOD)
duration = config.get(CONF_DURATION)
mad = MobileAlertsData(hass, device_id, device_class, method, duration)
async_add_entities(
[MobileAlertsWeather.historic(name, mad)],
True,
)
else: # current
ma_weather = config.get(CONF_WEATHER)
if hass.states.get(ma_weather) is None:
raise Exception("weather Entity {0} not found".format(ma_weather))
for device_class in config[CONF_DEVICES]:
sensor_name = name.lower() + "_" + device_class
async_add_entities(
[
MobileAlertsWeather.current(sensor_name, device_class,
ma_weather)
],
False,
)
def process_emails(hass: HomeAssistant, config: ConfigEntry) -> dict:
"""Process emails and return value.
Returns dict containing sensor data
"""
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
user = config.get(CONF_USERNAME)
pwd = config.get(CONF_PASSWORD)
folder = config.get(CONF_FOLDER)
resources = config.get(CONF_RESOURCES)
# Create the dict container
data = {}
# Login to email server and select the folder
account = login(host, port, user, pwd)
# Do not process if account returns false
if not account:
return data
if not selectfolder(account, folder):
# Bail out on error
return data
# Create image file name dict container
_image = {}
# USPS Mail Image name
image_name = image_file_name(hass, config)
_LOGGER.debug("Image name: %s", image_name)
_image[ATTR_IMAGE_NAME] = image_name
# Amazon delivery image name
image_name = image_file_name(hass, config, True)
_LOGGER.debug("Amazon Image Name: %s", image_name)
_image[ATTR_AMAZON_IMAGE] = image_name
image_path = config.get(CONF_PATH)
_LOGGER.debug("Image path: %s", image_path)
_image[ATTR_IMAGE_PATH] = image_path
data.update(_image)
# Only update sensors we're intrested in
for sensor in resources:
fetch(hass, config, account, data, sensor)
# Copy image file to www directory if enabled
if config.get(CONF_ALLOW_EXTERNAL):
copy_images(hass, config)
return data
async def async_setup(hass: HomeAssistantType, config: ConfigEntry):
"""Establish connection with MELCloud."""
if DOMAIN not in config:
return True
conf = config.get(DOMAIN)
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_IMPORT},
data=conf,
))
return True
async def async_setup(hass: HomeAssistant, config: ConfigEntry) -> bool:
"""Import the ImageProcessor component from config."""
conf = config.get(DOMAIN)
if conf is None:
conf = {}
hass.data[DOMAIN] = {}
if DOMAIN in conf:
for entry in config[DOMAIN]:
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_IMPORT}, data=entry))
return True
def fetch(
hass: HomeAssistant, config: ConfigEntry, account: Any, data: dict, sensor: str
) -> int:
"""Fetch data for a single sensor, including any sensors it depends on."""
img_out_path = f"{hass.config.path()}/{config.get(const.CONF_PATH)}"
gif_duration = config.get(const.CONF_DURATION)
generate_mp4 = config.get(const.CONF_GENERATE_MP4)
amazon_fwds = config.get(const.CONF_AMAZON_FWDS)
image_name = data[const.ATTR_IMAGE_NAME]
amazon_image_name = data[const.ATTR_AMAZON_IMAGE]
if sensor in data:
return data[sensor]
count = {}
if sensor == "usps_mail":
count[sensor] = get_mails(
account,
img_out_path,
gif_duration,
image_name,
generate_mp4,
)
elif sensor == const.AMAZON_PACKAGES:
count[sensor] = get_items(account, const.ATTR_COUNT, amazon_fwds)
count[const.AMAZON_ORDER] = get_items(account, const.ATTR_ORDER)
elif sensor == const.AMAZON_HUB:
value = amazon_hub(account, amazon_fwds)
count[sensor] = value[const.ATTR_COUNT]
count[const.AMAZON_HUB_CODE] = value[const.ATTR_CODE]
elif "_packages" in sensor:
prefix = sensor.split("_")[0]
delivering = fetch(hass, config, account, data, f"{prefix}_delivering")
delivered = fetch(hass, config, account, data, f"{prefix}_delivered")
count[sensor] = delivering + delivered
elif "_delivering" in sensor:
prefix = sensor.split("_")[0]
delivered = fetch(hass, config, account, data, f"{prefix}_delivered")
info = get_count(account, sensor, True)
count[sensor] = max(0, info[const.ATTR_COUNT] - delivered)
count[f"{prefix}_tracking"] = info[const.ATTR_TRACKING]
elif sensor == "zpackages_delivered":
count[sensor] = 0 # initialize the variable
for shipper in const.SHIPPERS:
delivered = f"{shipper}_delivered"
if delivered in data and delivered != sensor:
count[sensor] += fetch(hass, config, account, data, delivered)
elif sensor == "zpackages_transit":
total = 0
for shipper in const.SHIPPERS:
delivering = f"{shipper}_delivering"
if delivering in data and delivering != sensor:
total += fetch(hass, config, account, data, delivering)
count[sensor] = max(0, total)
elif sensor == "mail_updated":
count[sensor] = update_time()
else:
count[sensor] = get_count(
account, sensor, False, img_out_path, hass, amazon_image_name
)[const.ATTR_COUNT]
data.update(count)
_LOGGER.debug("Sensor: %s Count: %s", sensor, str(count[sensor]))
return count[sensor]
def fetch(hass: HomeAssistant, config: ConfigEntry, account: Any, data: dict,
sensor: str) -> int:
"""Fetch data for a single sensor, including any sensors it depends on.
Returns integer of sensor passed to it
"""
img_out_path = f"{hass.config.path()}/{config.get(CONF_PATH)}"
gif_duration = config.get(CONF_DURATION)
generate_mp4 = config.get(CONF_GENERATE_MP4)
amazon_fwds = config.get(CONF_AMAZON_FWDS)
image_name = data[ATTR_IMAGE_NAME]
amazon_image_name = data[ATTR_AMAZON_IMAGE]
amazon_days = config.get(CONF_AMAZON_DAYS)
if config.get(CONF_CUSTOM_IMG):
nomail = config.get(CONF_CUSTOM_IMG_FILE)
else:
nomail = None
if sensor in data:
return data[sensor]
count = {}
if sensor == "usps_mail":
count[sensor] = get_mails(
account,
img_out_path,
gif_duration,
image_name,
generate_mp4,
nomail,
)
elif sensor == AMAZON_PACKAGES:
count[sensor] = get_items(
account=account,
param=ATTR_COUNT,
fwds=amazon_fwds,
days=amazon_days,
)
count[AMAZON_ORDER] = get_items(
account=account,
param=ATTR_ORDER,
fwds=amazon_fwds,
days=amazon_days,
)
elif sensor == AMAZON_HUB:
value = amazon_hub(account, amazon_fwds)
count[sensor] = value[ATTR_COUNT]
count[AMAZON_HUB_CODE] = value[ATTR_CODE]
elif sensor == AMAZON_EXCEPTION:
info = amazon_exception(account, amazon_fwds)
count[sensor] = info[ATTR_COUNT]
count[AMAZON_EXCEPTION_ORDER] = info[ATTR_ORDER]
elif "_packages" in sensor:
prefix = sensor.replace("_packages", "")
delivering = fetch(hass, config, account, data, f"{prefix}_delivering")
delivered = fetch(hass, config, account, data, f"{prefix}_delivered")
count[sensor] = delivering + delivered
elif "_delivering" in sensor:
prefix = sensor.replace("_delivering", "")
delivered = fetch(hass, config, account, data, f"{prefix}_delivered")
info = get_count(account, sensor, True)
count[sensor] = max(0, info[ATTR_COUNT] - delivered)
count[f"{prefix}_tracking"] = info[ATTR_TRACKING]
elif sensor == "zpackages_delivered":
count[sensor] = 0 # initialize the variable
for shipper in SHIPPERS:
delivered = f"{shipper}_delivered"
if delivered in data and delivered != sensor:
count[sensor] += fetch(hass, config, account, data, delivered)
elif sensor == "zpackages_transit":
total = 0
for shipper in SHIPPERS:
delivering = f"{shipper}_delivering"
if delivering in data and delivering != sensor:
total += fetch(hass, config, account, data, delivering)
count[sensor] = max(0, total)
elif sensor == "mail_updated":
count[sensor] = update_time()
else:
count[sensor] = get_count(account, sensor, False, img_out_path, hass,
amazon_image_name)[ATTR_COUNT]
data.update(count)
_LOGGER.debug("Sensor: %s Count: %s", sensor, str(count[sensor]))
return count[sensor]
def image_file_name(hass: HomeAssistant,
config: ConfigEntry,
amazon: bool = False) -> str:
"""Determine if filename is to be changed or not.
Returns filename
"""
mail_none = None
path = None
image_name = None
if amazon:
mail_none = f"{os.path.dirname(__file__)}/no_deliveries.jpg"
image_name = "no_deliveries.jpg"
path = f"{hass.config.path()}/{config.get(CONF_PATH)}amazon"
else:
path = f"{hass.config.path()}/{config.get(CONF_PATH)}"
if config.get(CONF_CUSTOM_IMG):
mail_none = config.get(CONF_CUSTOM_IMG_FILE)
else:
mail_none = f"{os.path.dirname(__file__)}/mail_none.gif"
image_name = os.path.split(mail_none)[1]
# Path check
path_check = os.path.exists(path)
if not path_check:
try:
os.makedirs(path)
except OSError as err:
_LOGGER.error("Problem creating: %s, error returned: %s", path,
err)
return image_name
# SHA1 file hash check
try:
sha1 = hash_file(mail_none)
except OSError as err:
_LOGGER.error("Problem accessing file: %s, error returned: %s",
mail_none, err)
return image_name
ext = None
ext = ".jpg" if amazon else ".gif"
for file in os.listdir(path):
if file.endswith(".gif") or (file.endswith(".jpg") and amazon):
try:
created = datetime.datetime.fromtimestamp(
os.path.getctime(os.path.join(path,
file))).strftime("%d-%b-%Y")
except OSError as err:
_LOGGER.error("Problem accessing file: %s, error returned: %s",
file, err)
return image_name
today = get_formatted_date()
_LOGGER.debug("Created: %s, Today: %s", created, today)
# If image isn't mail_none and not created today,
# return a new filename
if sha1 != hash_file(os.path.join(path,
file)) and today != created:
image_name = f"{str(uuid.uuid4())}{ext}"
else:
image_name = file
# If we find no images in the image directory generate a new filename
if image_name in mail_none:
image_name = f"{str(uuid.uuid4())}{ext}"
_LOGGER.debug("Image Name: %s", image_name)
# Insert place holder image
_LOGGER.debug("Copying %s to %s", mail_none,
os.path.join(path, image_name))
copyfile(mail_none, os.path.join(path, image_name))
return image_name
