@camstack/addon-waste-collections 0.0.0-stage → 0.1.1

package/python/vendor/waste_collection_schedule/source/hausmuell_info.py

@@ -0,0 +1,411 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "hausmüll.info"
+DESCRIPTION = "Source for hausmüll.info."
+URL = "https://hausmuell.info"
+COUNTRY = "de"
+TEST_CASES = {
+    "Dietzhausen Am Rain 10 ebkds": {
+        "ort": "Dietzhausen",
+        "strasse": "Am Rain",
+        "hausnummer": 10,
+        "subdomain": "ebkds",
+    },
+    "Adam-Ries-Straße 5, Erfurt": {
+        "subdomain": "erfurt",
+        "strasse": "Adam-Ries-Straße",
+        "hausnummer": "5",
+    },
+    "schmalkalden-meiningen, Obermaßfeld-Grimmenthal": {
+        "subdomain": "schmalkalden-meiningen",
+        "ort": "Obermaßfeld-Grimmenthal",
+    },
+    "schmalkalden-meiningen, Dillstädt": {
+        "subdomain": "schmalkalden-meiningen",
+        "ort": "Dillstädt",
+    },
+    "schmalkalden-meiningen Zella-Mehils Benshausen Albrechter Straße": {
+        "subdomain": "schmalkalden-meiningen",
+        "ort": "Zella-Mehlis",
+        "ortsteil": "Benshausen",
+        "strasse": "Albrechtser Straße",
+    },
+    "schmalkalden-meiningen Breitungen, Bußhof": {
+        "subdomain": "schmalkalden-meiningen",
+        "ort": "Breitungen",
+        "ortsteil": "Bußhof",
+    },
+    "ew, Döringsdorf, Wanfrieder Str.": {
+        "subdomain": "ew",
+        "ort": "Döringsdorf",
+        "strasse": "Wanfrieder Str.",
+    },
+    "ew, Bernterode (WBS), Hinter den Höfen": {
+        "subdomain": "ew",
+        "ort": "Bernterode (WBS)",
+        "strasse": "Hinter den Höfen",
+    },
+    "azv, Berka vor dem Hainich": {
+        "subdomain": "azv",
+        "ort": "Berka vor dem Hainich",
+    },
+    "azv, Hörselberg-Hainich": {
+        "subdomain": "azv",
+        "ort": "Hörselberg-Hainich",
+        "ortsteil": "Ettenhausen/Nesse",
+    },
+    "börde, Belsdorf (Altkreis BÖ), Alleringerslebener Straße 15a": {
+        "subdomain": "boerde",
+        "ort": "Belsdorf (Altkreis BÖ)",
+        "strasse": "Alleringerslebener Straße",
+        "hausnummer": "15a",
+    },
+    "chemnitz, Straße des Friedens/Wittgensdorf 2 a": {
+        "subdomain": "asc",
+        "strasse": "Straße des Friedens/Wittgensdorf",
+        "hausnummer": "2 a",
+    },
+    "wesel Flüren, In der Flürener Heide": {
+        "subdomain": "wesel",
+        "ort": "Flüren",
+        "strasse": "In der Flürener Heide",
+    },
+}
+
+
+ICON_MAP = {
+    "hausmüll": Icons.GENERAL_WASTE,
+    "restabfall": Icons.GENERAL_WASTE,
+    "restmüll": Icons.GENERAL_WASTE,
+    "glass": Icons.GLASS,
+    "biomüll": Icons.BIO_KITCHEN,
+    "biomüll mit reinigung": Icons.BIO_KITCHEN,
+    "bioabfall mit reinigung": Icons.BIO_KITCHEN,
+    "bioabfall": Icons.BIO_KITCHEN,
+    "papier": Icons.PAPER,
+    "papier, pappe, karton": Icons.PAPER,
+    "papier, pappe & kart.": Icons.PAPER,
+    "pappe, papier & kart.": Icons.PAPER,
+    "altpapier": Icons.PAPER,
+    "gelbe tonne": Icons.PLASTIC_PACKAGING,
+    "gelber sack": Icons.PLASTIC_PACKAGING,
+    "gelber sack / gelbe tonne": Icons.PLASTIC_PACKAGING,
+    "leichtverpackungen": Icons.RECYCLING,
+    "leichtstoffverpackungen": Icons.RECYCLING,
+    "grünschnitt": Icons.GARDEN,
+    "schadstoffe": Icons.HAZARDOUS,
+    "schadstoffmobil": Icons.HAZARDOUS,
+    "problemmüll": Icons.HAZARDOUS,
+}
+
+SUPPORTED_PROVIDERS = [
+    {
+        "subdomain": "ebkds",
+        "title": "Eigenbetrieb Kommunalwirtschaftliche Dienstleistungen Suhl",
+        "url": "https://www.ebkds.de/",
+    },
+    {
+        "subdomain": "erfurt",
+        "title": "Stadtwerke Erfurt, SWE",
+        "url": "https://www.stadtwerke-erfurt.de/",
+    },
+    {
+        "subdomain": "schmalkalden-meiningen",
+        "title": "Kreiswerke Schmalkalden-Meiningen GmbH",
+        "url": "https://www.kwsm.de/",
+    },
+    {
+        "subdomain": "ew",
+        "title": "Eichsfeldwerke GmbH",
+        "url": "https://www.eichsfeldwerke.de/",
+    },
+    {
+        "subdomain": "azv",
+        "title": "Abfallwirtschaftszweckverband Wartburgkreis (AZV)",
+        "url": "https://www.azv-wak-ea.de/",
+    },
+    {
+        "subdomain": "boerde",
+        "title": "Landkreis Börde AöR (KsB)",
+        "url": "https://www.ks-boerde.de",
+    },
+    {
+        "subdomain": "asc",
+        "title": "Chemnitz (ASR)",
+        "url": "https://www.asr-chemnitz.de/",
+    },
+    {"subdomain": "wesel", "title": "ASG Wesel", "url": "https://www.asg-wesel.de/"},
+]
+
+EXTRA_INFO = [
+    {
+        "title": p["title"],
+        "url": p["url"],
+        "country": "de",
+        "default_params": {"subdomain": p["subdomain"]},
+    }
+    for p in SUPPORTED_PROVIDERS
+]
+
+
+API_URL = "https://{}.hausmuell.info/"
+
+
+def replace_special_chars(s: str) -> str:
+    return (
+        s.replace("ß", "s")
+        .replace("ä", "a")
+        .replace("ö", "o")
+        .replace("ü", "u")
+        .replace("Ä", "A")
+        .replace("Ö", "O")
+        .replace("Ü", "U")
+    )
+
+
+def replace_special_chars_with_underscore(s: str) -> str:
+    return (
+        s.replace("ß", "_")
+        .replace("ä", "_")
+        .replace("ö", "_")
+        .replace("ü", "_")
+        .replace("Ä", "_")
+        .replace("Ö", "_")
+        .replace("Ü", "_")
+    )
+
+
+def replace_special_chars_args(d: dict, replace_func=replace_special_chars) -> dict:
+    to_return = {}
+    for k, v in d.items():
+        if isinstance(v, list):
+            to_return[k] = [replace_func(i) for i in v]
+        else:
+            to_return[k] = replace_func(v)
+
+    return to_return
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "subdomain": "Subdomain",
+        "ort": "Ort",
+        "ortsteil": "Ortsteil",
+        "strasse": "Straße",
+        "hausnummer": "Hausnummer",
+    },
+    "en": {
+        "subdomain": "Subdomain",
+        "ort": "City",
+        "ortsteil": "District",
+        "strasse": "Street",
+        "hausnummer": "House number",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self,
+        subdomain: str,
+        ort: str | None = None,
+        ortsteil: str | None = None,
+        strasse: str | None = None,
+        hausnummer: str | int | None = None,
+    ):
+        self._ort: str = ort if ort else ""
+        self._strasse: str = strasse if strasse else ""
+        self._hausnummer: str = str(hausnummer) if hausnummer else ""
+        self._ortsteil: str = ortsteil if ortsteil else ""
+
+        self._api_url: str = API_URL.format(subdomain)
+        self._ics = ICS()
+
+    def _get_elemts(self, response_text: str) -> list[str]:
+        to_return: list[str] = []
+
+        li = BeautifulSoup(response_text, "html.parser").find("li")
+
+        if not li:
+            return ["0"]
+        onclick = li.get("onclick")
+        if not onclick:
+            return ["0"]
+
+        ids = onclick.split(")")[0].split("(")[1].split(",")
+
+        to_return = [i.strip() for i in ids if i.strip().isdigit()]
+        return to_return
+
+    def _has_result(self, response_text: str) -> bool:
+        """Check whether a search response actually contains a matching entry.
+
+        The API returns a `<li>` with an `onclick` attribute for a real match,
+        and either an empty `<ul>` or a `<li>Keinen Eintrag gefunden</li>`
+        (no `onclick`) when nothing matches.
+        """
+        return (
+            BeautifulSoup(response_text, "html.parser").find(
+                "li", attrs={"onclick": True}
+            )
+            is not None
+        )
+
+    def request_all(
+        self, url: str, data: dict, params: dict, argument: str, value: str
+    ) -> requests.Response:
+        """Request url with data if not successful retry with different kinds of replaced special chars.
+
+        Args:
+            url (str): url to request
+            data (dict): data to send
+            params (dict): params to send
+            argument (str): name of the source argument being searched for (as in Source.__init__)
+            value (str): value of that source argument, used for the error message
+
+        Raises:
+            SourceArgumentNotFound: if all requests fail to find a match
+
+        Returns:
+            requests.Response: the successful response
+        """
+        r = requests.post(url, data=data, params=params)
+        if self._has_result(r.text):
+            return r
+        r = requests.post(
+            url,
+            data=replace_special_chars_args(data),
+            params=replace_special_chars_args(params),
+        )
+        if self._has_result(r.text):
+            return r
+        r = requests.post(
+            url,
+            data=replace_special_chars_args(
+                data, replace_special_chars_with_underscore
+            ),
+            params=replace_special_chars_args(params),
+        )
+        if self._has_result(r.text):
+            return r
+        raise SourceArgumentNotFound(argument, value)
+
+    def fetch(self):
+        args = {
+            "hidden_kalenderart": "privat",
+            "input_ort": self._ort,
+            "input_ortsteil": self._ortsteil,
+            "input_str": [self._strasse, self._strasse],
+            "input_hnr": [self._hausnummer, self._hausnummer],
+            "ort_id": "0",
+            "ortteil_id": "0",
+            "str_id": "0",
+            "hidden_id_ort": "0",
+            "hidden_id_ortsteil": "0",
+            "hidden_id_str": "0",
+            "hidden_id_hnr": "0",
+            "hidden_id_egebiet": "0",
+            "hidden_send_btn": "ics",
+            "hiddenYear": str(datetime.now().year),
+        }
+
+        r = requests.get(self._api_url)
+        if r.url != self._api_url:
+            self._api_url = r.url
+        self._search_url: str = self._api_url + "search/"
+        self._ics_url: str = self._api_url + "ics/ics.php"
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        for i in soup.find_all("input"):
+            if i.get("name").startswith("showBins"):
+                args[i.get("name")] = "on"
+
+        if self._ort:
+            args["input"] = self._ort
+            r = self.request_all(
+                self._search_url + "search_orte.php",
+                args,
+                {"input": self._ort, "ort_id": "0"},
+                "ort",
+                self._ort,
+            )
+
+            ids = self._get_elemts(r.text)
+            args["hidden_id_ort"] = args["ort_id"] = ids[0]
+            if len(ids) > 1:
+                args["hidden_id_egebiet"] = ids[1]
+
+        if self._ortsteil:
+            r = self.request_all(
+                self._search_url + "search_ortsteile.php",
+                args,
+                {"input": self._ortsteil, "ort_id": args["ort_id"]},
+                "ortsteil",
+                self._ortsteil,
+            )
+
+            ids = self._get_elemts(r.text)
+
+            args["ort_id"] = args["hidden_id_ortsteil"] = (
+                args["hidden_id_ort"] if ids[0] == "0" else ids[0]
+            )
+            if len(ids) > 1:
+                args["hidden_id_egebiet"] = ids[1]
+
+        if self._strasse:
+            r = self.request_all(
+                self._search_url + "search_strassen.php",
+                args,
+                {"input": self._strasse, "str_id": "0", "ort_id": args["ort_id"]},
+                "strasse",
+                self._strasse,
+            )
+            ids = self._get_elemts(r.text)
+            args["hidden_id_str"] = args["str_id"] = ids[0]
+            if len(ids) > 1:
+                args["hidden_id_egebiet"] = ids[1]
+
+        if self._hausnummer:
+            args["input"] = self._hausnummer
+            r = self.request_all(
+                self._search_url + "search_hnr.php",
+                args,
+                {"input": self._hausnummer, "hnr_id": "0", "str_id": args["str_id"]},
+                "hausnummer",
+                self._hausnummer,
+            )
+
+            ids = self._get_elemts(r.text)
+            args["hidden_id_hnr"] = args["hnr_id"] = ids[0]
+            if len(ids) > 1:
+                args["hidden_id_egebiet"] = ids[1]
+
+        r = requests.post(self._search_url + "check_zusatz.php", data=args)
+        id_string = BeautifulSoup(r.text, "html.parser").find("span")
+        args["hidden_id_zusatz"] = (
+            args["hidden_id_hnr"] if id_string is None else id_string.text.strip()
+        )
+
+        r = requests.post(self._ics_url, data=args)
+        r.raise_for_status()
+
+        if "Bitte geben Sie Ihre Daten korrekt an." in r.text:
+            raise ValueError("No Valid response, please check your configuration.")
+
+        r.encoding = "utf-8"
+        dates = self._ics.convert(r.text)
+        entries = []
+        for d in dates:
+            bin_type = d[1].replace("ü", "ü").replace("Entsorgung:", "").strip()
+            icon = ICON_MAP.get(
+                bin_type.lower().replace("verschobene abholung:", "").strip()
+            )
+            entries.append(Collection(d[0], bin_type, icon))
+
+        return entries

package/python/vendor/waste_collection_schedule/source/havering_gov_uk.py

@@ -0,0 +1,77 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+TITLE = "London Borough of Havering"
+DESCRIPTION = "Source for London Borough of Havering."
+URL = "https://www.havering.gov.uk/"
+TEST_CASES = {"53 Argyle Gardens": {"uprn": "100021403735"}}
+
+COLLECTION_MAP = {
+    "Service - Domestic Waste": {
+        "waste_type": "Domestic Waste",
+        "icon": "mdi:trash-can",
+    },
+    "Service - Garden Waste": {
+        "waste_type": "Garden Waste",
+        "icon": "mdi:leaf",
+    },
+    "Service - Recycling": {
+        "waste_type": "Recycling",
+        "icon": "mdi:recycle",
+    },
+    "Service - Garden Waste Winter": {
+        "waste_type": "Garden Waste Winter",
+        "icon": "mdi:leaf",
+    },
+}
+
+API_URL = "https://api-prd.havering.gov.uk/whitespace/GetCollectionByUprnAndDate"
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str = str(uprn).zfill(12)
+
+    def fetch(self):
+        payload = {
+            "getCollectionByUprnAndDate": {
+                "getCollectionByUprnAndDateInput": {
+                    "uprn": self._uprn,
+                    "nextCollectionFromDate": datetime.datetime.today().strftime(
+                        "%Y/%m/%d"
+                    ),
+                }
+            }
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Ocp-Apim-Trace": "true",
+            "Ocp-Apim-Subscription-Key": "545bcf53c9094dfd980dd9da72b0514d",
+        }
+        r = requests.post(API_URL, json=payload, headers=headers)
+        data = r.json()
+
+        entries = []
+
+        for next_collection in data["getCollectionByUprnAndDateResponse"][
+            "getCollectionByUprnAndDateResult"
+        ]["Collections"]:
+            collection_type = COLLECTION_MAP.get(
+                next_collection["service"],
+                {"waste_type": next_collection["service"], "icon": "mdi:trash-can"},
+            )
+            collection_date = next_collection["date"]
+            entries.append(
+                Collection(
+                    date=datetime.datetime.strptime(
+                        collection_date, "%d/%m/%Y %H:%M:%S"
+                    ).date(),
+                    t=collection_type["waste_type"],
+                    icon=collection_type["icon"],
+                )
+            )
+
+        return entries

package/python/vendor/waste_collection_schedule/source/hawkesbury_nsw_gov_au.py

@@ -0,0 +1,131 @@
+import datetime as dt
+import json
+import logging
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "The Hawkesbury City Council, Sydney"
+DESCRIPTION = "Source for Hawkesbury City Council, Sydney, Australia waste collection."
+URL = "https://www.hawkesbury.nsw.gov.au/"
+TEST_CASES = {
+    "south windsor, 539a George Street": {
+        "suburb": "south windsor",
+        "street": "George Street",
+        "houseNo": 539,
+        "postCode": 2756,
+    },
+    "Windsor, catherine street 7": {
+        "suburb": "Windsor",
+        "street": "catherine st",
+        "houseNo": 7,
+        "postCode": 2756,
+    },
+    "Kurrajong, Bells Line Of Road 1052 ": {
+        "suburb": "Kurrajong HILLS",
+        "street": "Bells Line Of Road",
+        "houseNo": 1052,
+        "postCode": 2758,
+    },
+}
+API_URL = "https://data.hawkesbury.nsw.gov.au/api"
+_LOGGER = logging.getLogger(__name__)
+ICON_MAP = {
+    "DOMESTIC": Icons.GENERAL_WASTE,
+    "RECYCLE": Icons.RECYCLING,
+    "ORGANIC": Icons.ORGANIC,
+}
+STREETNAMES = {
+    "Av": "Avenue",
+    "Cct": "Circuit",
+    "Cr": "Crescent",
+    "Ct": "Court",
+    "Dr": "Drive",
+    "Esp": "Esplanade",
+    "Gr": "Grove",
+    "Hts": "Heights",
+    "Hwy": "Highway",
+    "Pde": "Parade",
+    "Pl": "Place",
+    "Rd": "Road",
+    "St": "Street",
+    "Tce": "Terrace",
+}
+
+
+class Source:
+    def __init__(self, suburb, street, houseNo, postCode):
+        self._suburb = suburb.upper()
+        self._street = street
+        self._houseNo = str(houseNo)
+        self._url = API_URL
+        self._postCode = postCode
+
+    def get_data(self, bin_prefix: str, fields) -> list[Collection]:
+        entries: list[Collection] = []
+
+        frequency = int(fields.get(f"{bin_prefix}_schedule", 0))
+        if frequency == 0:
+            return entries
+
+        base_string = fields.get(
+            f"{bin_prefix}_week1", dt.datetime.min.strftime("%Y-%m-%d")
+        )
+        basedate = parse_date_field(base_string)
+
+        # Get number of days between basedate and a year from now
+        days = ((dt.datetime.now() + dt.timedelta(days=365)) - basedate).days
+
+        date_list = [basedate + dt.timedelta(days=x) for x in range(0, days, frequency)]
+        name = bin_prefix.replace("bin", "").title()
+        for dateStr in date_list:
+            entries.append(Collection(dateStr.date(), name, ICON_MAP.get(name.upper())))
+        return entries
+
+    def fetch(self):
+        # check address values are not abbreviated
+        address = self._street
+        for key in STREETNAMES:
+            regex = rf"\b{key.lower()}\b"
+            address = re.sub(
+                pattern=regex, repl=STREETNAMES[key], string=address.lower()
+            )
+
+        # get list of suburbs
+        r = requests.get(
+            f"{self._url}/records/1.0/search/",
+            params={
+                "sort": "gisaddress",
+                "refine.gisaddress": f"{self._houseNo} {address.title()} {self._suburb} NSW {self._postCode}",
+                "rows": 1,
+                "dataset": "bin-collection-days",
+                "timezone": "Australia/Sydney",
+                "lang": "en",
+            },
+        )
+        data = json.loads(r.text)
+
+        # Check if house record was found
+        if len(data["records"]) == 0:
+            raise SourceArgumentNotFound("houseNo", self._houseNo)
+
+        # get collection schedule
+        record = data["records"][-1]
+        garbagebin_entries = self.get_data("garbagebin", record["fields"])
+        recyclebin_entries = self.get_data("recyclebin", record["fields"])
+        organicbin_entries = self.get_data("organicbin", record["fields"])
+        entries = garbagebin_entries + recyclebin_entries + organicbin_entries
+
+        return entries
+
+
+def parse_date_field(date_string):
+    formats = ["%Y-%m-%d %H:%M:%S", "%Y-%m-%d"]
+    for fmt in formats:
+        try:
+            return dt.datetime.strptime(date_string, fmt)
+        except ValueError:
+            continue
+    raise ValueError(f"Unrecognized date format: {date_string}")

package/python/vendor/waste_collection_schedule/source/hcc_govt_nz.py

@@ -0,0 +1,50 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Hamilton City Council"
+DESCRIPTION = "Source script for Hamilton City Council"
+URL = "https://www.fightthelandfill.co.nz/"
+TEST_CASES = {
+    "1 Hamilton Parade": {"address": "1 Hamilton Parade"},
+    "221b fox Street": {"address": "221b fox Street"},
+}
+
+API_URL = "https://api2.hcc.govt.nz/FightTheLandFill/get_Collection_Dates"
+ICON_MAP = {
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+
+
+class Source:
+    def __init__(self, address):
+        self.address = address
+
+    def fetch(self):
+        r = requests.get(
+            API_URL,
+            params={"address_string": self.address},
+        )
+        json = r.json()
+
+        # Extract entries from RedBin/YellowBin fields
+        entries = [
+            Collection(
+                date=datetime.datetime.strptime(
+                    json[0]["RedBin"], "%Y-%m-%dT%H:%M:%S"
+                ).date(),
+                t="Rubbish",
+                icon=ICON_MAP.get("Rubbish"),
+            ),
+            Collection(
+                date=datetime.datetime.strptime(
+                    json[0]["YellowBin"], "%Y-%m-%dT%H:%M:%S"
+                ).date(),
+                t="Recycling",
+                icon=ICON_MAP.get("Recycling"),
+            ),
+        ]
+
+        return entries