HomeAssistant/hassos_config
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
willem
2022-12-20 21:26:47 +01:00
commit 2962a6db69
722 changed files with 63886 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
custom_components/afvalwijzer/__init__.py Normal file
View File

0
custom_components/afvalwijzer/collector/__init__.py Normal file
View File

57
custom_components/afvalwijzer/collector/deafvalapp.py Normal file
View File

@@ -0,0 +1,57 @@
from datetime import datetime
import re
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import _LOGGER, SENSOR_COLLECTORS_DEAFVALAPP
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
):
if provider not in SENSOR_COLLECTORS_DEAFVALAPP.keys():
raise ValueError(f"Invalid provider: {provider}, please verify")
corrected_postal_code_parts = re.search(r"(\d\d\d\d) ?([A-z][A-z])", postal_code)
corrected_postal_code = (
corrected_postal_code_parts[1] + corrected_postal_code_parts[2].upper()
)
try:
url = SENSOR_COLLECTORS_DEAFVALAPP[provider].format(
corrected_postal_code,
street_number,
suffix,
)
raw_response = requests.get(url)
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
try:
response = raw_response.text
except ValueError as e:
raise ValueError(f"Invalid and/or no data received from {url}") from e
if not response:
_LOGGER.error("No waste data found!")
return
waste_data_raw = []
for rows in response.strip().split("\n"):
for ophaaldatum in rows.split(";")[1:-1]:
temp = {"type": _waste_type_rename(rows.split(";")[0].strip().lower())}
temp["date"] = datetime.strptime(ophaaldatum, "%d-%m-%Y").strftime(
"%Y-%m-%d"
)
waste_data_raw.append(temp)
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

72
custom_components/afvalwijzer/collector/icalendar.py Normal file
View File

@@ -0,0 +1,72 @@
from datetime import datetime
import re
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import _LOGGER, SENSOR_COLLECTORS_ICALENDAR
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
): # sourcery skip: avoid-builtin-shadow
if provider not in SENSOR_COLLECTORS_ICALENDAR.keys():
raise ValueError(f"Invalid provider: {provider}, please verify")
DATE_PATTERN = re.compile(r"^\d{8}")
try:
url = SENSOR_COLLECTORS_ICALENDAR[provider].format(
provider,
postal_code,
street_number,
suffix,
datetime.now().strftime("%Y-%m-%d"),
)
raw_response = requests.get(url)
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
try:
response = raw_response.text
except ValueError as exc:
raise ValueError(f"Invalid and/or no data received from {url}") from exc
if not response:
_LOGGER.error("No waste data found!")
return
waste_data_raw = []
date = None
type = None
for line in response.splitlines():
key, value = line.split(":", 2)
field = key.split(";")[0]
if field == "BEGIN" and value == "VEVENT":
date = None
type = None
elif field == "SUMMARY":
type = value.strip().lower()
elif field == "DTSTART":
if DATE_PATTERN.match(value):
date = f"{value[:4]}-{value[4:6]}-{value[6:8]}"
else:
_LOGGER.debug(f"Unsupported date format: {value}")
elif field == "END" and value == "VEVENT":
if date and type:
waste_data_raw.append({"type": type, "date": date})
else:
_LOGGER.debug(
f"No date or type extracted from event: date={date}, type={type}"
)
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

122
custom_components/afvalwijzer/collector/main_collector.py Normal file
View File

@@ -0,0 +1,122 @@
from ..common.waste_data_transformer import WasteDataTransformer
from ..const.const import (
_LOGGER,
SENSOR_COLLECTORS_AFVALWIJZER,
SENSOR_COLLECTORS_DEAFVALAPP,
SENSOR_COLLECTORS_ICALENDAR,
SENSOR_COLLECTORS_OPZET,
SENSOR_COLLECTORS_RD4,
SENSOR_COLLECTORS_XIMMIO,
)
try:
from . import deafvalapp, icalendar, mijnafvalwijzer, opzet, rd4, ximmio
except ImportError as err:
_LOGGER.error(f"Import error {err.args}")
class MainCollector(object):
def __init__(
self,
provider,
postal_code,
street_number,
suffix,
exclude_pickup_today,
exclude_list,
default_label,
):
self.provider = provider.strip().lower()
self.postal_code = postal_code.strip().upper()
self.street_number = street_number.strip()
self.suffix = suffix.strip().lower()
self.exclude_pickup_today = exclude_pickup_today.strip()
self.exclude_list = exclude_list.strip().lower()
self.default_label = default_label.strip()
try:
if provider in SENSOR_COLLECTORS_AFVALWIJZER:
waste_data_raw = mijnafvalwijzer.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
elif provider in SENSOR_COLLECTORS_DEAFVALAPP.keys():
waste_data_raw = deafvalapp.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
elif provider in SENSOR_COLLECTORS_ICALENDAR.keys():
waste_data_raw = icalendar.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
elif provider in SENSOR_COLLECTORS_OPZET.keys():
waste_data_raw = opzet.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
elif provider in SENSOR_COLLECTORS_RD4.keys():
waste_data_raw = rd4.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
elif provider in SENSOR_COLLECTORS_XIMMIO.keys():
waste_data_raw = ximmio.get_waste_data_raw(
self.provider,
self.postal_code,
self.street_number,
self.suffix,
)
else:
_LOGGER.error(f"Unknown provider: {provider}")
return False
except ValueError as err:
_LOGGER.error(f"Check afvalwijzer platform settings {err.args}")
##########################################################################
# COMMON CODE
##########################################################################
self._waste_data = WasteDataTransformer(
waste_data_raw,
self.exclude_pickup_today,
self.exclude_list,
self.default_label,
)
##########################################################################
# PROPERTIES FOR EXECUTION
##########################################################################
@property
def waste_data_with_today(self):
return self._waste_data.waste_data_with_today
@property
def waste_data_without_today(self):
return self._waste_data.waste_data_without_today
@property
def waste_data_provider(self):
return self._waste_data.waste_data_provider
@property
def waste_types_provider(self):
return self._waste_data.waste_types_provider
@property
def waste_data_custom(self):
return self._waste_data.waste_data_custom
@property
def waste_types_custom(self):
return self._waste_data.waste_types_custom

58
custom_components/afvalwijzer/collector/mijnafvalwijzer.py Normal file
View File

@@ -0,0 +1,58 @@
from datetime import datetime
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import (
_LOGGER,
SENSOR_COLLECTOR_TO_URL,
SENSOR_COLLECTORS_AFVALWIJZER,
)
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
):
if provider not in SENSOR_COLLECTORS_AFVALWIJZER:
raise ValueError(f"Invalid provider: {provider}, please verify")
if provider == "rova":
provider = "inzamelkalender.rova"
try:
url = SENSOR_COLLECTOR_TO_URL["afvalwijzer_data_default"][0].format(
provider,
postal_code,
street_number,
suffix,
datetime.now().strftime("%Y-%m-%d"),
)
raw_response = requests.get(url)
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
try:
response = raw_response.json()
except ValueError as e:
raise ValueError(f"Invalid and/or no data received from {url}") from e
if not response:
_LOGGER.error("Address not found!")
return
try:
waste_data_raw = (
response["ophaaldagen"]["data"] + response["ophaaldagenNext"]["data"]
)
except KeyError as exc:
raise KeyError(f"Invalid and/or no data received from {url}") from exc
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

69
custom_components/afvalwijzer/collector/opzet.py Normal file
View File

@@ -0,0 +1,69 @@
from datetime import datetime
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import _LOGGER, SENSOR_COLLECTORS_OPZET
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
):
if provider not in SENSOR_COLLECTORS_OPZET.keys():
raise ValueError(f"Invalid provider: {provider}, please verify")
try:
bag_id = None
_verify = provider != "suez"
url = f"{SENSOR_COLLECTORS_OPZET[provider]}/rest/adressen/{postal_code}-{street_number}"
raw_response = requests.get(url, verify=_verify)
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
try:
response = raw_response.json()
except ValueError as e:
raise ValueError(f"Invalid and/or no data received from {url}") from e
if not response:
_LOGGER.error("No waste data found!")
return
try:
if len(response) > 1 and suffix:
for item in response:
if (
item["huisletter"] == suffix
or item["huisnummerToevoeging"] == suffix
):
bag_id = item["bagId"]
break
else:
bag_id = response[0]["bagId"]
url = f"{SENSOR_COLLECTORS_OPZET[provider]}/rest/adressen/{bag_id}/afvalstromen"
waste_data_raw_temp = requests.get(url, verify=_verify).json()
waste_data_raw = []
for item in waste_data_raw_temp:
if not item["ophaaldatum"]:
continue
waste_type = item["menu_title"]
if not waste_type:
continue
temp = {"type": _waste_type_rename(item["menu_title"].strip().lower())}
temp["date"] = datetime.strptime(item["ophaaldatum"], "%Y-%m-%d").strftime(
"%Y-%m-%d"
)
waste_data_raw.append(temp)
except ValueError as exc:
raise ValueError(f"Invalid and/or no data received from {url}") from exc
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

74
custom_components/afvalwijzer/collector/rd4.py Normal file
View File

@@ -0,0 +1,74 @@
from datetime import datetime
import re
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import _LOGGER, SENSOR_COLLECTORS_RD4
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
):
if provider not in SENSOR_COLLECTORS_RD4.keys():
raise ValueError(f"Invalid provider: {provider}, please verify")
TODAY = datetime.now()
YEAR_CURRENT = TODAY.year
corrected_postal_code_parts = re.search(r"(\d\d\d\d) ?([A-z][A-z])", postal_code)
corrected_postal_code = (
f"{corrected_postal_code_parts[1]}+{corrected_postal_code_parts[2].upper()}"
)
try:
url = SENSOR_COLLECTORS_RD4[provider].format(
corrected_postal_code,
street_number,
suffix,
YEAR_CURRENT,
)
raw_response = requests.get(url)
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
try:
response = raw_response.json()
except ValueError as e:
raise ValueError(f"Invalid and/or no data received from {url}") from e
if not response:
_LOGGER.error("No waste data found!")
return
if not response["success"]:
_LOGGER.error("Address not found!")
return
try:
waste_data_raw_temp = response["data"]["items"][0]
except KeyError as exc:
raise KeyError(f"Invalid and/or no data received from {url}") from exc
waste_data_raw = []
for item in waste_data_raw_temp:
if not item["date"]:
continue
waste_type = item["type"]
if not waste_type:
continue
temp = {"type": _waste_type_rename(item["type"].strip().lower())}
temp["date"] = datetime.strptime(item["date"], "%Y-%m-%d").strftime("%Y-%m-%d")
waste_data_raw.append(temp)
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

83
custom_components/afvalwijzer/collector/ximmio.py Normal file
View File

@@ -0,0 +1,83 @@
from datetime import datetime, timedelta
import requests
from ..common.main_functions import _waste_type_rename
from ..const.const import _LOGGER, SENSOR_COLLECTOR_TO_URL, SENSOR_COLLECTORS_XIMMIO
def get_waste_data_raw(
provider,
postal_code,
street_number,
suffix,
):
if provider not in SENSOR_COLLECTORS_XIMMIO.keys():
raise ValueError(f"Invalid provider: {provider}, please verify")
collectors = ("avalex", "meerlanden", "rad", "westland")
provider_url = "ximmio02" if provider in collectors else "ximmio01"
TODAY = datetime.now().strftime("%d-%m-%Y")
DATE_TODAY = datetime.strptime(TODAY, "%d-%m-%Y")
DATE_TOMORROW = datetime.strptime(TODAY, "%d-%m-%Y") + timedelta(days=1)
DATE_TODAY_NEXT_YEAR = (DATE_TODAY.date() + timedelta(days=365)).strftime(
"%Y-%m-%d"
)
##########################################################################
# First request: get uniqueId and community
##########################################################################
try:
url = SENSOR_COLLECTOR_TO_URL[provider_url][0]
companyCode = SENSOR_COLLECTORS_XIMMIO[provider]
data = {
"postCode": postal_code,
"houseNumber": street_number,
"companyCode": companyCode,
}
raw_response = requests.post(url=url, data=data)
uniqueId = raw_response.json()["dataList"][0]["UniqueId"]
community = raw_response.json()["dataList"][0]["Community"]
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
##########################################################################
# Second request: get the dates
##########################################################################
try:
url = SENSOR_COLLECTOR_TO_URL[provider_url][1]
data = {
"companyCode": companyCode,
"startDate": DATE_TODAY.date(),
"endDate": DATE_TODAY_NEXT_YEAR,
"community": community,
"uniqueAddressID": uniqueId,
}
raw_response = requests.post(url=url, data=data).json()
except requests.exceptions.RequestException as err:
raise ValueError(err) from err
if not raw_response:
_LOGGER.error("Address not found!")
return
try:
response = raw_response["dataList"]
except KeyError as e:
raise KeyError(f"Invalid and/or no data received from {url}") from e
waste_data_raw = []
for item in response:
temp = {"type": _waste_type_rename(item["_pickupTypeText"].strip().lower())}
temp["date"] = datetime.strptime(
sorted(item["pickupDates"])[0], "%Y-%m-%dT%H:%M:%S"
).strftime("%Y-%m-%d")
waste_data_raw.append(temp)
return waste_data_raw
if __name__ == "__main__":
print("Yell something at a mountain!")

0
custom_components/afvalwijzer/common/__init__.py Normal file
View File

66
custom_components/afvalwijzer/common/day_sensor_data.py Normal file
View File

@@ -0,0 +1,66 @@
from datetime import datetime, timedelta
from ..const.const import _LOGGER
class DaySensorData(object):
##########################################################################
# INIT
##########################################################################
def __init__(
self,
waste_data_formatted,
default_label,
):
TODAY = datetime.now().strftime("%d-%m-%Y")
self.waste_data_formatted = sorted(
waste_data_formatted, key=lambda d: d["date"]
)
self.today_date = datetime.strptime(TODAY, "%d-%m-%Y")
self.tomorrow_date = datetime.strptime(TODAY, "%d-%m-%Y") + timedelta(days=1)
self.day_after_tomorrow_date = datetime.strptime(TODAY, "%d-%m-%Y") + timedelta(
days=2
)
self.default_label = default_label
self.waste_data_today = self.__gen_day_sensor(self.today_date)
self.waste_data_tomorrow = self.__gen_day_sensor(self.tomorrow_date)
self.waste_data_dot = self.__gen_day_sensor(self.day_after_tomorrow_date)
self.data = self._gen_day_sensor_data()
##########################################################################
# GENERATE TODAY, TOMORROW, DOT SENSOR(S)
##########################################################################
# Generate sensor data per date
def __gen_day_sensor(self, date):
day = []
try:
for waste in self.waste_data_formatted:
item_date = waste["date"]
if item_date == date:
item_name = waste["type"]
day.append(item_name)
if not day:
day.append(self.default_label)
except Exception as err:
_LOGGER.error(f"Other error occurred __gen_day_sensor: {err}")
return day
# Generate sensor data for today, tomorrow, day after tomorrow
def _gen_day_sensor_data(self):
day_sensor = {}
try:
day_sensor["today"] = ", ".join(self.waste_data_today)
day_sensor["tomorrow"] = ", ".join(self.waste_data_tomorrow)
day_sensor["day_after_tomorrow"] = ", ".join(self.waste_data_dot)
except Exception as err:
_LOGGER.error(f"Other error occurred _gen_day_sensor_data: {err}")
return day_sensor
@property
def day_sensor_data(self):
return self.data

80
custom_components/afvalwijzer/common/main_functions.py Normal file
View File

@@ -0,0 +1,80 @@
def _waste_type_rename(item_name):
# DEAFVALAPP
if item_name == "gemengde plastics":
item_name = "plastic"
if item_name == "zak_blauw":
item_name = "restafval"
if item_name == "pbp":
item_name = "pmd"
if item_name == "rest":
item_name = "restafval"
if item_name == "kerstboom":
item_name = "kerstbomen"
# OPZET
if item_name == "snoeiafval":
item_name = "takken"
if item_name == "sloop":
item_name = "grofvuil"
if item_name == "groente":
item_name = "gft"
if item_name == "groente-, fruit en tuinafval":
item_name = "gft"
if item_name == "groente, fruit- en tuinafval":
item_name = "gft"
if item_name == "kca":
item_name = "chemisch"
if item_name == "tariefzak restafval":
item_name = "restafvalzakken"
if item_name == "restafvalzakken":
item_name = "restafvalzakken"
if item_name == "rest":
item_name = "restafval"
if item_name == "plastic, blik & drinkpakken overbetuwe":
item_name = "pmd"
if item_name == "papier en karton":
item_name = "papier"
if item_name == "kerstb":
item_name = "kerstboom"
# RD4
if item_name == "pruning":
item_name = "takken"
if item_name == "residual_waste":
item_name = "restafval"
if item_name == "best_bag":
item_name = "best-tas"
if item_name == "paper":
item_name = "papier"
if item_name == "christmas_trees":
item_name = "kerstbomen"
# XIMMIO
if item_name == "branches":
item_name = "takken"
if item_name == "bulklitter":
item_name = "grofvuil"
if item_name == "bulkygardenwaste":
item_name = "tuinafval"
if item_name == "glass":
item_name = "glas"
if item_name == "green":
item_name = "gft"
if item_name == "grey":
item_name = "restafval"
if item_name == "kca":
item_name = "chemisch"
if item_name == "plastic":
item_name = "plastic"
if item_name == "packages":
item_name = "pmd"
if item_name == "paper":
item_name = "papier"
if item_name == "remainder":
item_name = "restwagen"
if item_name == "textile":
item_name = "textiel"
if item_name == "tree":
item_name = "kerstbomen"
return item_name
if __name__ == "__main__":
print("Yell something at a mountain!")

76
custom_components/afvalwijzer/common/next_sensor_data.py Normal file
View File

@@ -0,0 +1,76 @@
from datetime import datetime
from ..const.const import _LOGGER
class NextSensorData(object):
##########################################################################
# INIT
##########################################################################
def __init__(self, waste_data_after_date_selected, default_label):
self.waste_data_after_date_selected = sorted(
waste_data_after_date_selected, key=lambda d: d["date"]
)
TODAY = datetime.now().strftime("%d-%m-%Y")
self.today_date = datetime.strptime(TODAY, "%d-%m-%Y")
self.default_label = default_label
self.next_waste_date = self.__get_next_waste_date()
self.next_waste_in_days = self.__get_next_waste_in_days()
self.next_waste_type = self.__get_next_waste_type()
self.data = self._gen_next_sensor_data()
##########################################################################
# GENERATE NEXT SENSOR(S)
##########################################################################
# Generate sensor next_waste_date
def __get_next_waste_date(self):
next_waste_date = self.default_label
try:
next_waste_date = self.waste_data_after_date_selected[0]["date"]
except Exception as err:
_LOGGER.error(f"Other error occurred _get_next_waste_date: {err}")
return next_waste_date
# Generate sensor next_waste_in_days
def __get_next_waste_in_days(self):
next_waste_in_days = self.default_label
try:
next_waste_in_days = abs(self.today_date - self.next_waste_date).days # type: ignore
except Exception as err:
_LOGGER.error(f"Other error occurred _get_next_waste_in_days: {err}")
return next_waste_in_days
# Generate sensor next_waste_type
def __get_next_waste_type(self):
next_waste_type = []
try:
for waste in self.waste_data_after_date_selected:
item_date = waste["date"]
if item_date == self.next_waste_date:
item_name = waste["type"]
next_waste_type.append(item_name)
if not next_waste_type:
next_waste_type.append(self.default_label)
except Exception as err:
_LOGGER.error(f"Other error occurred _get_next_waste_type: {err}")
return next_waste_type
# Generate sensor data for custom sensors
def _gen_next_sensor_data(self):
next_sensor = {}
try:
next_sensor["next_date"] = self.next_waste_date
next_sensor["next_in_days"] = self.next_waste_in_days
next_sensor["next_type"] = ", ".join(self.next_waste_type)
except Exception as err:
_LOGGER.error(f"Other error occurred _gen_next_sensor_data: {err}")
return next_sensor
@property
def next_sensor_data(self):
return self.data

181
custom_components/afvalwijzer/common/waste_data_transformer.py Normal file
View File

@@ -0,0 +1,181 @@
from datetime import datetime, timedelta
from ..common.day_sensor_data import DaySensorData
from ..common.next_sensor_data import NextSensorData
from ..const.const import _LOGGER
# import sys
# def excepthook(type, value, traceback):
# _LOGGER.error(value)
# sys.excepthook = excepthook
class WasteDataTransformer(object):
##########################################################################
# INIT
##########################################################################
def __init__(
self,
waste_data_raw,
exclude_pickup_today,
exclude_list,
default_label,
):
self.waste_data_raw = waste_data_raw
self.exclude_pickup_today = exclude_pickup_today
self.exclude_list = exclude_list.strip().lower()
self.default_label = default_label
TODAY = datetime.now().strftime("%d-%m-%Y")
self.DATE_TODAY = datetime.strptime(TODAY, "%d-%m-%Y")
self.DATE_TOMORROW = datetime.strptime(TODAY, "%d-%m-%Y") + timedelta(days=1)
(
self._waste_data_with_today,
self._waste_data_without_today,
) = self.__structure_waste_data() # type: ignore
(
self._waste_data_provider,
self._waste_types_provider,
self._waste_data_custom,
self._waste_types_custom,
) = self.__gen_sensor_waste_data()
##########################################################################
# STRUCTURE ALL WASTE DATA IN CUSTOM FORMAT
#########################################################################
def __structure_waste_data(self):
try:
waste_data_with_today = {}
waste_data_without_today = {}
for item in self.waste_data_raw:
item_date = datetime.strptime(item["date"], "%Y-%m-%d")
item_name = item["type"].strip().lower()
if (
item_name not in self.exclude_list
and item_name not in waste_data_with_today
and item_date >= self.DATE_TODAY
):
waste_data_with_today[item_name] = item_date
for item in self.waste_data_raw:
item_date = datetime.strptime(item["date"], "%Y-%m-%d")
item_name = item["type"].strip().lower()
if (
item_name not in self.exclude_list
and item_name not in waste_data_without_today
and item_date > self.DATE_TODAY
):
waste_data_without_today[item_name] = item_date
try:
for item in self.waste_data_raw:
item_name = item["type"].strip().lower()
if item_name not in self.exclude_list:
if item_name not in waste_data_with_today.keys():
waste_data_with_today[item_name] = self.default_label
if item_name not in waste_data_without_today.keys():
waste_data_without_today[item_name] = self.default_label
except Exception as err:
_LOGGER.error(f"Other error occurred: {err}")
return waste_data_with_today, waste_data_without_today
except Exception as err:
_LOGGER.error(f"Other error occurred: {err}")
##########################################################################
# GENERATE REQUIRED DATA FOR HASS SENSORS
##########################################################################
def __gen_sensor_waste_data(self):
if self.exclude_pickup_today.casefold() in ("false", "no"):
date_selected = self.DATE_TODAY
waste_data_provider = self._waste_data_with_today
else:
date_selected = self.DATE_TOMORROW
waste_data_provider = self._waste_data_without_today
try:
waste_types_provider = sorted(
{
waste["type"]
for waste in self.waste_data_raw
if waste["type"] not in self.exclude_list
}
)
except Exception as err:
_LOGGER.error(f"Other error occurred waste_types_provider: {err}")
try:
waste_data_formatted = [
{
"type": waste["type"],
"date": datetime.strptime(waste["date"], "%Y-%m-%d"),
}
for waste in self.waste_data_raw
if waste["type"] in waste_types_provider
]
except Exception as err:
_LOGGER.error(f"Other error occurred waste_data_formatted: {err}")
days = DaySensorData(waste_data_formatted, self.default_label)
try:
waste_data_after_date_selected = list(
filter(
lambda waste: waste["date"] >= date_selected, waste_data_formatted
)
)
except Exception as err:
_LOGGER.error(f"Other error occurred waste_data_after_date_selected: {err}")
next_data = NextSensorData(waste_data_after_date_selected, self.default_label)
try:
waste_data_custom = {**next_data.next_sensor_data, **days.day_sensor_data}
except Exception as err:
_LOGGER.error(f"Other error occurred waste_data_custom: {err}")
try:
waste_types_custom = list(sorted(waste_data_custom.keys()))
except Exception as err:
_LOGGER.error(f"Other error occurred waste_types_custom: {err}")
return (
waste_data_provider,
waste_types_provider,
waste_data_custom,
waste_types_custom,
)
##########################################################################
# PROPERTIES FOR EXECUTION
##########################################################################
@property
def waste_data_with_today(self):
return self._waste_data_with_today
@property
def waste_data_without_today(self):
return self._waste_data_without_today
@property
def waste_data_provider(self):
return self._waste_data_provider
@property
def waste_types_provider(self):
return self._waste_types_provider
@property
def waste_data_custom(self):
return self._waste_data_custom
@property
def waste_types_custom(self):
return self._waste_types_custom

0
custom_components/afvalwijzer/const/__init__.py Normal file
View File

131
custom_components/afvalwijzer/const/const.py Normal file
View File

@@ -0,0 +1,131 @@
from datetime import timedelta
import logging
_LOGGER = logging.getLogger(__name__)
API = "api"
NAME = "afvalwijzer"
VERSION = "2022.11.02"
ISSUE_URL = "https://github.com/xirixiz/homeassistant-afvalwijzer/issues"
SENSOR_COLLECTOR_TO_URL = {
"afvalwijzer_data_default": [
"https://api.{0}.nl/webservices/appsinput/?apikey=5ef443e778f41c4f75c69459eea6e6ae0c2d92de729aa0fc61653815fbd6a8ca&method=postcodecheck&postcode={1}&street=&huisnummer={2}&toevoeging={3}&app_name=afvalwijzer&platform=web&afvaldata={4}&langs=nl&"
],
"afvalstoffendienstkalender": [
"https://{0}.afvalstoffendienstkalender.nl/nl/{1}/{2}/"
],
"afvalstoffendienstkalender-s-hertogenbosch": [
"https://afvalstoffendienstkalender.nl/nl/{0}/{1}/"
],
"ximmio01": [
"https://wasteapi.ximmio.com/api/FetchAdress",
"https://wasteapi.ximmio.com/api/GetCalendar",
],
"ximmio02": [
"https://wasteprod2api.ximmio.com/api/FetchAdress",
"https://wasteprod2api.ximmio.com/api/GetCalendar",
],
}
SENSOR_COLLECTORS_OPZET = {
"alkmaar": "https://www.stadswerk072.nl",
"alphenaandenrijn": "https://afvalkalender.alphenaandenrijn.nl",
"berkelland": "https://afvalkalender.gemeenteberkelland.nl",
"blink": "https://mijnblink.nl",
"cranendonck": "https://afvalkalender.cranendonck.nl",
"cyclus": "https://afvalkalender.cyclusnv.nl",
"dar": "https://afvalkalender.dar.nl",
"denhaag": "https://huisvuilkalender.denhaag.nl",
"gad": "https://inzamelkalender.gad.nl",
"hvc": "https://inzamelkalender.hvcgroep.nl",
"lingewaard": "https://afvalwijzer.lingewaard.nl",
"middelburg-vlissingen": "https://afvalwijzer.middelburgvlissingen.nl",
"montfoort": "https://afvalkalender.cyclusnv.nl",
"peelenmaas": "https://afvalkalender.peelenmaas.nl",
"prezero": "https://inzamelwijzer.prezero.nl",
"purmerend": "https://afvalkalender.purmerend.nl",
"rmn": "https://inzamelschema.rmn.nl",
"schouwen-duiveland": "https://afvalkalender.schouwen-duiveland.nl",
"spaarnelanden": "https://afvalwijzer.spaarnelanden.nl",
"sudwestfryslan": "https://afvalkalender.sudwestfryslan.nl",
"suez": "https://inzamelwijzer.prezero.nl",
"venray": "https://afvalkalender.venray.nl",
"voorschoten": "https://afvalkalender.voorschoten.nl",
"waalre": "https://afvalkalender.waalre.nl",
"zrd": "https://afvalkalender.zrd.nl",
}
SENSOR_COLLECTORS_ICALENDAR = {
"eemsdelta": "https://www.eemsdelta.nl/trash-calendar/download/{1}/{2}",
}
SENSOR_COLLECTORS_AFVALWIJZER = [
"mijnafvalwijzer",
"afvalstoffendienstkalender",
"afvalstoffendienstkalender-s-hertogenbosch",
"rova",
]
SENSOR_COLLECTORS_XIMMIO = {
"acv": "f8e2844a-095e-48f9-9f98-71fceb51d2c3",
"almere": "53d8db94-7945-42fd-9742-9bbc71dbe4c1",
"areareiniging": "adc418da-d19b-11e5-ab30-625662870761",
"avalex": "f7a74ad1-fdbf-4a43-9f91-44644f4d4222",
"avri": "78cd4156-394b-413d-8936-d407e334559a",
"bar": "bb58e633-de14-4b2a-9941-5bc419f1c4b0",
"hellendoorn": "24434f5b-7244-412b-9306-3a2bd1e22bc1",
"meerlanden": "800bf8d7-6dd1-4490-ba9d-b419d6dc8a45",
"meppel": "b7a594c7-2490-4413-88f9-94749a3ec62a",
"rad": "13a2cad9-36d0-4b01-b877-efcb421a864d",
"twentemilieu": "8d97bb56-5afd-4cbc-a651-b4f7314264b4",
"waardlanden": "942abcf6-3775-400d-ae5d-7380d728b23c",
"westland": "6fc75608-126a-4a50-9241-a002ce8c8a6c",
"ximmio": "800bf8d7-6dd1-4490-ba9d-b419d6dc8a45",
"reinis": "9dc25c8a-175a-4a41-b7a1-83f237a80b77",
}
SENSOR_COLLECTORS_RD4 = {
"rd4": "https://data.rd4.nl/api/v1/waste-calendar?postal_code={0}&house_number={1}&house_number_extension={2}&year={3}",
}
SENSOR_COLLECTORS_DEAFVALAPP = {
"deafvalapp": "https://dataservice.deafvalapp.nl/dataservice/DataServiceServlet?service=OPHAALSCHEMA&land=NL&postcode={0}&straatId=0&huisnr={1}&huisnrtoev={2}",
}
CONF_COLLECTOR = "provider"
CONF_API_TOKEN = "api_token"
CONF_POSTAL_CODE = "postal_code"
CONF_STREET_NUMBER = "street_number"
CONF_SUFFIX = "suffix"
CONF_DATE_FORMAT = "date_format"
CONF_EXCLUDE_PICKUP_TODAY = "exclude_pickup_today"
CONF_DEFAULT_LABEL = "default_label"
CONF_ID = "id"
CONF_EXCLUDE_LIST = "exclude_list"
SENSOR_PREFIX = "afvalwijzer "
SENSOR_ICON = "mdi:recycle"
ATTR_LAST_UPDATE = "last_update"
ATTR_IS_COLLECTION_DATE_TODAY = "is_collection_date_today"
ATTR_IS_COLLECTION_DATE_TOMORROW = "is_collection_date_tomorrow"
ATTR_IS_COLLECTION_DATE_DAY_AFTER_TOMORROW = "is_collection_date_day_after_tomorrow"
ATTR_DAYS_UNTIL_COLLECTION_DATE = "days_until_collection_date"
ATTR_YEAR_MONTH_DAY_DATE = "year_month_day_date"
MIN_TIME_BETWEEN_UPDATES = timedelta(hours=1)
PARALLEL_UPDATES = 1
SCAN_INTERVAL = timedelta(seconds=30)
DOMAIN = "afvalwijzer"
DOMAIN_DATA = "afvalwijzer_data"
STARTUP_MESSAGE = f"""
-------------------------------------------------------------------,
Afvalwijzer - {VERSION},
This is a custom integration!,
If you have any issues with this you need to open an issue here:,
https://github.com/xirixiz/homeassistant-afvalwijzer/issues,
-------------------------------------------------------------------,
"""

14
custom_components/afvalwijzer/manifest.json Normal file
View File

@@ -0,0 +1,14 @@
{
"domain": "afvalwijzer",
"name": "Afvalwijzer",
"version": "2022.11.02",
"iot_class": "cloud_polling",
"documentation": "https://github.com/xirixiz/homeassistant-afvalwijzer/blob/master/README.md",
"issue_tracker": "https://github.com/xirixiz/homeassistant-afvalwijzer/issues",
"config_flow": false,
"dependencies": [],
"codeowners": [
"@xirixiz"
],
"requirements": []
}

146
custom_components/afvalwijzer/sensor.py Normal file
View File

@@ -0,0 +1,146 @@
#!/usr/bin/env python3
"""
Sensor component Afvalwijzer
Author: Bram van Dartel - xirixiz
"""
from functools import partial
from homeassistant.components.sensor import PLATFORM_SCHEMA
import homeassistant.helpers.config_validation as cv
from homeassistant.util import Throttle
import voluptuous as vol
from .collector.main_collector import MainCollector
from .const.const import (
_LOGGER,
CONF_COLLECTOR,
CONF_DEFAULT_LABEL,
CONF_EXCLUDE_LIST,
CONF_EXCLUDE_PICKUP_TODAY,
CONF_ID,
CONF_POSTAL_CODE,
CONF_STREET_NUMBER,
CONF_SUFFIX,
MIN_TIME_BETWEEN_UPDATES,
PARALLEL_UPDATES,
SCAN_INTERVAL,
STARTUP_MESSAGE,
)
from .sensor_custom import CustomSensor
from .sensor_provider import ProviderSensor
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Optional(
CONF_COLLECTOR, default="mijnafvalwijzer"
): cv.string,
vol.Required(CONF_POSTAL_CODE, default="1234AB"): cv.string,
vol.Required(CONF_STREET_NUMBER, default="5"): cv.string,
vol.Optional(CONF_SUFFIX, default=""): cv.string,
vol.Optional(CONF_EXCLUDE_PICKUP_TODAY, default="true"): cv.string,
vol.Optional(CONF_EXCLUDE_LIST, default=""): cv.string,
vol.Optional(CONF_DEFAULT_LABEL, default="Geen"): cv.string,
vol.Optional(CONF_ID.strip().lower(), default=""): cv.string,
}
)
_LOGGER.info(STARTUP_MESSAGE)
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
provider = config.get(CONF_COLLECTOR)
postal_code = config.get(CONF_POSTAL_CODE)
street_number = config.get(CONF_STREET_NUMBER)
suffix = config.get(CONF_SUFFIX)
exclude_pickup_today = config.get(CONF_EXCLUDE_PICKUP_TODAY)
exclude_list = config.get(CONF_EXCLUDE_LIST)
default_label = config.get(CONF_DEFAULT_LABEL)
_LOGGER.debug(f"Afvalwijzer provider = {provider}")
_LOGGER.debug(f"Afvalwijzer zipcode = {postal_code}")
_LOGGER.debug(f"Afvalwijzer street_number = {street_number}")
try:
collector = await hass.async_add_executor_job(
partial(
MainCollector,
provider,
postal_code,
street_number,
suffix,
exclude_pickup_today,
exclude_list,
default_label,
)
)
except ValueError as err:
_LOGGER.error(f"Check afvalwijzer platform settings {err.args}")
fetch_data = AfvalwijzerData(config)
waste_types_provider = collector.waste_types_provider
_LOGGER.debug(f"Generating waste_types_provider list = {waste_types_provider}")
waste_types_custom = collector.waste_types_custom
_LOGGER.debug(f"Generating waste_types_custom list = {waste_types_custom}")
entities = []
for waste_type in waste_types_provider:
_LOGGER.debug(f"Adding sensor provider: {waste_type}")
entities.append(ProviderSensor(hass, waste_type, fetch_data, config))
for waste_type in waste_types_custom:
_LOGGER.debug(f"Adding sensor custom: {waste_type}")
entities.append(CustomSensor(hass, waste_type, fetch_data, config))
_LOGGER.debug(f"Entities appended = {entities}")
async_add_entities(entities)
class AfvalwijzerData(object):
def __init__(self, config):
self.config = config
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
provider = self.config.get(CONF_COLLECTOR)
postal_code = self.config.get(CONF_POSTAL_CODE)
street_number = self.config.get(CONF_STREET_NUMBER)
suffix = self.config.get(CONF_SUFFIX)
exclude_pickup_today = self.config.get(CONF_EXCLUDE_PICKUP_TODAY)
default_label = self.config.get(CONF_DEFAULT_LABEL)
exclude_list = self.config.get(CONF_EXCLUDE_LIST)
try:
collector = MainCollector(
provider,
postal_code,
street_number,
suffix,
exclude_pickup_today,
exclude_list,
default_label,
)
except ValueError as err:
_LOGGER.error(f"Check afvalwijzer platform settings {err.args}")
# waste data provider update - with today
try:
self.waste_data_with_today = collector.waste_data_with_today
except ValueError as err:
_LOGGER.error(f"Check waste_data_provider {err.args}")
self.waste_data_with_today = default_label
# waste data provider update - without today
try:
self.waste_data_without_today = collector.waste_data_without_today
except ValueError as err:
_LOGGER.error(f"Check waste_data_provider {err.args}")
self.waste_data_without_today = default_label
# waste data custom update
try:
self.waste_data_custom = collector.waste_data_custom
except ValueError as err:
_LOGGER.error(f"Check waste_data_custom {err.args}")
self.waste_data_custom = default_label

106
custom_components/afvalwijzer/sensor_custom.py Normal file
View File

@@ -0,0 +1,106 @@
#!/usr/bin/env python3
from datetime import datetime
import hashlib
from homeassistant.helpers.entity import Entity
from homeassistant.util import Throttle
from .const.const import (
_LOGGER,
ATTR_LAST_UPDATE,
ATTR_YEAR_MONTH_DAY_DATE,
CONF_DEFAULT_LABEL,
CONF_ID,
CONF_POSTAL_CODE,
CONF_STREET_NUMBER,
CONF_SUFFIX,
MIN_TIME_BETWEEN_UPDATES,
PARALLEL_UPDATES,
SENSOR_ICON,
SENSOR_PREFIX,
)
class CustomSensor(Entity):
def __init__(self, hass, waste_type, fetch_data, config):
self.hass = hass
self.waste_type = waste_type
self.fetch_data = fetch_data
self.config = config
self._id_name = self.config.get(CONF_ID)
self._default_label = self.config.get(CONF_DEFAULT_LABEL)
self._last_update = None
self._name = (
SENSOR_PREFIX + (f"{self._id_name} " if len(self._id_name) > 0 else "")
) + self.waste_type
self._state = self.config.get(CONF_DEFAULT_LABEL)
self._icon = SENSOR_ICON
self._year_month_day_date = None
self._unique_id = hashlib.sha1(
f"{self.waste_type}{self.config.get(CONF_ID)}{self.config.get(CONF_POSTAL_CODE)}{self.config.get(CONF_STREET_NUMBER)}{self.config.get(CONF_SUFFIX,'')}".encode(
"utf-8"
)
).hexdigest()
@property
def name(self):
return self._name
@property
def unique_id(self):
return self._unique_id
@property
def icon(self):
return self._icon
@property
def state(self):
return self._state
@property
def extra_state_attributes(self):
if self._year_month_day_date is not None:
return {
ATTR_LAST_UPDATE: self._last_update,
ATTR_YEAR_MONTH_DAY_DATE: self._year_month_day_date,
}
else:
return {
ATTR_LAST_UPDATE: self._last_update,
}
@Throttle(MIN_TIME_BETWEEN_UPDATES)
async def async_update(self):
await self.hass.async_add_executor_job(self.fetch_data.update)
waste_data_custom = self.fetch_data.waste_data_custom
try:
# Add attribute, set the last updated status of the sensor
self._last_update = datetime.now().strftime("%d-%m-%Y %H:%M")
if isinstance(waste_data_custom[self.waste_type], datetime):
_LOGGER.debug(
f"Generating state via AfvalwijzerCustomSensor for = {self.waste_type} with value {waste_data_custom[self.waste_type].date()}"
)
# Add the US date format
collection_date_us = waste_data_custom[self.waste_type].date()
self._year_month_day_date = str(collection_date_us)
# Add the NL date format as default state
self._state = datetime.strftime(
waste_data_custom[self.waste_type].date(), "%d-%m-%Y"
)
else:
_LOGGER.debug(
f"Generating state via AfvalwijzerCustomSensor for = {self.waste_type} with value {waste_data_custom[self.waste_type]}"
)
# Add non-date as default state
self._state = str(waste_data_custom[self.waste_type])
except ValueError:
_LOGGER.debug("ValueError AfvalwijzerCustomSensor - unable to set value!")
self._state = self._default_label
self._year_month_day_date = None
self._last_update = datetime.now().strftime("%d-%m-%Y %H:%M")

138
custom_components/afvalwijzer/sensor_provider.py Normal file
View File

@@ -0,0 +1,138 @@
#!/usr/bin/env python3
from datetime import date, datetime, timedelta
import hashlib
from homeassistant.helpers.entity import Entity
from homeassistant.util import Throttle
from .const.const import (
_LOGGER,
ATTR_DAYS_UNTIL_COLLECTION_DATE,
ATTR_IS_COLLECTION_DATE_DAY_AFTER_TOMORROW,
ATTR_IS_COLLECTION_DATE_TODAY,
ATTR_IS_COLLECTION_DATE_TOMORROW,
ATTR_LAST_UPDATE,
ATTR_YEAR_MONTH_DAY_DATE,
CONF_DEFAULT_LABEL,
CONF_EXCLUDE_PICKUP_TODAY,
CONF_ID,
CONF_POSTAL_CODE,
CONF_STREET_NUMBER,
CONF_SUFFIX,
MIN_TIME_BETWEEN_UPDATES,
PARALLEL_UPDATES,
SENSOR_ICON,
SENSOR_PREFIX,
)
class ProviderSensor(Entity):
def __init__(self, hass, waste_type, fetch_data, config):
self.hass = hass
self.waste_type = waste_type
self.fetch_data = fetch_data
self.config = config
self._id_name = self.config.get(CONF_ID)
self._default_label = self.config.get(CONF_DEFAULT_LABEL)
self._exclude_pickup_today = self.config.get(CONF_EXCLUDE_PICKUP_TODAY)
self._name = (
SENSOR_PREFIX
+ (self._id_name + " " if len(self._id_name) > 0 else "")
+ self.waste_type
)
self._icon = SENSOR_ICON
self._state = self.config.get(CONF_DEFAULT_LABEL)
self._last_update = None
self._days_until_collection_date = None
self._is_collection_date_today = False
self._is_collection_date_tomorrow = False
self._is_collection_date_day_after_tomorrow = False
self._year_month_day_date = None
self._unique_id = hashlib.sha1(
f"{self.waste_type}{self.config.get(CONF_ID)}{self.config.get(CONF_POSTAL_CODE)}{self.config.get(CONF_STREET_NUMBER)}{self.config.get(CONF_SUFFIX,'')}".encode(
"utf-8"
)
).hexdigest()
@property
def name(self):
return self._name
@property
def unique_id(self):
return self._unique_id
@property
def icon(self):
return self._icon
@property
def state(self):
return self._state
@property
def extra_state_attributes(self):
return {
ATTR_LAST_UPDATE: self._last_update,
ATTR_DAYS_UNTIL_COLLECTION_DATE: self._days_until_collection_date,
ATTR_IS_COLLECTION_DATE_TODAY: self._is_collection_date_today,
ATTR_IS_COLLECTION_DATE_TOMORROW: self._is_collection_date_tomorrow,
ATTR_IS_COLLECTION_DATE_DAY_AFTER_TOMORROW: self._is_collection_date_day_after_tomorrow,
ATTR_YEAR_MONTH_DAY_DATE: self._year_month_day_date,
}
@Throttle(MIN_TIME_BETWEEN_UPDATES)
async def async_update(self):
await self.hass.async_add_executor_job(self.fetch_data.update)
if self._exclude_pickup_today.casefold() in ("false", "no"):
waste_data_provider = self.fetch_data.waste_data_with_today
else:
waste_data_provider = self.fetch_data.waste_data_without_today
try:
if not waste_data_provider or self.waste_type not in waste_data_provider:
raise (ValueError)
# Add attribute, set the last updated status of the sensor
self._last_update = datetime.now().strftime("%d-%m-%Y %H:%M")
if isinstance(waste_data_provider[self.waste_type], datetime):
_LOGGER.debug(
f"Generating state via AfvalwijzerCustomSensor for = {self.waste_type} with value {waste_data_provider[self.waste_type].date()}"
)
# Add the US date format
collection_date_us = waste_data_provider[self.waste_type].date()
self._year_month_day_date = str(collection_date_us)
# Add the days until the collection date
delta = collection_date_us - date.today()
self._days_until_collection_date = delta.days
# Check if the collection days are in today, tomorrow and/or the day after tomorrow
self._is_collection_date_today = date.today() == collection_date_us
self._is_collection_date_tomorrow = (
date.today() + timedelta(days=1) == collection_date_us
)
self._is_collection_date_day_after_tomorrow = (
date.today() + timedelta(days=2) == collection_date_us
)
# Add the NL date format as default state
self._state = datetime.strftime(
waste_data_provider[self.waste_type].date(), "%d-%m-%Y"
)
else:
_LOGGER.debug(
f"Generating state via AfvalwijzerCustomSensor for = {self.waste_type} with value {waste_data_provider[self.waste_type]}"
)
# Add non-date as default state
self._state = str(waste_data_provider[self.waste_type])
except ValueError:
_LOGGER.debug("ValueError AfvalwijzerProviderSensor - unable to set value!")
self._state = self._default_label
self._days_until_collection_date = None
self._year_month_day_date = None
self._is_collection_date_today = False
self._is_collection_date_tomorrow = False
self._is_collection_date_day_after_tomorrow = False
self._last_update = datetime.now().strftime("%d-%m-%Y %H:%M")

397
custom_components/afvalwijzer/tests/dummy_data.json Normal file
View File

@@ -0,0 +1,397 @@
[
{
"nameType": "gft",
"type": "gft",
"date": "2021-01-02"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-01-05"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-01-08"
},
{
"nameType": "kerstbomen",
"type": "kerstbomen",
"date": "2021-01-09"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-01-15"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-01-19"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-01-20"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-01-29"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-02-02"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-02-05"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-02-12"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-02-16"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-02-17"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-02-26"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-03-02"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-03-05"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-03-12"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-03-16"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-03-17"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-03-26"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-03-30"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-04-02"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-04-09"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-04-13"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-04-21"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-04-23"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-04-30"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-04-30"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-05-07"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-05-11"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-05-19"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-05-21"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-05-25"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-05-28"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-06-04"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-06-08"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-06-16"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-06-18"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-06-22"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-06-25"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-07-02"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-07-06"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-07-16"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-07-20"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-07-21"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-07-23"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-07-30"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-08-03"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-08-13"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-08-17"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-08-18"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-08-20"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-08-27"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-08-31"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-09-10"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-09-14"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-09-15"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-09-17"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-09-24"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-09-28"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-10-08"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-10-12"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-10-15"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-10-20"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-10-22"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-10-26"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-11-05"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-11-09"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-11-12"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-11-17"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-11-19"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-11-19"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-12-03"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-12-07"
},
{
"nameType": "restafval",
"type": "restafval",
"date": "2021-12-10"
},
{
"nameType": "papier",
"type": "papier",
"date": "2021-12-15"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-12-17"
},
{
"nameType": "pmd",
"type": "pmd",
"date": "2021-12-21"
},
{
"nameType": "gft",
"type": "gft",
"date": "2021-12-31"
}
]

110
custom_components/afvalwijzer/tests/test_module.py Normal file
View File

@@ -0,0 +1,110 @@
#!/usr/bin/env python3
"""
Sensor component for AfvalDienst
Author: Bram van Dartel - xirixiz
import afvalwijzer
from afvalwijzer.collector.mijnafvalwijzer import AfvalWijzer
AfvalWijzer().get_data('','','')
python3 -m afvalwijzer.tests.test_module
"""
from ..collector.main_collector import MainCollector
# provider = "afvalstoffendienstkalender"
# api_token = "5ef443e778f41c4f75c69459eea6e6ae0c2d92de729aa0fc61653815fbd6a8ca"
# Afvalstoffendienstkalender
# postal_code = "5391KE"
# street_number = "1"
# Common
suffix = ""
exclude_pickup_today = "True"
default_label = "Geen"
exclude_list = ""
# DeAfvalapp
# provider = "deafvalapp"
# postal_code = "6105CN"
# street_number = "1"
# Icalendar
# provider = "eemsdelta"
# postal_code = "9991AB"
# street_number = "2"
# Afvalwijzer
# provider = "mijnafvalwijzer"
# postal_code = "5146eg"
# street_number = "1"
# Opzet
# provider = "prezero"
# postal_code = "6665CN"
# street_number = "1"
# RD4
# provider = "rd4"
# postal_code = "6301ET"
# street_number = "24"
# suffix = "C"
# Ximmio
provider = "meerlanden"
postal_code = "2121xt"
street_number = "38"
# Ximmio
# provider = "acv"
# postal_code = "6713CG"
# street_number = "11"
# postal_code = postal_code.strip().upper()
collector = MainCollector(
provider,
postal_code,
street_number,
suffix,
exclude_pickup_today,
exclude_list,
default_label,
)
# MainCollector(
# provider,
# postal_code,
# street_number,
# suffix,
# exclude_pickup_today,
# exclude_list,
# default_label,
# )
# data = XimmioCollector().get_waste_data_provider("meerlanden", postal_code2, street_number2, suffix, default_label, exclude_list)
# data2 = MijnAfvalWijzerCollector().get_waste_data_provider("mijnafvalwijzer", postal_code, street_number, suffix, default_label, exclude_list)
#########################################################################################################
print("\n")
print(collector.waste_data_with_today)
print(collector.waste_data_without_today)
print(collector.waste_data_custom)
print(collector.waste_types_provider)
print(collector.waste_types_custom)
print("\n")
# for key, value in afval1.items():
# print(key, value)
# print("\n")
# for key, value in afval2.items():
# print(key, value)