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

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

@@ -0,0 +1,234 @@
+# Modelled on awg_de.py — mirrors the Athos WasteManagementServlet multipart-form flow.
+# ZAW-SR uses SELECT dropdowns for Ort/Strasse/Hausnummer and requires an extra
+# STREETCHANGED step between CITYCHANGED and forward, so the standard parse_response_input
+# helper is extended to also capture SELECT field values.
+#
+# The Hausnummer SELECT has no separate field for the house number suffix: houses
+# with a suffix are listed as a single combined option, e.g. VALUE="4 A" (a
+# non-breaking space separates the number and the suffix). There is no
+# "Hausnummerzusatz" form field on the live site, so it must be folded into the
+# Hausnummer value instead of being sent as its own field.
+
+import html
+import logging
+import random
+import re
+import string
+
+import requests
+import urllib3
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.ICS import ICS
+
+# With verify=True the POST fails due to a SSLCertVerificationError.
+# Using verify=False works, but is not ideal.
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "ZAW-SR Straubing"
+DESCRIPTION = (
+    "Source for ZAW-SR (Zweckverband Abfallwirtschaft Straubing Stadt und Land)."
+)
+URL = "https://www.zaw-sr.de"
+COUNTRY = "de"
+
+TEST_CASES = {
+    "Straubing Theresienplatz 1": {
+        "city": "Straubing",
+        "street": "Theresienplatz",
+        "hnr": "1",
+    },
+    "Straubing Stadtgraben 1": {
+        "city": "Straubing",
+        "street": "Stadtgraben",
+        "hnr": "1",
+    },
+    "Schwarzach Harpfen 4 A": {
+        "city": "Schwarzach",
+        "street": "Harpfen",
+        "hnr": "4",
+        "addition": "A",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "city": "City",
+        "street": "Street",
+        "hnr": "House number",
+        "addition": "House number suffix",
+    },
+    "de": {
+        "city": "Ort",
+        "street": "Strasse",
+        "hnr": "Hausnummer",
+        "addition": "Hausnummerzusatz",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "city": "Name of your city or town exactly as shown in the dropdown at https://www.zaw-sr.de/abfuhrkalender (e.g. 'Straubing').",
+        "street": "Your street name exactly as shown in the dropdown (e.g. 'Theresienplatz').",
+        "hnr": "Your house number.",
+        "addition": "Optional house number suffix (e.g. 'A').",
+    },
+    "de": {
+        "city": "Name Ihrer Stadt oder Gemeinde genau wie in der Auswahl auf https://www.zaw-sr.de/abfuhrkalender (z.B. 'Straubing').",
+        "street": "Ihr Straßenname genau wie in der Auswahl (z.B. 'Theresienplatz').",
+        "hnr": "Ihre Hausnummer.",
+        "addition": "Optionaler Hausnummernzusatz (z.B. 'A').",
+    },
+}
+
+ICON_MAP = {
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Bioabfall": Icons.BIO_KITCHEN,
+    "Papiertonne": Icons.PAPER,
+    "Papier": Icons.PAPER,
+    "Restmülltonne": Icons.GENERAL_WASTE,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Restmuelltonne": Icons.GENERAL_WASTE,
+    "Gelber Sack": Icons.RECYCLING,
+    "Gelbe Tonne": Icons.RECYCLING,
+    "Wertstofftonne": Icons.RECYCLING,
+}
+
+API_URL = "https://straubing.zaw-sr.de/WasteManagementStraubing/WasteManagementServlet"
+
+
+class Source:
+    def __init__(self, city: str, street: str, hnr: str, addition: str = ""):
+        self._city = city
+        self._street = street
+        self._house_number = str(hnr)
+        self._address_suffix = addition.strip()
+        self._boundary = "WebKitFormBoundary" + "".join(
+            random.sample(string.ascii_letters + string.digits, 16)
+        )
+        self._ics = ICS()
+
+    def __str__(self):
+        return (
+            f"{self._city} {self._street} {self._house_number} {self._address_suffix}"
+        )
+
+    @staticmethod
+    def _parse_data(data, boundary):
+        result = ""
+        for key, value in data.items():
+            result += f'------{boundary}\r\nContent-Disposition: form-data; name="{key}"\r\n\r\n{value}\r\n'
+        result += f"------{boundary}--\r\n"
+        return result.encode()
+
+    @staticmethod
+    def _parse_response_fields(text):
+        """Parse all INPUT and SELECT fields from the response HTML."""
+        parsed = re.findall(
+            '<INPUT\\sNAME="([^"]+?)"\\sID="[^"]+?"(?:\\sVALUE="([^"]*?)")?', text
+        )
+        result = dict(parsed)
+        for sel_block in re.finditer(
+            r'<SELECT\sNAME="([^"]+?)".*?</SELECT>', text, re.DOTALL
+        ):
+            name = re.search(r'NAME="([^"]+?)"', sel_block.group(0)).group(1)
+            selected = re.search(
+                r'<OPTION VALUE="([^"]+?)"[^>]*SELECTED', sel_block.group(0)
+            )
+            result[name] = selected.group(1) if selected else ""
+        return result
+
+    def _address(self):
+        # The Hausnummer SELECT combines the number and its suffix into a
+        # single option value, e.g. "4\xa0A" (non-breaking space separator).
+        house_number = self._house_number
+        if self._address_suffix:
+            house_number = f"{self._house_number}\xa0{self._address_suffix}"
+        return {
+            "Ort": self._city,
+            "Strasse": self._street,
+            "Hausnummer": house_number,
+        }
+
+    def _headers(self):
+        return {"Content-Type": f"multipart/form-data; boundary=----{self._boundary}"}
+
+    def _payload(self, last_request, action="", period="", **kwargs):
+        payload = self._parse_response_fields(last_request)
+        payload.update({"SubmitAction": action, **kwargs})
+        if period:
+            payload.update({"Zeitraum": html.unescape(period)})
+        return self._parse_data(payload, self._boundary)
+
+    def _get_dates(self, session, init_request, calendar=""):
+        # Step 1: CITYCHANGED — select the city and get the street list
+        payload = self._payload(
+            init_request,
+            action="CITYCHANGED",
+            period=calendar,
+            Ort=self._city,
+            Strasse="",
+            Hausnummer="",
+        )
+        city_response = session.post(
+            API_URL, headers=self._headers(), data=payload, verify=False
+        )
+
+        # Step 2: STREETCHANGED — select the street and get the house-number list
+        payload = self._payload(
+            city_response.text,
+            action="STREETCHANGED",
+            period=calendar,
+            Ort=self._city,
+            Strasse=self._street,
+            Hausnummer="",
+        )
+        street_response = session.post(
+            API_URL, headers=self._headers(), data=payload, verify=False
+        )
+
+        # Step 3: forward — submit the full address
+        payload = self._payload(
+            street_response.text,
+            action="forward",
+            period=calendar,
+            **self._address(),
+        )
+        final_response = session.post(
+            API_URL, headers=self._headers(), data=payload, verify=False
+        )
+
+        # Step 4: download ICS
+        payload = self._payload(
+            final_response.text,
+            action="filedownload_ICAL",
+            period=calendar,
+            **self._address(),
+        )
+        ics_response = session.post(
+            API_URL, headers=self._headers(), data=payload, verify=False
+        )
+        return self._ics.convert(ics_response.text)
+
+    def fetch(self) -> list[Collection]:
+        session = requests.session()
+
+        init_request = session.get(
+            f"{API_URL}?SubmitAction=wasteDisposalServices&InFrameMode=true",
+            verify=False,
+        ).text
+        if calendars := re.findall('NAME="Zeitraum" VALUE="([^"]+?)"', init_request):
+            dates = [
+                date
+                for calendar in calendars
+                for date in self._get_dates(session, init_request, calendar)
+            ]
+        else:
+            dates = self._get_dates(session, init_request)
+        entries = []
+        for date, bin_type in dates:
+            entries.append(
+                Collection(date, bin_type.strip(), ICON_MAP.get(bin_type.strip()))
+            )
+        return entries

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

@@ -0,0 +1,132 @@
+from datetime import datetime
+from html.parser import HTMLParser
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+# Source code based on ZKE Saarbrücken
+TITLE = "ZKE Saarbrücken"
+DESCRIPTION = "Source for Zentraler Kommunaler Entsorgungsbetrieb (ZKE) Saarbrücken."
+URL = "https://www.zke-sb.de"
+TEST_CASES = {
+    "Harthweg": {
+        "street": "Harthweg",
+        "house_number": 7,
+    },
+    "Jahnweg": {
+        "street": "Jahnweg",
+        "house_number": 6,
+    },
+    "Netzbachtal": {
+        "street": "Netzbachtal",
+        "house_number": 1,
+    },
+}
+
+ICON_MAP = {
+    "Restmuell:": Icons.GENERAL_WASTE,
+    "Biomuell": Icons.ORGANIC,
+    "Papiertonne": Icons.PAPER,
+    "Gelbe": Icons.RECYCLING,
+}
+
+API_URL = "https://info.zke-sb.de/WasteManagementSaarbruecken/WasteManagementServlet"
+
+
+class HiddenInputParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self._args = {}
+
+    @property
+    def args(self):
+        return self._args
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "input":
+            d = dict(attrs)
+            if str(d.get("type", "")).lower() == "hidden" and "name" in d:
+                self._args[d["name"]] = d["value"] if "value" in d else ""
+
+
+class Source:
+    def __init__(self, street: str, house_number: str):
+        self._street = street
+        self._hnr = house_number
+        self._ics = ICS()
+
+    def fetch(self):
+        now = datetime.now()
+        entries = self.get_data(now.year)
+        if now.month == 12:
+            try:
+                entries += self.get_data(now.year + 1)
+            except Exception:
+                pass
+        return entries
+
+    def get_data(self, year):
+        session = requests.session()
+
+        # 1) GET: "Abfallkalender"
+        r = session.get(
+            API_URL,
+            params={"SubmitAction": "wasteDisposalServices", "InFrameMode": "TRUE"},
+        )
+        r.raise_for_status()
+        r.encoding = "utf-8"
+        parser = HiddenInputParser()
+        parser.feed(r.text)
+        args = parser.args
+
+        # 2) CITYCHANGED
+        args["Ort"] = self._street[0].upper()
+        args["SubmitAction"] = "CITYCHANGED"
+        r = session.post(API_URL, data=args)
+        r.raise_for_status()
+
+        parser = HiddenInputParser()
+        parser.feed(r.text)
+        args = parser.args
+
+        # 3) STREETCHANGED
+        args["Strasse"] = self._street
+        args["SubmitAction"] = "STREETCHANGED"
+        r = session.post(API_URL, data=args)
+        r.raise_for_status()
+
+        parser = HiddenInputParser()
+        parser.feed(r.text)
+        args = parser.args
+
+        # 4) forward
+        args["Hausnummer"] = str(self._hnr)
+        args["SubmitAction"] = "forward"
+        args["ContainerGewaehlt_1"] = "on"
+        args["ContainerGewaehlt_2"] = "on"
+        args["ContainerGewaehlt_3"] = "on"
+        args["ContainerGewaehlt_4"] = "on"
+        args["ContainerGewaehlt_5"] = "on"
+        args["ContainerGewaehlt_6"] = "on"
+        r = session.post(API_URL, data=args)
+        r.raise_for_status()
+
+        parser = HiddenInputParser()
+        parser.feed(r.text)
+        args = parser.args
+
+        # 5) ICS-Download
+        args["SubmitAction"] = "filedownload_ICAL"
+        r = session.post(API_URL, data=args)
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for d in dates:
+            bin_type = d[1].strip()
+            entries.append(
+                Collection(d[0], bin_type, ICON_MAP.get(bin_type.split(" ")[0]))
+            )
+        return entries

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

@@ -0,0 +1,184 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Zweckverband Abfallwirtschaft Schwalm-Eder-Kreis"
+DESCRIPTION = "Source for ZVA (Zweckverband Abfallwirtschaft Schwalm-Eder-Kreis)."
+URL = "https://www.zva-sek.de"
+TEST_CASES = {
+    "Fritzlar": {
+        "bezirk": "Fritzlar",
+        "ortsteil": "Fritzlar-kernstadt",
+        "strasse": "Ahornweg",
+    },
+    "Ottrau": {
+        "bezirk": "Ottrau",
+        "ortsteil": "immichenhain",
+        "strasse": "",
+    },
+    "Knüllwald": {
+        "bezirk": "Knüllwald",
+        "ortsteil": "Hergetsfeld",
+    },
+    "Felsberg": {
+        "bezirk": "Felsberg",
+        "ortsteil": "Felsberg",
+    },
+    "Guxhagen": {
+        "bezirk": "Guxhagen",
+        "ortsteil": "Guxhagen",
+    },
+}
+SERVLET = "https://www.zva-sek.de/module/abfallkalender/generate_ical.php"
+MAIN_URL = "https://www.zva-sek.de/online-dienste/abfallkalender-{year}/{file}"
+API_URL = "https://www.zva-sek.de/module/abfallkalender/{file}"
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "bezirk": "Abfuhrbezirk",
+        "strasse": "Straße",
+        "ortsteil": "Ortsteil",
+    },
+    "en": {
+        "bezirk": "City district",
+        "strasse": "Street",
+        "ortsteil": "District",
+    },
+}
+
+
+class Source:
+    def __init__(self, bezirk: str, ortsteil: str, strasse: str | None = None):
+        self._bezirk = bezirk
+        self._ortsteil = ortsteil
+        self._street = strasse if strasse != "" else None
+        self._ics = ICS()
+
+    def fetch(self):
+        session = requests.session()
+        year = datetime.now().year
+
+        bezirk_id = None
+        ortsteil_id = None
+
+        # get bezirke id
+        r = session.get(MAIN_URL.format(year=year, file=f"abfallkalender-{year}.html"))
+        if r.status_code == 404:  # try last year URL if this year is not available
+            r = session.get(
+                MAIN_URL.format(year=year, file=f"abfallkalender-{year - 1}.html")
+            )
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        for option in soup.find("select", {"name": "ak_bezirk"}).find_all("option"):
+            if option.text.lower() == self._bezirk.lower():
+                # removing solves problem with subsequen calls
+                # self._bezirk = option.get("value")
+                bezirk_id = option.get("value")
+                break
+
+        if not bezirk_id:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "bezirk",
+                self._bezirk,
+                [
+                    option.text
+                    for option in soup.find("select", {"name": "ak_bezirk"}).find_all(
+                        "option"
+                    )
+                ],
+            )
+        # get ortsteil id
+        r = session.get(
+            API_URL.format(file="get_ortsteile.php"), params={"bez_id": bezirk_id}
+        )
+        r.raise_for_status()
+        last_orts_id = None
+        for part in r.text.split(";")[2:-1]:
+            # part is "f.ak_ortsteil.options[5].text = 'Alte Kasseler Straße'" or "ak_ortsteil.options[6].value = '2'"
+            if "length" in part:
+                continue
+            if part.split(" = ")[1][1:-1].lower() == self._ortsteil.lower():
+                ortsteil_id = last_orts_id
+                break
+            last_orts_id = part.split(" = ")[1][1:-1]
+
+        if not ortsteil_id:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "ortsteil",
+                self._ortsteil,
+                [part.split(" = ")[1][1:-1] for part in r.text.split(";")[2:-1]],
+            )
+
+        street_id = None
+
+        # get street id if steet given
+        if self._street is not None:
+            r = session.get(
+                API_URL.format(file="get_strassen.php"),
+                params={"ot_id": ortsteil_id.split("-")[0]},
+            )
+            r.raise_for_status()
+            last_street_id = None
+            for part in r.text.split(";")[2:-1]:
+                # part is "f.ak_strasse.options[5].text = 'Alte Kasseler Straße'" or "ak_strasse.options[6].value = '2'"
+                if "length" in part:
+                    continue
+                if part.split(" = ")[1][1:-1].lower() == self._street.lower():
+                    street_id = last_street_id
+                    break
+                last_street_id = part.split(" = ")[1][1:-1]
+
+            if not street_id:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "street",
+                    self._street,
+                    [part.split(" = ")[1][1:-1] for part in r.text.split(";")[2:-1]],
+                )
+
+        entries = self.get_calendar_data(
+            year, bezirk_id, ortsteil_id, street_id, session
+        )
+        if datetime.now().month >= 11:
+            try:
+                entries += self.get_calendar_data(
+                    year + 1, bezirk_id, ortsteil_id, street_id, session
+                )
+            except Exception:
+                pass
+        return entries
+
+    def get_calendar_data(self, year, bezirk_id, ortsteil_id, street_id, session):
+        args = {
+            "year": str(year),
+            "ak_bezirk": bezirk_id,
+            "ak_ortsteil": ortsteil_id,
+            "alle_arten": "",
+            "iCalEnde": 6,
+            "iCalBeginn": 17,
+        }
+        if self._street is not None:
+            args["ak_strasse"] = street_id
+
+        r = session.post(
+            SERVLET,
+            data=args,
+        )
+
+        r.raise_for_status()
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for d in dates:
+            entries.append(
+                Collection(d[0], re.sub("[ ]*am [0-9]+.[0-9]+.[0-9]+[ ]*", "", d[1]))
+            )
+        return entries

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

@@ -0,0 +1,85 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfallwirtschaft Werra-Meißner-Kreis"
+DESCRIPTION = "Source for Zweckverband Abfallwirtschaft Werra-Meißner-Kreis"
+URL = "https://www.zva-wmk.de/"
+TEST_CASES = {
+    "Frankenhain": {"city": "Berkatal - Frankenhain", "street": "Teichhof"},
+    "Hebenshausen": {"city": "Neu-Eichenberg - Hebenshausen", "street": "Bachstraße"},
+    "Vockerode": {"city": "Meißner - Vockerode", "street": "Feuerwehr"},
+    "Bad Sooden-Allendorf": {
+        "city": "Bad Sooden-Allendorf - Allendorf",
+        "street": "Kannhöhe",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "street": "Straße",
+        "city": "Ort",
+    }
+}
+
+
+class Source:
+    def __init__(self, city, street):
+        city = city.replace("Hessisch Lichtenau", "HESSISCH+LICHTENAU")
+        city = city.replace("Bad Sooden", "BAD+SOODEN")
+        city = city.replace("ß", "%C3%9F").upper()
+        city = city.replace("Ä", "%C3%84")
+        city = city.replace("Ü", "%C3%9C")
+        city = city.replace("Ö", "%C3%96")
+        city = city.replace(" - ", "_")
+        street = street.replace("ß", "%C3%9F").upper()
+        street = street.replace("Ä", "%C3%84")
+        street = street.replace("Ü", "%C3%9C")
+        street = street.replace("Ö", "%C3%96")
+        self._city = city
+        self._street = street
+        self._ics = ICS(split_at=" / ")
+
+    def fetch(self):
+        today = datetime.date.today()
+
+        entries = self._fetch_year(today.year)
+        if today.month == 12:
+            entries.extend(self._fetch_year(today.year + 1))
+        return entries
+
+    def _fetch_year(self, year):
+        match year:
+            case 2021:
+                yearstr = "schnellsuche-2021"
+            case 2023:
+                yearstr = "schnellsuche-2023"
+            case 2024:
+                yearstr = ""
+            case 2025:
+                yearstr = "schnellsuche-2020"
+            case 2026:
+                yearstr = "persönlicher-terminkalender-2026"
+            case _:
+                yearstr = "persönlicher-terminkalender-2026"
+        try:
+            return self._fetch_yearstr(yearstr, self._street)
+        except Exception:
+            return self._fetch_yearstr("", self._street.upper())
+
+    def _fetch_yearstr(self, yearstr, street):
+        params = {"city": self._city, "street": street, "type": "all", "link": "ical"}
+
+        r = requests.get(f"https://www.zva-wmk.de/termine/{yearstr}", params=params)
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+        if not dates:
+            raise ValueError("No entries found")
+
+        entries = []
+        for d in dates:
+            entries.append(Collection(d[0], d[1]))
+        return entries