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

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

@@ -0,0 +1,176 @@
+import datetime
+import logging
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.AbfallIOGraphQL import SERVICE_MAP
+
+TITLE = "Abfall.IO / AbfallPlus (GraphQL)"
+DESCRIPTION = "Source for AbfallPlus.de waste collection using the v3 GraphQL API."
+URL = "https://www.abfallplus.de"
+COUNTRY = "de"
+
+_LOGGER = logging.getLogger(__name__)
+
+INIT_URL = "https://api.abfall.io"
+GQL_URL = "https://widgets.abfall.io/graphql"
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"
+}
+
+APPOINTMENTS_QUERY = """
+query Query($idHouseNumber: ID!, $wasteTypes: [ID], $dateMin: Date, $dateMax: Date, $showInactive: Boolean) {
+    appointments(idHouseNumber: $idHouseNumber, wasteTypes: $wasteTypes, dateMin: $dateMin, dateMax: $dateMax, showInactive: $showInactive) {
+        date
+        wasteType {
+            name
+        }
+    }
+}
+"""
+
+
+def EXTRA_INFO():
+    result = []
+    for s in SERVICE_MAP:
+        entry = {
+            "title": s["title"],
+            "url": s["url"],
+            "default_params": {"key": s["service_id"]},
+        }
+        if "country" in s:
+            entry["country"] = s["country"]
+        result.append(entry)
+    return result
+
+
+TEST_CASES = {
+    "Altlandsberg": {
+        "key": "efb75cbd1f08fae1d4e47ae72a85c655",
+        "idHouseNumber": 4136,
+    },
+    "Strausberg": {
+        "key": "efb75cbd1f08fae1d4e47ae72a85c655",
+        "idHouseNumber": 5985,
+    },
+    "Graz (Rudersdorfer Straße 60)": {
+        "key": "1c230a689579b6d3ddb9ceb5a56c6072",
+        "idHouseNumber": 31972,
+    },
+    "Landkreis Reutlingen, Wannweil, Bahnhofstraße 5": {
+        "key": "15f69fab91c4cae50d9dbb5bcfd383f0",
+        "idHouseNumber": 58444,
+    },
+    "Entsorgungsbetriebe Essen": {
+        "key": "51be67f3758f1fb57b420efe065c0663",
+        "idHouseNumber": 74629,
+    },
+    "KELL Kommunalentsorgung Landkreis Leipzig GmbH, Großpösna": {
+        "key": "0d7a92192ba3ae914c028ac37d73e222",
+        "idHouseNumber": 1257,
+    },
+    "Wirtschaftsbetriebe Duisburg (WBD), Buchholz, Altenbrucher Damm 8": {
+        "key": "80acad6c77fe9342ebafad29a8c58bf6",
+        "idHouseNumber": 72827,
+    },
+    "Landkreis Göttingen, Scheden": {
+        "key": "4b5702d771c82b611c386ebbc7629026",
+        "idHouseNumber": 641,
+    },
+    "Landkreis Böblingen, Böblingen, Dagersheim": {
+        "key": "76bdaac8568082d77e7a90cb41129f9b",
+        "idHouseNumber": 1057,
+    },
+    "ASG Nordsachsen, Delitzsch-Beerendorf": {
+        "key": "2085afd95285e645e15ee9623d0c5172",
+        "idHouseNumber": 360435,
+    },
+    "Schwarzwald-Baar-Kreis, Königsfeld": {
+        "key": "30628292bdd8b43db86a48f7e0d85f85",
+        "idHouseNumber": 16437,
+    },
+    "ASO Abfall-Service Osterholz, Osterholz-Scharmbeck, Ahrensfelder Damm 4": {
+        "key": "8b016df0116d1d5094fa339bebea0c65",
+        "idHouseNumber": 6644,
+    },
+}
+
+
+class Source:
+    def __init__(self, key, idHouseNumber, wasteTypes=None):
+        self._key = key
+        self._id_house_number = str(idHouseNumber)
+        if isinstance(wasteTypes, str):
+            self._waste_types = [
+                x.strip() for x in wasteTypes.split(",") if x.strip()
+            ] or None
+        elif wasteTypes:
+            self._waste_types = [str(w) for w in wasteTypes]
+        else:
+            self._waste_types = None
+        # Some providers (e.g. KELL GmbH) reject GraphQL requests that don't
+        # carry an Origin/Referer header matching their own website. Look up
+        # the provider's URL (if known) so we can send it proactively.
+        self._origin = next(
+            (s["url"].rstrip("/") for s in SERVICE_MAP if s["service_id"] == key),
+            None,
+        )
+
+    def fetch(self):
+        r = requests.get(INIT_URL, params={"key": self._key}, headers=HEADERS)
+        if r.status_code == 401:
+            raise ValueError(
+                f"API key '{self._key}' is not valid for the abfall.io v3 GraphQL API. "
+                "Please check that you are using the correct key for your provider."
+            )
+        r.raise_for_status()
+        config = r.json()
+        api_key = config["apiKey"]
+
+        waste_types = self._waste_types
+        if waste_types is None:
+            waste_types = [
+                wt["wasteType"]
+                for wt in config["settings"].get("PUB_ABFALLTYPEN", [])
+                if wt.get("checked", False)
+            ]
+
+        now = datetime.date.today()
+        date_max = now + datetime.timedelta(days=365)
+
+        gql_headers = {
+            **HEADERS,
+            "Content-Type": "application/json",
+            "x-abfallplus-api-key": api_key,
+        }
+        if self._origin:
+            gql_headers["Origin"] = self._origin
+            gql_headers["Referer"] = f"{self._origin}/"
+
+        r = requests.post(
+            GQL_URL,
+            json={
+                "query": APPOINTMENTS_QUERY,
+                "variables": {
+                    "idHouseNumber": self._id_house_number,
+                    "wasteTypes": waste_types if waste_types else None,
+                    "dateMin": now.isoformat(),
+                    "dateMax": date_max.isoformat(),
+                    "showInactive": False,
+                },
+            },
+            headers=gql_headers,
+        )
+        r.raise_for_status()
+
+        data = r.json()
+        if "errors" in data:
+            raise ValueError(f"GraphQL error: {data['errors']}")
+
+        entries = []
+        for apt in data.get("data", {}).get("appointments", []):
+            date = datetime.date.fromisoformat(apt["date"])
+            waste_type = apt["wasteType"]["name"]
+            entries.append(Collection(date, waste_type))
+
+        return entries

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

@@ -0,0 +1,166 @@
+import html
+import re
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Abfallwirtschaft Kyffhäuserkreis"
+DESCRIPTION = (
+    "Source for Abfallwirtschaft Kyffhäuserkreis, covering waste collection "
+    "schedules for towns and villages within the Kyffhäuserkreis district, "
+    "Thuringia, Germany."
+)
+URL = "https://abfall-kyffhaeuser.de"
+COUNTRY = "de"
+
+API_URL = "https://abfall-kyffhaeuser.de/wp-json/tribe/events/v1"
+
+TEST_CASES = {
+    "Ebeleben (single schedule)": {"city": "Ebeleben"},
+    "Bad Frankenhausen - Tour 1": {"city": "Bad Frankenhausen - Tour 1"},
+    "Sondershausen - Tour 3": {"city": "Sondershausen - Tour 3"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Visit https://abfall-kyffhaeuser.de/kalender/, open the 'Ort' filter "
+        "and use the exact place name shown there as the 'city' argument. Larger "
+        "towns (Bad Frankenhausen, Sondershausen, Artern) are split into several "
+        "collection tours ('Tour 1', 'Tour 2', ...) - check your bin / waste "
+        "collection notice or ask the Kyffhäuserkreis waste department which "
+        "tour serves your street. If you enter an unknown or ambiguous name, "
+        "the resulting error message will list the valid place names."
+    ),
+    "de": (
+        "Besuchen Sie https://abfall-kyffhaeuser.de/kalender/, öffnen Sie den "
+        "Filter 'Ort' und verwenden Sie den dort angezeigten Namen exakt als "
+        "'city'-Parameter. Größere Orte (Bad Frankenhausen, Sondershausen, "
+        "Artern) sind in mehrere Abfuhrtouren ('Tour 1', 'Tour 2', ...) "
+        "aufgeteilt - bitte prüfen Sie Ihren Abfuhrkalender/-bescheid oder "
+        "fragen Sie bei der Abfallwirtschaft Kyffhäuserkreis nach, welche Tour "
+        "für Ihre Straße zuständig ist. Bei unbekannten oder mehrdeutigen "
+        "Namen listet die Fehlermeldung alle gültigen Ortsnamen auf."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "city": (
+            "Place name as shown in the 'Ort' filter on "
+            "https://abfall-kyffhaeuser.de/kalender/, e.g. 'Ebeleben' or "
+            "'Bad Frankenhausen - Tour 1'."
+        ),
+    },
+    "de": {
+        "city": (
+            "Ortsname wie im Filter 'Ort' auf "
+            "https://abfall-kyffhaeuser.de/kalender/ angezeigt, z. B. "
+            "'Ebeleben' oder 'Bad Frankenhausen - Tour 1'."
+        ),
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "city": "Place / tour",
+    },
+    "de": {
+        "city": "Ort / Tour",
+    },
+}
+
+
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.ORGANIC,
+    "Papiertonne": Icons.PAPER,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Gelber RC": Icons.PLASTIC_PACKAGING,
+    "Weihnachtsbaum": Icons.CHRISTMAS_TREE,
+}
+
+
+def _normalize(value: str) -> str:
+    value = html.unescape(value).strip().lower()
+    value = value.translate(str.maketrans({"ä": "ae", "ö": "oe", "ü": "ue", "ß": "ss"}))
+    return re.sub(r"[^a-z0-9]", "", value)
+
+
+class Source:
+    def __init__(self, city: str):
+        self._city = city
+        self._session = requests.Session()
+
+    def _get_all_venues(self) -> list[dict]:
+        venues: list[dict] = []
+        page = 1
+        while True:
+            r = self._session.get(
+                f"{API_URL}/venues", params={"per_page": 100, "page": page}, timeout=30
+            )
+            r.raise_for_status()
+            data = r.json()
+            venues.extend(data.get("venues", []))
+            if page >= data.get("total_pages", 1):
+                break
+            page += 1
+        return venues
+
+    def _resolve_venue(self) -> int:
+        venues = self._get_all_venues()
+        target = _normalize(self._city)
+
+        # exact match first
+        for venue in venues:
+            if _normalize(venue["venue"]) == target:
+                return int(venue["id"])
+
+        # fall back to substring match, e.g. "Bad Frankenhausen" matching all
+        # of its "Tour" venues, so the user gets a helpful, narrowed-down list
+        matches = [
+            html.unescape(venue["venue"])
+            for venue in venues
+            if target in _normalize(venue["venue"])
+        ]
+        if not matches:
+            matches = [html.unescape(venue["venue"]) for venue in venues]
+        raise SourceArgumentNotFoundWithSuggestions("city", self._city, sorted(matches))
+
+    def _get_all_events(self, venue_id: int) -> list[dict]:
+        start_date = date.today()
+        end_date = start_date + timedelta(days=400)
+        events: list[dict] = []
+        page = 1
+        while True:
+            r = self._session.get(
+                f"{API_URL}/events",
+                params={
+                    "venue": venue_id,
+                    "start_date": start_date.isoformat(),
+                    "end_date": end_date.isoformat(),
+                    "per_page": 50,
+                    "page": page,
+                },
+                timeout=30,
+            )
+            r.raise_for_status()
+            data = r.json()
+            events.extend(data.get("events", []))
+            if page >= data.get("total_pages", 1):
+                break
+            page += 1
+        return events
+
+    def fetch(self) -> list[Collection]:
+        venue_id = self._resolve_venue()
+        events = self._get_all_events(venue_id)
+
+        entries = []
+        for event in events:
+            waste_type = str(event["title"])
+            event_date = date.fromisoformat(str(event["start_date"])[:10])
+            icon: Icons | None = ICON_MAP.get(waste_type)
+            entries.append(Collection(date=event_date, t=waste_type, icon=icon))
+        return entries

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

@@ -0,0 +1,229 @@
+from datetime import datetime
+from typing import Literal
+
+import requests
+from bs4 import BeautifulSoup, NavigableString, Tag
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Landkreis Rostock"
+DESCRIPTION = "Source for Landkreis Rostock."
+URL = "https://www.abfall-lro.de/"
+TEST_CASES = {
+    "Alt Kätwin": {
+        "municipality": "Alt Kätwin",
+        "black_rhythm": "2w",
+        "green_rhythm": "4w",
+    },
+    "Altenhagen (Lohmen)": {
+        "municipality": "Altenhagen (Lohmen)",
+        "black_rhythm": "2w",
+        "green_rhythm": "2w",
+    },
+    "Qualitz": {
+        "municipality": "Qualitz",
+        "black_rhythm": "",
+        "green_rhythm": "2w",
+        "green_seasonal": True,
+    },
+    "Güstrow Werlestraße": {
+        "municipality": "Güstrow",
+        "street": "Werlestraße",
+        "black_rhythm": "2w",
+        "green_rhythm": "2w",
+    },
+}
+
+
+ICON_MAP = {
+    "Schwarze": Icons.GENERAL_WASTE,
+    "Grüne": Icons.ORGANIC,
+    "Blaue": Icons.PAPER,
+    "Gelbe": Icons.RECYCLING,
+}
+
+
+API_URL = "https://www.abfall-lro.de/de/abfuhrtermine/"
+GUESTROW_URL = "https://www.abfall-lro.de/de/abfuhrtermine/guestrow.php"
+ICAL_URL = "https://www.abfall-lro.de/default-wGlobal/wGlobal/abfuhrtermine/ical.php"
+
+RHYTHMS = Literal["2w", "4w", ""]
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "municipality": "Gemeinde",
+        "street": "Straße",
+        "black_rhythm": "Schwarze Tonne Rythmus",
+        "green_rhythm": "Gelbe Tonne Rythmus",
+        "black_seasonal": "Schwarze Tonne Saisonal",
+        "green_seasonal": "Gelbe Tonne Saisonal",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "municipality": "Name of the municipality, should match the name shown https://www.abfall-lro.de/de/abfuhrtermine/ (including sub region in bracktes). Use 'Güstrow' for Güstrow city streets.",
+        "street": "Street name (only required for Güstrow)",
+        "black_rhythm": "Rhythm of the black bin collection",
+        "green_rhythm": "Rhythm of the green bin collection",
+        "black_seasonal": "Check if the black bins are only collected seasonally",
+        "green_seasonal": "Check if the green bins are only collected seasonally",
+    },
+    "de": {
+        "municipality": "Name der Gemeinde, sollte mit dem Namen auf https://www.abfall-lro.de/de/abfuhrtermine/ übereinstimmen (einschließlich Unterregion in Klammern). Für Güstrower Straßen 'Güstrow' verwenden.",
+        "street": "Straßenname (nur für Güstrow erforderlich)",
+        "black_rhythm": "Leerungsrythmus der schwarzen Tonne",
+        "green_rhythm": "Leerungsrythmus der grünen Tonne",
+        "black_seasonal": "Ankreuzen, wenn die schwarzen Tonnen nur saisonal geleert werden",
+        "green_seasonal": "Ankreuzen, wenn die Grünen Tonnen nur saisonal geleert werden",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self,
+        municipality: str,
+        black_rhythm: RHYTHMS,
+        green_rhythm: RHYTHMS,
+        street: str | None = None,
+        black_seasonal: bool = False,
+        green_seasonal: bool = False,
+    ) -> None:
+        self._municipality: str = municipality
+        self._street: str | None = street
+        self._ics = ICS(regex=r"Leerung (.*)")
+        self._letters: str | None = None
+        self._black_rhythm = black_rhythm
+        self._green_rhythm = green_rhythm
+        self._black_seasonal = black_seasonal
+        self._green_seasonal = green_seasonal
+
+    def _is_guestrow(self) -> bool:
+        return self._municipality.lower().replace("ü", "u") in (
+            "gustrow",
+            "güstrow",
+            "guestrow",
+        )
+
+    def _fetch_guestrow_letter(self) -> None:
+        if self._street is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street",
+                "",
+                [
+                    "(street is required for Güstrow — see https://www.abfall-lro.de/de/abfuhrtermine/guestrow.php)"
+                ],
+            )
+
+        r = requests.get(GUESTROW_URL)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        links = soup.find_all(
+            "a", href=lambda h: h and h.endswith(".pdf") and "abfuhrtermine" in h
+        )
+
+        street_link: str | None = None
+        streets = []
+        for link in links:
+            text = link.text.strip()
+            streets.append(text)
+            if self._street.lower().replace(" ", "") == text.lower().replace(" ", ""):
+                street_link = link.get("href")
+                break
+
+        if street_link is None:
+            raise SourceArgumentNotFoundWithSuggestions("street", self._street, streets)
+
+        self._letters = street_link.split("/")[-1].split(".")[0]
+
+    def fetch_letter(self) -> None:
+        if self._is_guestrow():
+            return self._fetch_guestrow_letter()
+
+        r = requests.get(API_URL)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        links = soup.find_all("a")
+        relevant_links: list[Tag] = []
+        for link in links:
+            if (
+                isinstance(link, Tag)
+                and isinstance(href := link.get("href"), str)
+                and href.startswith("/default")
+                and href.endswith(".pdf")
+            ):
+                relevant_links.append(link)
+
+        mun_link: str | None = None
+        municipalities = []
+        for link in relevant_links:
+            text = link.text.strip()
+            if isinstance(link.next_sibling, NavigableString):
+                text += " " + link.next_sibling.strip()
+
+            municipalities.append(text)
+            if self._municipality.lower().replace(" ", "").replace("(", "").replace(
+                ")", ""
+            ) == text.lower().replace(" ", "").replace("(", "").replace(")", ""):
+                mun_link = link.get("href")
+                break
+        if mun_link is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", self._municipality, [*municipalities, "Güstrow"]
+            )
+
+        self._letters = mun_link.split("/")[-1].split(".")[0]
+
+    def fetch(self) -> list[Collection]:
+        fresh_letter = False
+        if self._letters is None:
+            fresh_letter = True
+            self.fetch_letter()
+
+        try:
+            return self.get_collections_per_year()
+        except Exception:
+            if fresh_letter:
+                raise
+            return self.get_collections_per_year()
+
+    def get_collections_per_year(self) -> list[Collection]:
+        now = datetime.now()
+        year = now.year
+        collections = self.get_collections(year)
+        if now.month != 12:
+            return collections
+        try:
+            collections += self.get_collections(year + 1)
+        except Exception:
+            pass
+        return collections
+
+    def get_collections(self, year: int) -> list[Collection]:
+        args = {
+            "letters": self._letters,
+            "year": year,
+            "black": self._black_rhythm,
+            "green": self._green_rhythm,
+            "yellow": "y",
+            "blue": "y",
+        }
+        if self._black_seasonal:
+            args["bsaison"] = "y"
+        if self._green_seasonal:
+            args["gsaison"] = "y"
+
+        # get json file
+        r = requests.get(ICAL_URL, params=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/abfall_neunkirchen_siegerland_de.py

@@ -0,0 +1,63 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.SiteparkIES import SiteparkIES, match_icon
+
+TITLE = "Neunkirchen Siegerland"
+DESCRIPTION = "Source for 'Abfallkalender Neunkirchen Siegerland'."
+URL = "https://www.neunkirchen-siegerland.de"
+COUNTRY = "de"
+REFID = "3362.1"
+TEST_CASES = {
+    "Waldstraße": {"strasse": "Waldstr"},
+    "Altenseelbacher Weg (Neunkirchen)": {
+        "strasse": "Altenseelbacher Weg",
+        "ort": "Neunkirchen",
+    },
+}
+SOURCE_CODEOWNERS = ["@bbr111"]
+
+ICON_MAP = {
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Papier": Icons.PAPER,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Astschnitt": Icons.GARDEN,
+    "Schadstoff": Icons.HAZARDOUS,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "strasse": "Street",
+        "ort": "District",
+    },
+    "de": {
+        "strasse": "Straße",
+        "ort": "Ortsteil",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "strasse": "Partial or full street name as shown on the Neunkirchen Siegerland waste calendar (e.g. 'Waldstr' for 'Waldstraße').",
+        "ort": "Optional district (Ortsteil) to disambiguate a street that exists in several places, i.e. the part shown in parentheses (e.g. 'Neunkirchen').",
+    },
+    "de": {
+        "strasse": "Teil- oder vollständiger Straßenname wie im Abfallkalender Neunkirchen Siegerland (z.B. 'Waldstr' für 'Waldstraße').",
+        "ort": "Optionaler Ortsteil zur Eindeutigkeit, falls die Straße in mehreren Ortsteilen vorkommt, also der Teil in Klammern (z.B. 'Neunkirchen').",
+    },
+}
+
+
+class Source:
+    def __init__(self, strasse, ort=None):
+        self._strasse = strasse
+        self._ort = ort
+        self._sitepark = SiteparkIES(
+            URL, refid=REFID, download_params={"kat": "1", "alarm": "0"}
+        )
+
+    def fetch(self):
+        dates = self._sitepark.fetch(strasse=self._strasse, ort=self._ort)
+        return [
+            Collection(date, waste_type, match_icon(waste_type, ICON_MAP))
+            for date, waste_type in dates
+        ]