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

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

@@ -0,0 +1,181 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from dateutil.relativedelta import relativedelta
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "FL Abfalltransport AG"
+DESCRIPTION = "Source for FL Abfalltransport AG, Liechtenstein."
+URL = "https://www.ezv.li/abfallentsorgung/abfallkalender"
+BASE_URL = "https://www.ezv.li/abfallentsorgung/abfallkalender"
+COUNTRY = "li"
+
+MUNICIPALITIES = [
+    "balzers",
+    "triesen",
+    "triesenberg",
+    "vaduz",
+    "schaan",
+    "planken",
+    "gamprin-bendern",
+    "ruggell",
+    "mauren-schaanwald",
+    "eschen-nendeln",
+    "schellenberg",
+]
+
+WASTE_TYPES = {
+    "kehricht": "Kehricht",
+    "gruenabfuhr": "Grünabfuhr",
+}
+
+# Month number → URL slug (as expected by the website)
+MONTHS_URL = {
+    1: "januar",
+    2: "februar",
+    3: "maerz",
+    4: "april",
+    5: "mai",
+    6: "juni",
+    7: "juli",
+    8: "august",
+    9: "september",
+    10: "oktober",
+    11: "november",
+    12: "dezember",
+}
+
+ICON_MAP = {
+    "Kehricht": Icons.GENERAL_WASTE,
+    "Grünabfuhr": Icons.GARDEN,
+}
+
+TEST_CASES = {
+    "Balzers Kehricht": {"municipality": "balzers", "waste_type": "kehricht"},
+    "Vaduz Grünabfuhr": {"municipality": "vaduz", "waste_type": "gruenabfuhr"},
+    "Schaan Kehricht": {"municipality": "schaan", "waste_type": "kehricht"},
+    "Balzers Both": {"municipality": "balzers", "waste_type": "all"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Select your municipality from the list and choose a waste type ('kehricht', 'gruenabfuhr', or 'all'). Visit https://www.ezv.li/abfallentsorgung/abfallkalender to see the schedule.",
+    "de": "Wählen Sie Ihre Gemeinde aus der Liste und den Abfalltyp ('kehricht', 'gruenabfuhr' oder 'all'). Besuchen Sie https://www.ezv.li/abfallentsorgung/abfallkalender für den Kalender.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "municipality": "Municipality name in lower case (e.g. 'balzers', 'vaduz', 'schaan')",
+        "waste_type": "Waste type: 'kehricht', 'gruenabfuhr', 'all' (or comma-separated list)",
+    },
+    "de": {
+        "municipality": "Gemeindename in Kleinbuchstaben (z.B. 'balzers', 'vaduz', 'schaan')",
+        "waste_type": "Abfalltyp: 'kehricht', 'gruenabfuhr', 'all' (oder komma-separierte Liste)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "municipality": "Municipality",
+        "waste_type": "Waste type",
+    },
+    "de": {
+        "municipality": "Gemeinde",
+        "waste_type": "Abfalltyp",
+    },
+}
+
+
+def EXTRA_INFO():
+    return [
+        {
+            "title": m.replace("-", " ").title(),
+            "default_params": {"municipality": m},
+        }
+        for m in MUNICIPALITIES
+    ]
+
+
+class Source:
+    def __init__(self, municipality: str, waste_type: str = "kehricht"):
+        self._municipality = municipality.lower().strip()
+
+        if self._municipality not in MUNICIPALITIES:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", self._municipality, MUNICIPALITIES
+            )
+
+        self._waste_types = self._parse_waste_types(waste_type)
+        self._labels = {WASTE_TYPES[t] for t in self._waste_types}
+
+    def _parse_waste_types(self, waste_type: str) -> list[str]:
+        requested_types = []
+        valid_types = list(WASTE_TYPES.keys())
+        accepted_types = [*valid_types, "all", "both"]
+        for token in waste_type.lower().replace(";", ",").split(","):
+            selected_type = token.strip()
+            if not selected_type:
+                continue
+            if selected_type in ("all", "both"):
+                requested_types.extend(valid_types)
+                continue
+            if selected_type in valid_types:
+                requested_types.append(selected_type)
+                continue
+            raise SourceArgumentNotFoundWithSuggestions(
+                "waste_type", selected_type, accepted_types
+            )
+
+        if not requested_types:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "waste_type", waste_type, accepted_types
+            )
+
+        deduplicated = []
+        for selected_type in requested_types:
+            if selected_type not in deduplicated:
+                deduplicated.append(selected_type)
+        return deduplicated
+
+    def fetch(self) -> list[Collection]:
+        entries = []
+        today = datetime.date.today()
+
+        for delta_month in range(3):
+            target = today.replace(day=1) + relativedelta(months=delta_month)
+            month_slug = MONTHS_URL[target.month]
+
+            url = f"{BASE_URL}/{self._municipality}/{month_slug}"
+            resp = requests.get(url, timeout=30)
+            if resp.status_code != 200:
+                continue
+
+            soup = BeautifulSoup(resp.text, "html.parser")
+
+            # The day headers carry no year; take it from the selected month option
+            year = target.year
+            selected = soup.select_one("#pica-filter-month option[selected]")
+            if selected is not None:
+                match = re.search(r"\b(\d{4})\b", selected.get("data-caption", ""))
+                if match:
+                    year = int(match.group(1))
+            month = target.month
+
+            for day in soup.select(".pica-day"):
+                day_tag = day.select_one(".pica-date-header-day")
+                if day_tag is None:
+                    continue
+                try:
+                    dt = datetime.date(year, month, int(day_tag.get_text(strip=True)))
+                except ValueError:
+                    continue
+
+                for name_tag in day.select(".pica-category-name"):
+                    label = name_tag.get_text(strip=True)
+                    if label not in self._labels:
+                        continue
+                    entries.append(Collection(dt, label, icon=ICON_MAP.get(label)))
+
+        return entries

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

@@ -0,0 +1,51 @@
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfallwirtschaft Stadt Fürth"
+DESCRIPTION = "Source for Stadt Fürth"
+URL = "https://abfallwirtschaft.fuerth.eu/"
+COUNTRY = "de"
+TEST_CASES = {
+    "Mühltalstrasse 4": {"id": 96983001},
+    "Carlo-Schmid-Strasse 27": {"id": 96975001},
+}
+
+API_URL = "https://abfallwirtschaft.fuerth.eu/termine.php"
+
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Altpapier": Icons.PAPER,
+}
+
+
+class Source:
+    def __init__(self, id):
+        self._id = id
+        self._ics = ICS(split_at="/")
+
+    def fetch(self):
+        # fetch the ical
+        r = requests.get(f"{API_URL}?icalexport={self._id}")
+        r.raise_for_status()
+
+        # replace non-ascii character in UID, otherwise ICS converter will fail
+        ics = ""
+        for line in r.text.splitlines():
+            if line.startswith("UID"):
+                line = line.replace("ä", "ae")
+                line = line.replace("ö", "oe")
+                line = line.replace("ü", "ue")
+            ics += line
+            ics += "\n"
+
+        dates = self._ics.convert(ics)
+
+        entries = []
+
+        for d in dates:
+            entries.append(Collection(date=d[0], t=d[1], icon=ICON_MAP.get(d[1])))
+
+        return entries

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

@@ -0,0 +1,70 @@
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfallwirtschaft Germersheim"
+DESCRIPTION = "Source für Abfallkalender Kreis Germersheim"
+URL = "https://www.abfallwirtschaft-germersheim.de"
+TEST_CASES = {
+    "Bellheim": {"city": "Bellheim", "street": "Albert-Schweitzer-Str."},
+    "Hatzenbuehl": {"city": "Hatzenbühl"},
+    "hoerdt": {"city": "Hördt", "street": ""},
+}
+
+API_URL = "https://www.abfallwirtschaft-germersheim.de/online-service/abfall-termine/abfalltermine-ics-export-bis-240-liter.html"
+
+
+class Source:
+    def __init__(self, city, street=""):
+        self._street = street
+        self._city = city
+        self._ics = ICS()
+
+    def fetch(self):
+        s = requests.Session()
+        params = {
+            "icsortschaft": self._city,
+            "icsabfallart[]": [],
+        }
+
+        if self._street != "":
+            params["icsstrasse"] = self._street
+
+        r = s.get(API_URL, params=params)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        ics_download = soup.find(
+            "input", {"type": "hidden", "name": "ICS_DOWNLOAD"}
+        ).get("value")
+        request_token = soup.find(
+            "input", {"type": "hidden", "name": "REQUEST_TOKEN"}
+        ).get("value")
+
+        checkbox_class = re.compile("id_form_icsabfallart_[0-9][0-9]?")
+        waste_types = soup.find("div", {"class": "ctlg_form_field checkbox"}).find_all(
+            "label",
+            {
+                "for": checkbox_class,
+            },
+        )
+        for waste_type in waste_types:
+            params["icsabfallart[]"].append(waste_type.text)
+
+        r = s.post(
+            API_URL,
+            params=params,
+            data={"ICS_DOWNLOAD": ics_download, "REQUEST_TOKEN": request_token},
+        )
+        r.raise_for_status()
+
+        entries = []
+
+        dates = self._ics.convert(r.text)
+        for d in dates:
+            entries.append(Collection(d[0], d[1]))
+
+        return entries

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

@@ -0,0 +1,130 @@
+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 rh_entsorgung_de.md
+TITLE = "Abfallwirtschaft Pforzheim"
+DESCRIPTION = "Source for Abfallwirtschaft Pforzheim."
+URL = "https://www.abfallwirtschaft-pforzheim.de"
+TEST_CASES = {
+    "Abnobstraße": {
+        "street": "Abnobastraße",
+        "house_number": 3,
+        "address_suffix": "",
+    },
+    "Im Buchbusch": {
+        "street": "Im Buchbusch",
+        "house_number": 12,
+    },
+    "Eisenbahnstraße": {
+        "street": "Eisenbahnstraße",
+        "house_number": 29,
+        "address_suffix": "-33",
+    },
+}
+
+ICON_MAP = {
+    "Restmuell": Icons.GENERAL_WASTE,
+    "Biobehaelter": Icons.ORGANIC,
+    "Papierbehaelter": Icons.PAPER,
+    "Gelbe": Icons.RECYCLING,
+    "Grossmuellbehaelter": Icons.GENERAL_WASTE,
+}
+
+
+API_URL = "https://onlineservices.abfallwirtschaft-pforzheim.de/WasteManagementPforzheim/WasteManagementServlet"
+
+# Parser for HTML input (hidden) text
+
+
+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["type"]).lower() == "hidden":
+                self._args[d["name"]] = d["value"] if "value" in d else ""
+
+
+class Source:
+    def __init__(self, street: str, house_number: int, address_suffix: str = ""):
+        self._street = street
+        self._hnr = house_number
+        self._suffix = address_suffix
+        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()
+
+        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
+        args["Ort"] = self._street[0].upper()
+        args["Strasse"] = self._street
+        args["Hausnummer"] = str(self._hnr)
+        args["Hausnummerzusatz"] = self._suffix
+        args["SubmitAction"] = "CITYCHANGED"
+        args["Zeitraum"] = f"Jahresübersicht {year}"
+        r = session.post(
+            API_URL,
+            data=args,
+        )
+        r.raise_for_status()
+
+        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"
+        args["ContainerGewaehlt_7"] = "on"
+        r = session.post(
+            API_URL,
+            data=args,
+        )
+        r.raise_for_status()
+
+        args["ApplicationName"] = "com.athos.nl.mvc.abfterm.AbfuhrTerminModel"
+        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:
+            entries.append(Collection(d[0], d[1], ICON_MAP.get(d[1].split(" ")[0])))
+        return entries

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

@@ -0,0 +1,125 @@
+import json
+import re
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "AWB Abfallwirtschaft Vechta"
+DESCRIPTION = "Source for AWB Abfallwirtschaft Vechta."
+URL = "https://www.abfallwirtschaft-vechta.de/"
+TEST_CASES = {
+    "Vechta, An der Hasenweide": {"stadt": "Vechta", "strasse": "An der Hasenweide"},
+    "Bakum, Up'n Sande": {"stadt": "Bakum", "strasse": "Up'n Sande"},
+    "Neuenkirchen-Vörden, Braunschweiger Straße": {
+        "stadt": "Neuenkirchen-Vörden",
+        "strasse": "Braunschweiger Straße",
+    },
+    "Goldenstedt, An der Ellenbäke": {
+        "stadt": "Goldenstedt",
+        "strasse": "An der Ellenbäke",
+    },
+}
+
+
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Glass": Icons.GLASS,
+    "Bioabfall": Icons.BIO_KITCHEN,
+    "Altpapier": Icons.PAPER,
+    "Altpapier Siemer": Icons.PAPER,
+    "Altpapier Pamo": Icons.PAPER,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+}
+
+
+class Source:
+    def __init__(self, stadt: str, strasse: str):
+        self._stadt: str = stadt
+        self._strasse: str = strasse
+        self._ics = ICS()
+
+    def fetch(self):
+        now = datetime.now()
+        entries = self.get_data(now.year)
+        if now.month != 12:
+            return entries
+        try:
+            return entries + self.get_data(now.year + 1)
+        except Exception:
+            pass
+
+    def get_data(self, jahr):
+        args = {"stadt": self._stadt, "strasse": self._strasse}
+
+        collection_entries = []
+        string_entries = []
+
+        for papier_typ in ["pamo", "siemer"]:
+            session = requests.Session()
+            session.cookies.set("jahr", str(jahr))
+
+            r = session.get(
+                "https://www.abfallwirtschaft-vechta.de/CALENDER/inc.suche_stadt.php",
+                params={"term": self._stadt},
+            )
+            r.raise_for_status()
+            city_id = r.json()[0]["id"]
+            session.cookies.set("stadt", str(city_id))
+
+            r = session.get(
+                "https://www.abfallwirtschaft-vechta.de/CALENDER/inc.suche_strasse.php",
+                params={"stadt": city_id, "term": self._strasse},
+            )
+            r.raise_for_status()
+            street = json.loads(r.text[1:-2])["strassen"][0]
+            session.cookies.set("stadt", str(street["id"]))
+            session.cookies.set("abfuhrbezirk", str(street["abfuhrbezirk"]))
+            session.cookies.set("abfuhrbezirkpapir", str(street[papier_typ]))
+            session.cookies.set("papier", papier_typ)
+
+            args = {
+                "stadt": city_id,
+                "strasse": street["id"],
+                "abfuhrbezirkpapier": street[papier_typ],
+                "jahr": jahr,
+                "papier": papier_typ,
+                "trigger": "false",
+                "triggerday": "false",
+                "triggertime": "false",
+            }
+
+            r = session.get(
+                "https://www.abfallwirtschaft-vechta.de/CALENDER/inc.get_calender_ics.php",
+                params=args,
+            )
+            r.raise_for_status()
+            r.encoding = "utf-8"
+
+            # sometimes has a not ascii UID this would raise an Exception while converting
+            dates = self._ics.convert(r.text.replace("UID:", "NOTUID: "))
+
+            for d in dates:
+                bin_type = (
+                    d[1]
+                    .replace("Abfuhrtermin", "")
+                    .replace("Erinnerung", "")
+                    .replace("für", "")
+                    .strip()
+                )
+
+                if f"{bin_type} {d[0]!s}" in string_entries:
+                    continue
+                string_entries.append(f"{bin_type} {d[0]!s}")
+
+                collection_entries.append(
+                    Collection(
+                        d[0],
+                        bin_type,
+                        ICON_MAP.get(
+                            re.sub("[0-9]", "", bin_type).strip().replace("  ", " ")
+                        ),
+                    )
+                )
+        return collection_entries

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

@@ -0,0 +1,126 @@
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Landkreis Neumarkt"
+DESCRIPTION = "Source for Landkreis Neumarkt."
+URL = "https://www.abfuhrplan-landkreis-neumarkt.de"
+TEST_CASES = {
+    "dietfurt industriestrasse": {"city": "dietfurt", "street": "industriestrasse"},
+    "Parsberg, Bogenmühle": {"city": "parsberg", "street": "bogenmuehle"},
+}
+
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Papiertonne": Icons.PAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+}
+
+
+BASE_API_URL = "https://www.abfuhrplan-landkreis-neumarkt.de"
+DATA_ULR = BASE_API_URL + "/{city}/{street}"
+
+
+def _prepare_arg(arg: str) -> str:
+    return (
+        arg.lower()
+        .strip()
+        .replace(" ", "-")
+        .replace("(", "")
+        .replace(")", "")
+        .replace("ä", "ae")
+        .replace("ö", "oe")
+        .replace("ü", "ue")
+        .replace("ß", "ss")
+    )
+
+
+class Source:
+    def __init__(self, city: str, street: str):
+        self._city: str = _prepare_arg(city)
+        self._street: str = _prepare_arg(street)
+        self._ics = ICS()
+
+    @staticmethod
+    def _get_all_elements(url: str) -> list[str]:
+        r = requests.get(url)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        items = soup.select("li.list-group-item")
+        elements = []
+        for item in items:
+            a = item.select_one("a")
+            if not a:
+                continue
+            href = a.get("href")
+            if not isinstance(href, str):
+                continue
+            href_name = href.split("/")[-1]
+            if href_name == _prepare_arg(item.text.lower().strip()):
+                elements.append(item.text.strip())
+            else:
+                elements.append(href_name)
+        return elements
+
+    @staticmethod
+    def _get_all_cities() -> list[str]:
+        return Source._get_all_elements(BASE_API_URL)
+
+    @staticmethod
+    def _get_all_streets(city: str) -> list[str]:
+        print(f"{BASE_API_URL}/{city}")
+        try:
+            return Source._get_all_elements(f"{BASE_API_URL}/{city}")
+        except requests.exceptions.HTTPError as e:
+            print("failed to get streets")
+            print(e.response.status_code)
+            if e.response.status_code == 404:
+                cities = Source._get_all_elements(BASE_API_URL)
+                raise SourceArgumentNotFoundWithSuggestions("city", city, cities) from e
+            raise e
+
+    def fetch(self) -> list[Collection]:
+        url = DATA_ULR.format(city=self._city, street=self._street)
+
+        # get json file
+        r = requests.get(url)
+        if r.status_code == 404:
+            streets = Source._get_all_streets(self._city)
+            raise SourceArgumentNotFoundWithSuggestions("street", self._street, streets)
+
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        form = soup.select_one('form[action="/getical"]')
+        if not form:
+            raise Exception("Form not found")
+
+        data: dict[str, str | int] = {}
+        for input in form.select("input") + form.select("button"):
+            name = input.get("name")
+            value = input.get("value")
+            if not isinstance(name, str):
+                continue
+            if not isinstance(value, str):
+                continue
+            data[name] = value
+
+        for selects in form.select("select"):
+            name = selects.get("name")
+            if not isinstance(name, str):
+                continue
+            data[name] = 0
+
+        r = requests.post(f"{BASE_API_URL}/getical", data=data)
+        r.raise_for_status()
+
+        entries = []
+        for date, bin_type in self._ics.convert(r.text):
+            icon = ICON_MAP.get(bin_type)  # Collection icon
+            entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries