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

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

@@ -0,0 +1,232 @@
+import datetime
+import re
+import time
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentNotFound,
+)
+
+TITLE = "Aberdeen City Council"
+DESCRIPTION = (
+    "Source script for the Aberdeen City Council bin collection calendar "
+    "(integration.aberdeencity.gov.uk Granicus Firmstep self-service form)."
+)
+URL = "https://www.aberdeencity.gov.uk/"
+COUNTRY = "uk"
+
+# The Firmstep "AchieveForms" platform exposes the bin lookup as a two-step
+# apibroker/runLookup flow. Each step is keyed by a hardcoded lookup id that
+# the council embeds in the form's compiled definition. These were captured
+# from the live form's network traffic; they're stable until the council
+# republishes the form.
+LOOKUP_ID_GET_TOKEN = "583c08ffc47fe"
+LOOKUP_ID_GET_SCHEDULE = "5a3141caf4016"
+
+SESSION_URL = (
+    "https://integration.aberdeencity.gov.uk/authapi/isauthenticated"
+    "?uri=https%253A%252F%252Fintegration.aberdeencity.gov.uk%252Fservice"
+    "%252Fbin_collection_calendar___view"
+    "&hostname=integration.aberdeencity.gov.uk&withCredentials=true"
+)
+API_URL = "https://integration.aberdeencity.gov.uk/apibroker/runLookup"
+
+TEST_CASES = {
+    "179 Skene Street, AB10 1QN": {"uprn": "9051064786"},
+}
+
+# Aberdeen reports waste types as compact identifiers (no spaces) — the
+# API returns rows keyed `GeneralDate1`, `RecyclingDate1`, `GardenDate1`,
+# etc. plus matching `Count<type>` totals. Verified by hitting the live
+# endpoint with a known-invalid UPRN: returns `CountGarden`, `CountRecycling`,
+# `CountGeneral` so those three are the canonical streams. Map covers
+# observed types plus reasonable guesses for households that subscribe to
+# additional services (food, mixed recycling) — extra unmapped names just
+# return without an icon, no breakage.
+ICON_MAP = {
+    "General": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Mixed Recycling": Icons.RECYCLING,
+    "Garden": Icons.GARDEN,
+    "Food": Icons.BIO_KITCHEN,
+    "Food and Garden": Icons.ORGANIC,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Find your UPRN (Unique Property Reference Number) for your address "
+        "using https://www.findmyaddress.co.uk/ or your council documents."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (required)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "UPRN",
+    },
+}
+
+
+# `GeneralWasteDate1`, `MixedRecyclingDate2`, etc. — bin type prefix + DateN.
+_DATE_KEY_RE = re.compile(r"^(.*?)Date\d+$")
+_COUNT_KEY_RE = re.compile(r"^Count")
+
+_HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "User-Agent": "Mozilla/5.0",
+    "X-Requested-With": "XMLHttpRequest",
+    "Referer": (
+        "https://integration.aberdeencity.gov.uk/fillform/"
+        "?iframe_id=fillform-frame-1&db_id="
+    ),
+}
+
+
+def _split_camel(name: str) -> str:
+    """`GeneralWaste` -> `General Waste`, `MixedRecycling` -> `Mixed Recycling`.
+
+    The API returns waste-type names as Pascal-case identifiers; split them
+    on capital-letter boundaries so the icon map and user-visible labels
+    line up.
+    """
+    return re.sub(r"(?<!^)(?=[A-Z])", " ", name).strip()
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        # Step 1: obtain a sid + a request-specific token. The token is
+        # returned by the first runLookup call and bound to this session.
+        auth_resp = session.get(SESSION_URL, headers=_HEADERS, timeout=30)
+        auth_resp.raise_for_status()
+        try:
+            sid = auth_resp.json()["auth-session"]
+        except (ValueError, KeyError) as err:
+            raise SourceArgumentException(
+                "uprn",
+                f"Could not establish session with Aberdeen form: {err}",
+            ) from err
+
+        token_params = {
+            "id": LOOKUP_ID_GET_TOKEN,
+            "repeat_against": "",
+            "noRetry": "true",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+        token_resp = session.post(
+            API_URL, headers=_HEADERS, params=token_params, timeout=30
+        )
+        token_resp.raise_for_status()
+        try:
+            token_row = token_resp.json()["integration"]["transformed"]["rows_data"][
+                "0"
+            ]
+            token = token_row["token"]
+        except (ValueError, KeyError, TypeError) as err:
+            raise SourceArgumentException(
+                "uprn",
+                f"Aberdeen token request returned unexpected payload: {err}",
+            ) from err
+
+        # Step 2: fetch the schedule for the UPRN.
+        today = datetime.date.today()
+        payload = {
+            "formValues": {
+                "Section 1": {
+                    "nauprn": {"value": self._uprn},
+                    "token": {"value": token},
+                    "mindate": {"value": today.strftime("%Y-%m-%d")},
+                    "maxdate": {
+                        "value": (today + datetime.timedelta(days=60)).strftime(
+                            "%Y-%m-%d"
+                        )
+                    },
+                }
+            }
+        }
+        sched_params = dict(token_params)
+        sched_params["id"] = LOOKUP_ID_GET_SCHEDULE
+        sched_params["_"] = str(int(time.time() * 1000))
+
+        sched_resp = session.post(
+            API_URL,
+            headers=_HEADERS,
+            params=sched_params,
+            json=payload,
+            timeout=30,
+        )
+        sched_resp.raise_for_status()
+        try:
+            rows = sched_resp.json()["integration"]["transformed"]["rows_data"]["0"]
+        except (ValueError, KeyError, TypeError) as err:
+            raise SourceArgumentException(
+                "uprn",
+                f"Aberdeen schedule request returned unexpected payload: {err}",
+            ) from err
+
+        if not isinstance(rows, dict) or not rows:
+            raise SourceArgumentNotFound(
+                "uprn",
+                self._uprn,
+                "No collection data returned for this UPRN.",
+            )
+
+        # Aberdeen's API responds to an *invalid* UPRN with only `Count<type>`
+        # rows holding `"0"` and zero `<type>Date<n>` keys. Distinguish that
+        # case from a real "API changed" failure: if no date keys exist at
+        # all, it's a not-found, not a parsing bug.
+        has_date_keys = any(_DATE_KEY_RE.match(k) for k in rows)
+        if not has_date_keys:
+            raise SourceArgumentNotFound(
+                "uprn",
+                self._uprn,
+                "No collections found for this UPRN. Check the number is "
+                "correct and that the property is within the City of Aberdeen.",
+            )
+
+        entries: list[Collection] = []
+        for key, value in rows.items():
+            if _COUNT_KEY_RE.match(key):
+                continue
+            m = _DATE_KEY_RE.match(key)
+            if not m or not value:
+                continue
+            bin_type_camel = m.group(1)
+            bin_type = _split_camel(bin_type_camel)
+            try:
+                # API returns "Tuesday 28 January 2026" — locale-stable English
+                date = datetime.datetime.strptime(value, "%A %d %B %Y").date()
+            except (ValueError, TypeError):
+                continue
+            entries.append(
+                Collection(
+                    date=date,
+                    t=bin_type,
+                    icon=ICON_MAP.get(bin_type),
+                )
+            )
+
+        if not entries:
+            raise SourceArgumentException(
+                "uprn",
+                f"Aberdeen returned {len(rows)} rows including date keys but "
+                "none parsed. The API format may have changed.",
+            )
+
+        return entries

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

@@ -0,0 +1,56 @@
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+# Include work around for SSL UNSAFE_LEGACY_RENEGOTIATION_DISABLED error
+from waste_collection_schedule.service.SSLError import get_legacy_session
+
+TITLE = "Aberdeenshire Council"
+DESCRIPTION = "Source for Aberdeenshire Council, UK."
+URL = "https://aberdeenshire.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "000151124612"},
+    "Test_002": {"uprn": "000151004105"},
+    "Test_003": {"uprn": "0151035884"},
+    "Test_004": {"uprn": 151170625},
+}
+ICON_MAP = {
+    "Mixed recycling and food waste": Icons.BIO_KITCHEN,
+    "Refuse and food waste": Icons.BIO_KITCHEN,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "An easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering in your address details."
+    },
+    "de": {
+        "uprn": "Eine einfache Möglichkeit, Ihre Unique Property Reference Number (UPRN) zu finden, besteht darin, auf https://www.findmyaddress.co.uk/ zu gehen und Ihre Adressdaten einzugeben."
+    },
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn).zfill(12)
+
+    def fetch(self):
+        response = get_legacy_session().get(
+            f"https://online.aberdeenshire.gov.uk/Apps/Waste-Collections/Routes/Route/{self._uprn}"
+        )
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        entries = []
+
+        tr = soup.findAll("tr")
+        for item in tr[1:]:  # Ignore table header row
+            td = item.findAll("td")
+            entries.append(
+                Collection(
+                    date=datetime.strptime(td[0].text.split(" ")[0], "%d/%m/%Y").date(),
+                    t=td[1].text,
+                    icon=ICON_MAP.get(td[1].text),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,52 @@
+# There was an ICS source but the ICS file was not stored permanently and would be removed after a few days.
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfallbehandlungsgesellschaft Havelland mbH (abh)"
+DESCRIPTION = "Source for Abfallbehandlungsgesellschaft Havelland mbH."
+URL = "https://abfall-havelland.de/"
+TEST_CASES = {
+    "Wustermark Drosselgasse": {
+        "ort": "Wustermark",
+        "strasse": "Drosselgasse",
+    },
+    "Milow Friedhofstr.": {"ort": "Milow", "strasse": "Friedhofstr."},
+    "Falkensee Ahornstr.": {"ort": "Falkensee", "strasse": "Ahornstr."},
+    "Falkensee complex street name": {
+        "ort": "Falkensee",
+        "strasse": "Karl-Marx-Str. (von Friedrich-Hahn-Str. bis Am Schlaggraben)",
+    },
+}
+
+ICON_MAP = {
+    "mülltonne": Icons.GENERAL_WASTE,
+    "bio-tonne": Icons.ORGANIC,
+    "papier": Icons.PAPER,
+    "gelbe": Icons.RECYCLING,
+}
+
+API_URL = "https://www.abfall-havelland.de/ics.php"
+
+
+class Source:
+    def __init__(self, ort: str, strasse: str):
+        self._ort: str = ort
+        self._strasse: str = strasse
+        self._ics = ICS(split_at=", ")
+
+    def fetch(self) -> list[Collection]:
+        args = {"city": self._ort, "street": self._strasse}
+
+        # ics content
+        r = requests.get(API_URL, params=args)
+        r.raise_for_status()
+        dates = self._ics.convert(r.text)
+        entries = []
+        for d in dates:
+            bin_type = d[1].replace(" - Abholtermin", "")
+            entries.append(
+                Collection(d[0], bin_type, ICON_MAP.get(bin_type.split()[0].lower()))
+            )
+
+        return entries

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

@@ -0,0 +1,233 @@
+import datetime
+import logging
+import re
+from html.parser import HTMLParser
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.AbfallIO import SERVICE_MAP
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfall.IO / AbfallPlus"
+DESCRIPTION = (
+    "Source for AbfallPlus.de waste collection. Service is hosted on abfall.io."
+)
+URL = "https://www.abfallplus.de"
+COUNTRY = "de"
+
+
+def EXTRA_INFO():
+    return [
+        {
+            "title": s["title"],
+            "url": s["url"],
+            "default_params": {"key": s["service_id"]},
+        }
+        for s in SERVICE_MAP
+    ]
+
+
+TEST_CASES = {
+    "Landshut": {
+        "key": "bd0c2d0177a0849a905cded5cb734a6f",
+        "f_id_kommune": 2655,
+        "f_id_bezirk": 2655,
+        "f_id_strasse": 763,
+        # "f_abfallarten": [31, 17, 19, 218]
+    },
+    "Landshut (f_abfallarten as comma separated string)": {
+        "key": "bd0c2d0177a0849a905cded5cb734a6f",
+        "f_id_kommune": 2655,
+        "f_id_bezirk": 2655,
+        "f_id_strasse": 763,
+        "f_abfallarten": "31,17,19,218",
+    },
+    "Schoenmackers": {
+        "key": "e5543a3e190cb8d91c645660ad60965f",
+        "f_id_kommune": 3682,
+        "f_id_strasse": "3682adenauerplatz",
+        "f_id_strasse_hnr": "20417",
+        # "f_abfallarten": [691,692,696,695,694,701,700,693,703,704,697,699],
+    },
+    "Ludwigshafen am Rhein": {
+        "key": "6efba91e69a5b454ac0ae3497978fe1d",
+        "f_id_kommune": "5916",
+        "f_id_strasse": "5916abteistrasse",
+        "f_id_strasse_hnr": 33,
+    },
+    "AWB Limburg-Weilburg": {
+        "key": "0ff491ffdf614d6f34870659c0c8d917",
+        "f_id_kommune": 6031,
+        "f_id_strasse": 621,
+        "f_id_strasse_hnr": 872,
+        "f_abfallarten": [27, 28, 17, 67],
+    },
+    "Landkreis Prignitz, Gemeinde Karstädt, Blüthen": {
+        "key": "798f59a75627f5d7686dab0c7226c877",
+        "f_id_kommune": 3229,
+        "f_id_bezirk": 31,
+        "f_id_strasse": 322,
+        "f_id_strasse_hnr": 323,
+    },
+    "Landkreis Prignitz, Gemeinde Karstädt, restliche Straßen": {
+        "key": "798f59a75627f5d7686dab0c7226c877",
+        "f_id_kommune": 3229,
+        "f_id_bezirk": 41,
+        "f_id_strasse": 333,
+        "f_id_strasse_hnr": 333,
+    },
+    "Landkreis Landshut, Altfraunhofen, Am Bäckerfeld": {
+        "key": "04b7561b94f2cbaa171cd85bb6aa56de",
+        "f_id_kommune": 3791,
+        "f_id_strasse": 314,
+    },
+}
+_LOGGER = logging.getLogger(__name__)
+
+MODUS_KEY = "d6c5855a62cf32a4dadbc2831f0f295f"
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"
+}
+
+
+# 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 d["type"] == "hidden":
+                self._args[d["name"]] = d["value"]
+
+
+class Source:
+    def __init__(
+        self,
+        key: str,
+        f_id_kommune: str | int,
+        f_id_strasse: str | int,
+        f_id_bezirk: str | int | None = None,
+        f_id_strasse_hnr: str | int | None = None,
+        f_abfallarten: list[str] | str | None = None,
+    ):
+        if isinstance(f_abfallarten, str):
+            # UI config flow stores this as a comma separated string
+            f_abfallarten = [x.strip() for x in f_abfallarten.split(",") if x.strip()]
+        elif f_abfallarten is None:
+            f_abfallarten = []
+        self._key = key
+        self._kommune = f_id_kommune
+        self._bezirk = f_id_bezirk
+        self._strasse = f_id_strasse
+        self._strasse_hnr = f_id_strasse_hnr
+        self._abfallarten = f_abfallarten  # list of waste type ids
+        self._ics = ICS()
+
+    def _step(self, waction: str, args: dict) -> dict:
+        r = requests.post(
+            "https://api.abfall.io",
+            params={"key": self._key, "modus": MODUS_KEY, "waction": waction},
+            data=args,
+            headers=HEADERS,
+            timeout=30,
+        )
+        r.raise_for_status()
+        p = HiddenInputParser()
+        p.feed(r.text)
+        args.update(p.args)
+        return args
+
+    def fetch(self):
+        # get token
+        params = {"key": self._key, "modus": MODUS_KEY, "waction": "init"}
+
+        r = requests.post("https://api.abfall.io", params=params, headers=HEADERS)
+        if r.status_code == 401:
+            raise ValueError(
+                f"API key '{self._key}' is no longer valid for the legacy abfall.io API. "
+                "This provider has likely migrated to the new abfall.io v3 API. "
+                "Please switch to the 'Abfall.IO / AbfallPlus (GraphQL)' source (abfall_io_graphql) instead, "
+                "which supports the v3 API. "
+                "See https://github.com/mampfes/hacs_waste_collection_schedule/blob/master/doc/source/abfall_io_graphql.md"
+            )
+        r.raise_for_status()
+
+        # add all hidden input fields to form data
+        # There is one hidden field which acts as a token:
+        # It consists of a UUID key and a UUID value.
+        p = HiddenInputParser()
+        p.feed(r.text)
+        args = p.args
+
+        args["f_id_kommune"] = self._kommune
+
+        # For services with a bezirk (district) selection, go through the
+        # intermediate steps so that f_posts_json[] accumulates the correct
+        # server-side state for each step, which is required for the final
+        # export to return results.
+        if self._bezirk is not None:
+            args["f_id_bezirk"] = self._bezirk
+            args = self._step("auswahl_bezirk_set", args)
+
+            args["f_id_strasse"] = self._strasse
+            args = self._step("auswahl_strasse_set", args)
+
+            if self._strasse_hnr is not None:
+                args["f_id_strasse_hnr"] = self._strasse_hnr
+                args = self._step("auswahl_hnr_set", args)
+        else:
+            args["f_id_strasse"] = self._strasse
+
+            if self._strasse_hnr is not None:
+                args["f_id_strasse_hnr"] = self._strasse_hnr
+
+        for i in range(len(self._abfallarten)):
+            args[f"f_id_abfalltyp_{i}"] = self._abfallarten[i]
+
+        args["f_abfallarten_index_max"] = len(self._abfallarten)
+        args["f_abfallarten"] = ",".join(str(x) for x in self._abfallarten)
+
+        now = datetime.datetime.now()
+        date2 = now + datetime.timedelta(days=365)
+        args["f_zeitraum"] = f"{now.strftime('%Y%m%d')}-{date2.strftime('%Y%m%d')}"
+
+        params = {"key": self._key, "modus": MODUS_KEY, "waction": "export_ics"}
+
+        # get csv file
+        r = requests.post(
+            "https://api.abfall.io", params=params, data=args, headers=HEADERS
+        )
+
+        # parse ics file
+        r.encoding = "utf-8"  # requests doesn't guess the encoding correctly
+        ics_file = r.text
+
+        # Remove all lines starting with <b
+        # This warning are caused for customers which use an extra radiobutton
+        # list to add special waste types:
+        # - AWB Limburg-Weilheim uses this list to select a "Sonderabfall <city>"
+        #   waste type. The warning could be removed by adding the extra config
+        #   option "f_abfallarten" with the following values [27, 28, 17, 67]
+        html_warnings = re.findall(r"\<b.*", ics_file)
+        if html_warnings:
+            ics_file = re.sub(r"\<br.*|\<b.*", "\\r", ics_file)
+            # _LOGGER.warning("Html tags removed from ics file: " + ', '.join(html_warnings))
+
+        entries = []
+        for ev in self._ics.convert_events(ics_file):
+            entries.append(
+                Collection(
+                    ev.date,
+                    ev.title,
+                    location=ev.location,
+                    description=ev.description,
+                )
+            )
+        return entries