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

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

@@ -0,0 +1,375 @@
+import re
+from dataclasses import dataclass
+from datetime import date, datetime, timezone
+from typing import Literal, TypedDict
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Bürgerportal"
+URL = "https://www.c-trace.de"
+DESCRIPTION = "Source for waste collection in multiple service areas."
+
+
+def EXTRA_INFO():
+    return [
+        {
+            "title": s["title"],
+            "url": s["url"],
+            "default_params": {"operator": s["operator"]},
+        }
+        for s in SERVICE_MAP
+    ]
+
+
+TEST_CASES = {
+    "Cochem-Zell": {
+        "operator": "cochem_zell",
+        "district": "Bullay",
+        "subdistrict": "Bullay",
+        "street": "Layenweg",
+        "number": 3,
+    },
+    "Alb-Donau": {
+        "operator": "alb_donau",
+        "district": "Blaubeuren",
+        "street": "Alberstraße",
+        "number": 3,
+    },
+    "Biedenkopf": {
+        "operator": "biedenkopf",
+        "district": "Biedenkopf",
+        "subdistrict": "Breidenstein",
+        "street": "Auf dem Hammer",
+        "number": 1,
+    },
+}
+
+ICON_MAP = {
+    "mobil": Icons.GENERAL_WASTE,
+    "bio": Icons.ORGANIC,
+    "papier": Icons.PAPER,
+    "verpackung": Icons.RECYCLING,
+    "gelb": Icons.RECYCLING,
+    "lvp": Icons.PLASTIC_PACKAGING,
+    "rest": Icons.GENERAL_WASTE,
+    "gruen": Icons.GARDEN,
+    "grün": Icons.GARDEN,
+    "baum": Icons.GARDEN,
+    "schnitt": Icons.GARDEN,
+    "schad": Icons.HAZARDOUS,
+}
+API_HEADERS = {
+    "Accept": "application/json, text/plain;q=0.5",
+    "Cache-Control": "no-cache",
+}
+Operator = Literal["cochem_zell", "alb_donau", "biedenkopf", "bedburg", "klevestadt"]
+
+SERVICE_MAP = [
+    {
+        "title": "KV Cochem-Zell",
+        "url": "https://www.cochem-zell-online.de/",
+        "api_url": "https://buerger-portal-cochemzell.azurewebsites.net/api",
+        "operator": "cochem_zell",
+    },
+    {
+        "title": "Abfallwirtschaft Alb-Donau-Kreis",
+        "url": "https://www.aw-adk.de/",
+        "api_url": "https://buerger-portal-albdonaukreisabfallwirtschaft.azurewebsites.net/api",
+        "operator": "alb_donau",
+    },
+    {
+        "title": "MZV Biedenkopf",
+        "url": "https://mzv-biedenkopf.de/",
+        "api_url": "https://biedenkopfmzv.buergerportal.digital/api",
+        "operator": "biedenkopf",
+    },
+    {
+        "title": "Bürgerportal Bedburg",
+        "url": "https://www.bedburg.de/",
+        "api_url": "https://buerger-portal-bedburg.azurewebsites.net/api",
+        "operator": "bedburg",
+    },
+    {
+        "title": "Umweltbetriebe USK Kleve",
+        "url": "https://buerger-app-klevestadt.azurewebsites.net/calendar",
+        "api_url": "https://buerger-portal-klevestadt.azurewebsites.net/api",
+        "operator": "klevestadt",
+    },
+]
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "operator": "Betreiber",
+        "district": "Ort",
+        "street": "Straße",
+        "subdistrict": "Ortsteil",
+        "number": "Hausnummer",
+        "show_volume": "Große Container anzeigen",
+    }
+}
+
+
+# This datalcass is used for adding entries to a set and remove duplicate entries.
+# The default `Collection` extends the standard dict and thus is not hashable.
+@dataclass(frozen=True, eq=True)
+class CollectionEntry:
+    date: date
+    waste_type: str
+    icon: str | None
+
+    def export(self) -> Collection:
+        return Collection(self.date, self.waste_type, self.icon)
+
+
+def quote_none(value: str | None) -> str:
+    if value is None:
+        return "null"
+
+    return f"'{value}'"
+
+
+def get_api_map():
+    return {s["operator"]: s["api_url"] for s in SERVICE_MAP}
+
+
+class Source:
+    def __init__(
+        self,
+        operator: Operator,
+        district: str,
+        street: str,
+        subdistrict: str | None = None,
+        number: int | str | None = None,
+        show_volume: bool = False,
+    ):
+        self.api_url = get_api_map()[operator]
+        self.district = district
+        self.subdistrict = subdistrict
+        self.street = street
+        self.number = number
+        self.show_volume = show_volume
+        self.new_params = True
+
+    def _do_fetch_request(
+        self,
+        session: requests.Session,
+        district_id: int,
+        street_id: int,
+        year: int,
+        new_params=True,
+    ) -> requests.Response:
+        params: dict[str, str | int | tuple[str]] = {
+            "$expand": "Abfuhrplan,Abfuhrplan/GefaesstarifArt/Abfallart,Abfuhrplan/GefaesstarifArt/VolumenObj",
+            "$orderby": "Abfuhrplan/GefaesstarifArt/Abfallart/Name,Abfuhrplan/GefaesstarifArt/VolumenObj/VolumenWert",
+            "orteId": district_id,
+            "strassenId": street_id,
+            "jahr": year,
+        }
+        if not new_params:
+            params["$expand"] = (
+                "Abfuhrplan,Abfuhrplan/GefaesstarifArt/Abfallart,Abfuhrplan/GefaesstarifArt/Volumen"
+            )
+            params["$orderby"] = (
+                "Abfuhrplan/GefaesstarifArt/Abfallart/Name,Abfuhrplan/GefaesstarifArt/Volumen/VolumenWert"
+            )
+
+        if self.number:
+            params["hausNr"] = (f"'{self.number}'",)
+        return session.get(
+            f"{self.api_url}/AbfuhrtermineAbJahr",
+            params=params,
+        )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.session()
+        session.headers.update(API_HEADERS)
+
+        year = datetime.now().year
+        entries: set[CollectionEntry] = set()
+
+        district_id = self.fetch_district_id(session)
+        street_id = self.fetch_street_id(session, district_id)
+        # Eventually verify house number in the future
+
+        res = self._do_fetch_request(
+            session, district_id, street_id, year, self.new_params
+        )
+        if res.status_code == 500:
+            self.new_params = not self.new_params
+            res = self._do_fetch_request(
+                session, district_id, street_id, year, self.new_params
+            )
+
+        res.raise_for_status()
+        payload: CollectionsRes = res.json()
+
+        date_regex = re.compile(r"\d+")
+
+        for collection in payload["d"]:
+            if date_match := re.search(date_regex, collection["Termin"]):
+                timestamp = float(date_match.group())
+                date_ = datetime.fromtimestamp(timestamp / 1000, timezone.utc).date()
+                waste_type = collection["Abfuhrplan"]["GefaesstarifArt"]["Abfallart"][
+                    "Name"
+                ]
+                icon = None
+
+                for icon_type, tested_icon in ICON_MAP.items():
+                    if icon_type.lower() in waste_type.lower():
+                        icon = tested_icon
+
+                if self.show_volume:
+                    vol_key = "VolumenObj" if self.new_params else "Volumen"
+                    volume = int(
+                        collection["Abfuhrplan"]["GefaesstarifArt"][vol_key][
+                            "VolumenWert"
+                        ]
+                    )
+                    waste_type = f"{waste_type} ({volume} l)"
+
+                entries.add(CollectionEntry(date_, waste_type, icon))
+
+        if len(entries) == 0:
+            raise ValueError(
+                "No collections found! Please verify that your configuration is correct."
+            )
+
+        return [entry.export() for entry in entries]
+
+    def fetch_district_id(self, session: requests.Session) -> int:
+        res = session.get(
+            f"{self.api_url}/OrteMitOrtsteilen",
+            headers=API_HEADERS,
+        )
+        res.raise_for_status()
+        payload: DistrictsRes = res.json()
+
+        try:
+            return next(
+                entry["OrteId"]
+                for entry in payload["d"]
+                if entry["Ortsname"] == self.district
+                and entry["Ortsteilname"] == self.subdistrict
+            )
+        except StopIteration:
+            district_match = next(
+                (
+                    entry["OrteId"]
+                    for entry in payload["d"]
+                    if entry["Ortsname"] == self.district
+                ),
+                None,
+            )
+            if district_match:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "subdistrict",
+                    self.subdistrict,
+                    [
+                        entry["Ortsteilname"]
+                        for entry in payload["d"]
+                        if entry["Ortsname"] == self.district
+                    ],
+                ) from None
+            raise SourceArgumentNotFoundWithSuggestions(
+                "district",
+                self.district,
+                {entry["Ortsname"] for entry in payload["d"]},
+            ) from None
+
+    def fetch_street_id(self, session: requests.Session, district_id: int):
+        res = session.get(
+            f"{self.api_url}/Strassen",
+            params={
+                "$filter": f"Ort/OrteId eq {district_id} and OrtsteilName eq {quote_none(self.subdistrict)}",
+                "$orderby": "Name asc",
+            },
+            headers=API_HEADERS,
+        )
+        res.raise_for_status()
+        payload: StreetsRes = res.json()
+
+        try:
+            return next(
+                entry["StrassenId"]
+                for entry in payload["d"]
+                if entry["Name"] == self.street
+            )
+        except StopIteration:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self.street, [entry["Name"] for entry in payload["d"]]
+            ) from None
+
+
+# Typed dictionaries for the API
+# Automatically generated using https://pytyper.dev/
+
+
+class DistrictRes(TypedDict):
+    OrteId: int
+    Ortsname: str
+    Ortsteilname: str | None
+
+
+class DistrictsRes(TypedDict):
+    d: list[DistrictRes]
+
+
+class StreetRes(TypedDict):
+    StrassenId: int
+    Name: str
+    Plz: str
+
+
+class StreetsRes(TypedDict):
+    d: list[StreetRes]
+
+
+class Capacity(TypedDict):
+    VolumenId: int
+    VolumenWert: str
+
+
+class WasteType(TypedDict):
+    AbfallartenId: int
+    Code: str
+    Name: str
+    Farbe: str
+    IsBio: bool
+    IsPapier: bool
+    IsRest: bool
+    IsWertstoff: bool
+    Bemerkung: None
+    Aktiv: None
+    IsSchadstoff: None
+
+
+class ContainerType(TypedDict):
+    GefaesstarifArtenId: int
+    BescheidText: None
+    BescheidTextLeerungsgebuehr: None
+    Bezeichnung: str
+    GefaesstarifArtVerwenden: bool
+    GefaesstarifArtVerwendenAbfallkalender: bool
+    Bemerkung: None
+    Volumen: Capacity
+    Abfallart: WasteType
+    # Abfuhrrhythmus: Abfuhrrhythmus
+
+
+class CollectionPlan(TypedDict):
+    AbfuhrplaeneId: int
+    Jahr: int
+    GefaesstarifArt: ContainerType
+    # AbfallartenObj: Abfuhrrhythmus
+
+
+class CollectionRes(TypedDict):
+    AbfuhrtermineId: int
+    Termin: str
+    Abfuhrplan: CollectionPlan
+
+
+class CollectionsRes(TypedDict):
+    d: list[CollectionRes]

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

@@ -0,0 +1,85 @@
+from typing import ClassVar
+
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Gemeinde Bürmoos"
+DESCRIPTION = "Source for Gemeinde Bürmoos, Austria."
+URL = "https://www.buermoos.at"
+COUNTRY = "at"
+SOURCE_CODEOWNERS = ["@bbr111"]
+
+TEST_CASES: dict[str, dict] = {
+    "Birkenstraße 76a": {
+        "strasse": "Birkenstraße",
+        "hausnummer": "76a",
+    },
+    "Almweg 2": {
+        "strasse": "Almweg",
+        "hausnummer": "2",
+    },
+}
+
+ICON_MAP = {
+    "Biomüllabfuhr": Icons.ORGANIC,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Altpapier": Icons.PAPER,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Sperrmüll": Icons.BULKY,
+    "Altglas": Icons.GLASS,
+    "Problemstoff": Icons.HAZARDOUS,
+    "GELB": Icons.PLASTIC_PACKAGING,
+    "WEIß": Icons.GENERAL_WASTE,
+    "ROT": Icons.GENERAL_WASTE,
+    "LVP": Icons.PLASTIC_PACKAGING,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "strasse": "Street",
+        "hausnummer": "House number",
+    },
+    "de": {
+        "strasse": "Straße",
+        "hausnummer": "Hausnummer",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "strasse": "Street name as listed in the Bürmoos waste calendar dropdown.",
+        "hausnummer": "House number as listed in the Bürmoos waste calendar dropdown.",
+    },
+    "de": {
+        "strasse": "Straßenname wie in der Abfallkalender-Auswahl von Bürmoos aufgeführt.",
+        "hausnummer": "Hausnummer wie in der Abfallkalender-Auswahl von Bürmoos aufgeführt.",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://www.buermoos.at/Service/Aktuelles/Muellkalender, pick your "
+        "street and house number from the dropdowns, and use the same values for "
+        "'strasse' and 'hausnummer'."
+    ),
+    "de": (
+        "Öffnen Sie https://www.buermoos.at/Service/Aktuelles/Muellkalender, wählen "
+        "Sie Ihre Straße und Hausnummer aus den Dropdown-Menüs, und verwenden Sie "
+        "dieselben Werte für 'strasse' und 'hausnummer'."
+    ),
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://www.buermoos.at"
+    ICON_MAP = ICON_MAP
+    SELECTION_URL = "https://www.buermoos.at/Service/Aktuelles/Muellkalender"
+    LOOKAHEAD_DAYS = 365
+    MAX_PAGES = 30
+    QUERY_PARAMS: ClassVar = {
+        "sprache": "1",
+        "menuonr": "219233420",
+    }
+
+    def __init__(self, strasse: str, hausnummer: str | int):
+        super().__init__(strasse=strasse, hausnummer=hausnummer)

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

@@ -0,0 +1,115 @@
+from datetime import date, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Bundaberg Regional Council"
+DESCRIPTION = "Source for Bundaberg Regional Council, QLD, Australia."
+URL = "https://www.bundaberg.qld.gov.au"
+TEST_CASES = {
+    "10 Maynard Street Avenell Heights": {
+        "street_number": "10",
+        "street_name": "Maynard",
+        "suburb": "AVENELL HEIGHTS",
+    },
+    "1 Bourbong Street Bundaberg East": {
+        "street_number": "1",
+        "street_name": "Bourbong",
+        "suburb": "BUNDABERG EAST",
+    },
+}
+
+API_URL = "https://microapps.bundaberg.qld.gov.au/bin_dates/livesearch.php"
+# Guide date (Sunday) used to determine Week A vs B for fortnightly recycling
+GUIDE_DATE = date(2020, 10, 18)
+HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+
+# JavaScript Date.getDay() (0=Sun) → Python weekday() (0=Mon)
+_JS_TO_PY_WEEKDAY = {0: 6, 1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5}
+
+
+def _week_code(d: date) -> str:
+    return "A" if ((d - GUIDE_DATE).days // 7) % 2 == 0 else "B"
+
+
+class Source:
+    def __init__(self, street_number: str, street_name: str, suburb: str = ""):
+        self._street_number = str(street_number)
+        self._street_name = street_name
+        self._suburb = suburb.upper()
+
+    def fetch(self) -> list[Collection]:
+        query = f"{self._street_number} {self._street_name}"
+
+        r = requests.get(API_URL, params={"q": query}, headers=HEADERS)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        divs = soup.find_all("div")
+
+        if not divs:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_number/street_name", query, []
+            )
+
+        # Pick the best match: exact suburb match if provided, otherwise first result
+        match = None
+        if self._suburb:
+            for div in divs:
+                if self._suburb in div["id"].upper():
+                    match = div
+                    break
+            if match is None:
+                suggestions = [d.get_text(strip=True) for d in divs]
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "suburb", self._suburb, suggestions
+                )
+        else:
+            match = divs[0]
+
+        parts = match["id"].split(",")
+
+        # Format: address,wasteDayCode,recDayCode,recWeekCode
+        #      or address,wasteDayCode,recDayCode,recWeekCode,newWaste,newRec,newRecWeek
+        # Post-2022 changeover: use new codes when present
+        if len(parts) >= 7:
+            waste_js = int(parts[4])
+            rec_js = int(parts[5])
+            rec_week = parts[6].strip()
+        elif len(parts) >= 4:
+            waste_js = int(parts[1])
+            rec_js = int(parts[2])
+            rec_week = parts[3].strip()
+        else:
+            raise ValueError(f"Unexpected response format: {match['id']}")
+
+        waste_weekday = _JS_TO_PY_WEEKDAY[waste_js]
+        rec_weekday = _JS_TO_PY_WEEKDAY[rec_js]
+
+        today = date.today()
+        collections: list[Collection] = []
+
+        # General waste: weekly
+        d = today + timedelta(days=(waste_weekday - today.weekday()) % 7)
+        for _ in range(52):
+            collections.append(
+                Collection(d, "General Waste", ICON_MAP["General Waste"])
+            )
+            d += timedelta(weeks=1)
+
+        # Recycling: fortnightly on rec_weekday in rec_week
+        d = today + timedelta(days=(rec_weekday - today.weekday()) % 7)
+        if _week_code(d) != rec_week:
+            d += timedelta(weeks=1)
+        for _ in range(26):
+            collections.append(Collection(d, "Recycling", ICON_MAP["Recycling"]))
+            d += timedelta(weeks=2)
+
+        return collections